Migrate casting ConversionUtils methods to Types

ctrueden · ctrueden · commit 4aefc55a6fed · 2018-03-02T16:02:54.000-06:00
The following methods moved:

* ConversionUtils#canAssign(Class, Class) -&gt; Types.isAssignable(Type, Type)
* ConversionUtils#canCast(Class, Class) -&gt; Types.isAssignable(Type, Type)
* ConversionUtils#canAssign(Object, Class) -&gt; Types.isInstance(Object, Class)
* ConversionUtils#canCast(Object, Class) -&gt; Types.isInstance(Object, Class)
* ConversionUtils#cast(Object, Class) -&gt; Types.cast(Object, class)

Note that Types.isAssignable(Type, Type) already existed; this migration
simply deprecates the ConversionUtils method and moves the unit tests.

This also changes Types.isAssignable to throw NullPointerException
if a null destination type is given, since it never makes sense to
cast from anything to a null type.
diff --git a/src/main/java/org/scijava/util/ConversionUtils.java b/src/main/java/org/scijava/util/ConversionUtils.java
@@ -87,63 +87,6 @@ public static <T> T convertToEnum(final String src, final Class<T> dest) {
 		}
 	}
 
-	/**
-	 * Casts the given object to the specified type, or null if the types are
-	 * incompatible.
-	 */
-	public static <T> T cast(final Object src, final Class<T> dest) {
-		if (!canCast(src, dest)) return null;
-		@SuppressWarnings("unchecked")
-		final T result = (T) src;
-		return result;
-	}
-
-	/**
-	 * Checks whether objects of the given class can be assigned to the specified
-	 * type. Unlike {@link Class#isAssignableFrom(Class)}, this method considers
-	 * auto-unboxing.
-	 * 
-	 * @return true If the destination class is assignable from the source one, or
-	 *         if the source class is null and destination class is non-null.
-	 */
-	public static boolean canAssign(final Class<?> src, final Class<?> dest) {
-		return canCast(src, dest);
-	}
-
-	/**
-	 * Checks whether the given object can be assigned to the specified type.
-	 * Unlike {@link Class#isAssignableFrom(Class)}, this method considers
-	 * auto-unboxing.
-	 * 
-	 * @return true If the destination class is assignable from the source
-	 *         object's class, or if the source object is null and destionation
-	 *         class is non-null.
-	 */
-	public static boolean canAssign(final Object src, final Class<?> dest) {
-		return canCast(src, dest);
-	}
-
-	/**
-	 * @deprecated use {@link #canAssign(Class, Class)} instead
-	 */
-	@Deprecated
-	public static boolean canCast(final Class<?> src, final Class<?> dest) {
-		if (dest == null) return false;
-		if (src == null) return true;
-		final Class<?> saneSrc = getNonprimitiveType(src);
-		final Class<?> saneDest = getNonprimitiveType(dest);
-		return saneDest.isAssignableFrom(saneSrc);
-	}
-
-	/**
-	 * @deprecated use {@link #canAssign(Object, Class)} instead
-	 */
-	@Deprecated
-	public static boolean canCast(final Object src, final Class<?> dest) {
-		if (dest == null) return false;
-		return src == null || canCast(src.getClass(), dest);
-	}
-
 	// -- ConvertService setter --
 
 	/**
@@ -152,8 +95,8 @@ public static boolean canCast(final Object src, final Class<?> dest) {
 	public static void setDelegateService(final ConvertService convertService,
 		final double priority)
 	{
-		if (ConversionUtils.convertService == null ||
-			Double.compare(priority, servicePriority) > 0)
+		if (ConversionUtils.convertService == null || Double.compare(priority,
+			servicePriority) > 0)
 		{
 			ConversionUtils.convertService = convertService;
 			servicePriority = priority;
@@ -228,6 +171,42 @@ public static Class<?> getClass(final Type type) {
 		return Types.raw(type);
 	}
 
+	/** @deprecated use {@link Types#cast} */
+	@Deprecated
+	public static <T> T cast(final Object src, final Class<T> dest) {
+		if (!canCast(src, dest)) return null;
+		@SuppressWarnings("unchecked")
+		final T result = (T) src;
+		return result;
+	}
+
+	/** @deprecated use {@link Types#isAssignable} */
+	@Deprecated
+	public static boolean canAssign(final Class<?> src, final Class<?> dest) {
+		return canCast(src, dest);
+	}
+
+	/** @deprecated use {@link Types#isInstance} */
+	@Deprecated
+	public static boolean canAssign(final Object src, final Class<?> dest) {
+		return canCast(src, dest);
+	}
+
+	/** @deprecated use {@link Types#isAssignable} */
+	@Deprecated
+	public static boolean canCast(final Class<?> src, final Class<?> dest) {
+		if (dest == null) return false;
+		if (src == null) return true;
+		return Types.isAssignable(Types.box(src), Types.box(dest));
+	}
+
+	/** @deprecated use {@link Types#isInstance} */
+	@Deprecated
+	public static boolean canCast(final Object src, final Class<?> dest) {
+		if (dest == null) return false;
+		return src == null || canCast(src.getClass(), dest);
+	}
+
 	/** @deprecated use {@link Types#raws} and {@link Types#component} */
 	@Deprecated
 	public static Class<?> getComponentClass(final Type type) {
@@ -252,7 +231,7 @@ public static <T> T getNullValue(final Class<T> type) {
 		return Types.nullValue(type);
 	}
 
-	//-- Helper methods --
+	// -- Helper methods --
 
 	/**
 	 * Gets the {@link Converter} to use for the given conversion request. If the
diff --git a/src/main/java/org/scijava/util/Types.java b/src/main/java/org/scijava/util/Types.java
@@ -546,6 +546,30 @@ public static boolean isAssignable(final Type source, final Type target) {
 		return TypeUtils.isAssignable(source, target);
 	}
 
+	/**
+	 * Checks whether the given object can be cast to the specified type.
+	 *
+	 * @return true If the destination class is assignable from the source
+	 *         object's class, or if the source object is null and destination
+	 *         class is non-null.
+	 * @see #cast(Object, Class)
+	 */
+	public static boolean isInstance(final Object obj, final Class<?> dest) {
+		if (dest == null) return false;
+		return obj == null || dest.isInstance(obj);
+	}
+
+	/**
+	 * Casts the given object to the specified type, or null if the types are
+	 * incompatible.
+	 */
+	public static <T> T cast(final Object src, final Class<T> dest) {
+		if (!isInstance(src, dest)) return null;
+		@SuppressWarnings("unchecked")
+		final T result = (T) src;
+		return result;
+	}
+
 	/**
 	 * Creates a new {@link ParameterizedType} of the given class together with
 	 * the specified type arguments.
@@ -978,8 +1002,12 @@ public int hashCode() {
 		 * @param type the subject type to be assigned to the target type
 		 * @param toType the target type
 		 * @return {@code true} if {@code type} is assignable to {@code toType}.
+		 * @throws NullPointerException if {@code toType} is null.
 		 */
 		public static boolean isAssignable(final Type type, final Type toType) {
+			if (toType == null) {
+				throw new NullPointerException("Destination type is null");
+			}
 			return isAssignable(type, toType, null);
 		}
 
diff --git a/src/test/java/org/scijava/util/ConversionUtilsTest.java b/src/test/java/org/scijava/util/ConversionUtilsTest.java
@@ -57,63 +57,6 @@
  */
 public class ConversionUtilsTest {
 
-	/** Tests {@link ConversionUtils#canCast(Class, Class)}. */
-	@Test
-	public void testCanCast() {
-		// check casting to superclass
-		assertTrue(ConversionUtils.canCast(String.class, Object.class));
-
-		// check casting to interface
-		assertTrue(ConversionUtils.canCast(ArrayList.class, Collection.class));
-
-		// casting numeric primitives is not supported
-		assertFalse(ConversionUtils.canCast(double.class, float.class));
-		assertFalse(ConversionUtils.canCast(float.class, double.class));
-
-		// check casting with boxing
-		assertTrue(ConversionUtils.canCast(int.class, Number.class));
-
-		// casting from null always works
-		final Class<?> nullClass = null;
-		assertTrue(ConversionUtils.canCast(nullClass, Object.class));
-		assertTrue(ConversionUtils.canCast(nullClass, int[].class));
-		final Object nullObject = null;
-		assertTrue(ConversionUtils.canCast(nullObject, Object.class));
-		assertTrue(ConversionUtils.canCast(nullObject, int[].class));
-
-		// casting to null is not allowed
-		assertFalse(ConversionUtils.canCast(nullClass, null));
-		assertFalse(ConversionUtils.canCast(Object.class, null));
-		assertFalse(ConversionUtils.canCast(nullObject, null));
-		assertFalse(ConversionUtils.canCast(new Object(), null));
-	}
-
-	/** Tests {@link ConversionUtils#cast(Object, Class)}. */
-	@Test
-	public void testCast() {
-		// check casting to superclass
-		final String string = "Hello";
-		final Object stringToObject = ConversionUtils.cast(string, Object.class);
-		assertSame(string, stringToObject);
-
-		// check casting to interface
-		final ArrayList<?> arrayList = new ArrayList<>();
-		final Collection<?> arrayListToCollection =
-			ConversionUtils.cast(arrayList, Collection.class);
-		assertSame(arrayList, arrayListToCollection);
-
-		// casting numeric primitives is not supported
-		final Float doubleToFloat = ConversionUtils.cast(5.1, float.class);
-		assertNull(doubleToFloat);
-		final Double floatToDouble = ConversionUtils.cast(5.1f, double.class);
-		assertNull(floatToDouble);
-
-		// boxing works though
-		final Number intToNumber = ConversionUtils.cast(5, Number.class);
-		assertSame(Integer.class, intToNumber.getClass());
-		assertEquals(5, intToNumber.intValue());
-	}
-
 	/** Tests {@link ConversionUtils#convertToEnum(String, Class)}. */
 	@Test
 	public void testConvertToEnum() {
diff --git a/src/test/java/org/scijava/util/TypesTest.java b/src/test/java/org/scijava/util/TypesTest.java
@@ -389,6 +389,79 @@ class Struct {
 		assertSame(int[].class, paramClass);
 	}
 
+	/** Tests {@link Types#isAssignable(Type, Type)}. */
+	@Test
+	public void testIsAssignable() {
+		// check casting to superclass
+		assertTrue(Types.isAssignable(String.class, Object.class));
+
+		// check casting to interface
+		assertTrue(Types.isAssignable(ArrayList.class, Collection.class));
+
+		// casting numeric primitives is not supported
+		assertFalse(Types.isAssignable(double.class, float.class));
+		assertFalse(Types.isAssignable(float.class, double.class));
+
+		// boxing is not reported to work
+		// TODO: Consider changing this behavior.
+		assertFalse(Types.isAssignable(int.class, Number.class));
+
+		// casting from null always works
+		assertTrue(Types.isAssignable(null, Object.class));
+		assertTrue(Types.isAssignable(null, int[].class));
+	}
+
+	/** Tests {@link Types#isAssignable(Type, Type)} from null to null. */
+	@Test(expected = NullPointerException.class)
+	public void testIsAssignableNullToNull() {
+		Types.isAssignable(null, null);
+	}
+
+	/** Tests {@link Types#isAssignable(Type, Type)} from Class to null. */
+	@Test(expected = NullPointerException.class)
+	public void testIsAssignableClassToNull() {
+		Types.isAssignable(Object.class, null);
+	}
+
+	/** Tests {@link Types#isInstance(Object, Class)}. */
+	@Test
+	public void testIsInstance() {
+		// casting from null always works
+		final Object nullObject = null;
+		assertTrue(Types.isInstance(nullObject, Object.class));
+		assertTrue(Types.isInstance(nullObject, int[].class));
+
+		// casting to null is not allowed
+		assertFalse(Types.isInstance(nullObject, null));
+		assertFalse(Types.isInstance(new Object(), null));
+	}
+
+	/** Tests {@link Types#cast(Object, Class)}. */
+	@Test
+	public void testCast() {
+		// check casting to superclass
+		final String string = "Hello";
+		final Object stringToObject = Types.cast(string, Object.class);
+		assertSame(string, stringToObject);
+
+		// check casting to interface
+		final ArrayList<?> arrayList = new ArrayList<>();
+		final Collection<?> arrayListToCollection = //
+			Types.cast(arrayList, Collection.class);
+		assertSame(arrayList, arrayListToCollection);
+
+		// casting numeric primitives is not supported
+		final Float doubleToFloat = Types.cast(5.1, float.class);
+		assertNull(doubleToFloat);
+		final Double floatToDouble = Types.cast(5.1f, double.class);
+		assertNull(floatToDouble);
+
+		// boxing works though
+		final Number intToNumber = Types.cast(5, Number.class);
+		assertSame(Integer.class, intToNumber.getClass());
+		assertEquals(5, intToNumber.intValue());
+	}
+
 	// -- Helper classes --
 
 	private static class Thing<T> {
