Added support for UUID conversion

Author: bbottema

src/main/java/org/bbottema/javareflection/valueconverter/ValueConversionHelper.java

@@ -25,6 +25,7 @@
 import org.bbottema.javareflection.valueconverter.converters.FileConverters;
 import org.bbottema.javareflection.valueconverter.converters.NumberConverters;
 import org.bbottema.javareflection.valueconverter.converters.StringConverters;
+import org.bbottema.javareflection.valueconverter.converters.UUIDConverters;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -91,6 +92,7 @@ public static void resetDefaultConverters() {
 		defaultConverters.addAll(BooleanConverters.BOOLEAN_CONVERTERS);
 		defaultConverters.addAll(CharacterConverters.CHARACTER_CONVERTERS);
 		defaultConverters.addAll(StringConverters.STRING_CONVERTERS);
+		defaultConverters.addAll(UUIDConverters.UUID_CONVERTERS);
 		defaultConverters.addAll(FileConverters.FILE_CONVERTERS);
 
 		for (ValueFunction<?, ?> numberConverter : defaultConverters) {

src/main/java/org/bbottema/javareflection/valueconverter/converters/StringConverters.java

@@ -32,6 +32,7 @@
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.UUID;
 
 import static org.slf4j.LoggerFactory.getLogger;
 
@@ -50,6 +51,7 @@
  * <li><strong>Double (or primitive double)</strong>: <code>Double.parseDouble(value)</code></li>
  * <li><strong>BigInteger</strong>: <code>BigInteger.valueOf(Long.parseLong(value))</code></li>
  * <li><strong>BigDecimal</strong>: <code>new BigDecimal(value)</code></li>
+ * <li><strong>UUID</strong>: <code>UUID.fromString(value)</code></li>
  * </ol>
  */
 @Nullable
@@ -72,6 +74,7 @@ public final class StringConverters {
 		converters.add(new ValueFunctionImpl<>(String.class, BigInteger.class, new StringToBigIntegerFunction()));
 		converters.add(new ValueFunctionImpl<>(String.class, BigDecimal.class, new StringToBigDecimalFunction()));
 		converters.add(new ValueFunctionImpl<>(String.class, File.class, new StringToFileFunction()));
+		converters.add(new ValueFunctionImpl<>(String.class, UUID.class, new StringToUUIDFunction()));
 		return converters;
 	}
 
@@ -230,4 +233,15 @@ public File apply(String value) {
 			return file;
 		}
 	}
+	
+	private static class StringToUUIDFunction implements Function<String, UUID> {
+		@Override
+		public UUID apply(String value) {
+			try {
+				return UUID.fromString(value);
+			} catch (IllegalArgumentException e) {
+				throw new IncompatibleTypeException(value, String.class, UUID.class);
+			}
+		}
+	}
 }

src/main/java/org/bbottema/javareflection/valueconverter/converters/UUIDConverters.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) ${project.inceptionYear} Benny Bottema ([email protected])
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.bbottema.javareflection.valueconverter.converters;
+
+import lombok.experimental.UtilityClass;
+import org.bbottema.javareflection.util.Function;
+import org.bbottema.javareflection.util.Function.Functions;
+import org.bbottema.javareflection.valueconverter.ValueFunction;
+import org.bbottema.javareflection.valueconverter.ValueFunction.ValueFunctionImpl;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.UUID;
+
+@Nullable
+@UtilityClass
+public final class UUIDConverters {
+	
+	public static final Collection<ValueFunction<UUID, ?>> UUID_CONVERTERS = produceUUIDConverters();
+	
+	private static Collection<ValueFunction<UUID, ?>> produceUUIDConverters() {
+		ArrayList<ValueFunction<UUID, ?>> converters = new ArrayList<>();
+		converters.add(new ValueFunctionImpl<>(UUID.class, UUID.class, Functions.<UUID>identity()));
+		converters.add(new ValueFunctionImpl<>(UUID.class, String.class, new UUIDToStringFunction()));
+		return converters;
+	}
+	
+	private static class UUIDToStringFunction implements Function<UUID, String> {
+		@Override
+		public String apply(UUID value) {
+			return value.toString();
+		}
+	}
+}

src/test/java/org/bbottema/javareflection/valueconverter/ValueConversionHelperTest.java

@@ -23,12 +23,12 @@
 import org.junit.Test;
 import sun.reflect.generics.reflectiveObjects.NotImplementedException;
 
-import java.io.File;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Calendar;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.UUID;
 
 import static java.lang.String.format;
 import static java.util.Arrays.asList;
@@ -273,6 +273,8 @@ public void testConvertStringClassOfQ() {
 		assertThat(ValueConversionHelper.convert("h", String.class)).isEqualTo("h");
 		assertThat(ValueConversionHelper.convert("ONE", TestEnum.class)).isEqualTo(TestEnum.ONE);
 		assertThat(ValueConversionHelper.convert("h", Boolean.class)).isTrue();
+		final UUID uuid = UUID.randomUUID();
+		assertThat(ValueConversionHelper.convert(uuid.toString(), UUID.class)).isEqualTo(uuid);
 		try {
 			ValueConversionHelper.convert("falsef", Boolean.class);
 			fail("should not be able to convert value");
@@ -297,6 +299,24 @@ public void testConvertStringClassOfQ() {
 		} catch (IncompatibleTypeException e) {
 			// OK
 		}
+		try {
+			ValueConversionHelper.convert("", UUID.class);
+			fail("should not be able to convert value");
+		} catch (IncompatibleTypeException e) {
+			// OK
+		}
+		try {
+			ValueConversionHelper.convert("s", UUID.class);
+			fail("should not be able to convert value");
+		} catch (IncompatibleTypeException e) {
+			// OK
+		}
+		try {
+			ValueConversionHelper.convert("s-s-s-s-s", UUID.class);
+			fail("should not be able to convert value");
+		} catch (IncompatibleTypeException e) {
+			// OK
+		}
 	}
 
 	@Test