Migrate ClassUtils.getArrayClass to Types.array

ctrueden · ctrueden · commit f25e92a86e78 · 2018-03-02T16:02:53.000-06:00
This also changes the behavior of the method to throw
IllegalArgumentException, rather than returning null, if
something goes wrong with the creation of the array type.
But the deprecated method preserves the legacy behavior,
for backwards compatibility.

The new behavior is more consistent with the other methods
of the Types class -- and it is better in general for a
reusable library to do proper exception handling. If the
behavior is too bothersome, we could add "boolean quietly"
flags to every method, but it would rather clutter things.
diff --git a/src/main/java/org/scijava/util/ClassUtils.java b/src/main/java/org/scijava/util/ClassUtils.java
@@ -35,7 +35,6 @@
 import java.io.File;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
-import java.lang.reflect.Array;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
@@ -221,25 +220,6 @@ public static Class<?> loadClass(final String name,
 		}
 	}
 
-	/**
-	 * Gets the array class corresponding to the given element type.
-	 * <p>
-	 * For example, {@code getArrayClass(double.class)} returns
-	 * {@code double[].class}.
-	 * </p>
-	 */
-	public static Class<?> getArrayClass(final Class<?> elementClass) {
-		if (elementClass == null) return null;
-		// NB: It appears the reflection API has no built-in way to do this.
-		// So unfortunately, we must allocate a new object and then inspect it.
-		try {
-			return Array.newInstance(elementClass, 0).getClass();
-		}
-		catch (final IllegalArgumentException exc) {
-			return null;
-		}
-	}
-
 	/** Checks whether a class with the given name exists. */
 	public static boolean hasClass(final String className) {
 		return hasClass(className, null);
@@ -689,6 +669,15 @@ public static int compare(final Class<?> c1, final Class<?> c2) {
 
 	// -- Helper methods --
 
+	private static Class<?> arrayOrNull(final Class<?> componentType) {
+		try {
+			return Types.array(componentType);
+		}
+		catch (final IllegalArgumentException exc) {
+			return null;
+		}
+	}
+
 	/**
 	 * Populates the cache of annotated elements for a particular class by looking
 	 * for all inherited and declared instances annotated with the specified
@@ -813,6 +802,12 @@ public static Field getField(final Class<?> c, final String fieldName) {
 		return Types.field(c, fieldName);
 	}
 
+	/** @deprecated Use {@link Types#array(Class)} instead. */
+	@Deprecated
+	public static Class<?> getArrayClass(final Class<?> elementClass) {
+		return Types.raw(arrayOrNull(elementClass));
+	}
+
 	// -- Helper classes --
 
 	/**
diff --git a/src/main/java/org/scijava/util/Types.java b/src/main/java/org/scijava/util/Types.java
@@ -147,6 +147,43 @@ public static Field field(final Class<?> c, final String name) {
 		return field(c.getSuperclass(), name);
 	}
 
+	/**
+	 * Gets the array class corresponding to the given element type.
+	 * <p>
+	 * For example, {@code arrayType(double.class)} returns {@code double[].class}
+	 * .
+	 * </p>
+	 * 
+	 * @param componentType The type of elements which the array possesses
+	 * @throws IllegalArgumentException if the type cannot be the component type
+	 *           of an array (this is the case e.g. for {@code void.class}).
+	 */
+	public static Class<?> array(final Class<?> componentType) {
+		if (componentType == null) return null;
+		// NB: It appears the reflection API has no built-in way to do this.
+		// So unfortunately, we must allocate a new object and then inspect it.
+		return Array.newInstance(componentType, 0).getClass();
+	}
+
+	/**
+	 * Gets the array type&mdash;which might be a {@link Class} or a
+	 * {@link GenericArrayType} depending on the argument&mdash;corresponding to
+	 * the given element type.
+	 * <p>
+	 * For example, {@code arrayType(double.class)} returns {@code double[].class}
+	 * .
+	 * </p>
+	 * 
+	 * @param componentType The type of elements which the array possesses
+	 */
+	public static Type array(final Type componentType) {
+		if (componentType == null) return null;
+		if (componentType instanceof Class) {
+			return array((Class<?>) componentType);
+		}
+		return new TypeUtils.GenericArrayTypeImpl(componentType);
+	}
+
 	/**
 	 * Gets the component type of the given array type, or null if not an array.
 	 */
diff --git a/src/test/java/org/scijava/util/ClassUtilsTest.java b/src/test/java/org/scijava/util/ClassUtilsTest.java
@@ -127,17 +127,6 @@ public void testFailureLoud() {
 		ClassUtils.loadClass("a.non.existent.class", false);
 	}
 
-	@Test
-	public void testGetArrayClass() {
-		assertSame(boolean[].class, ClassUtils.getArrayClass(boolean.class));
-		assertSame(String[].class, ClassUtils.getArrayClass(String.class));
-		assertSame(Number[].class, ClassUtils.getArrayClass(Number.class));
-		assertSame(boolean[][].class, ClassUtils.getArrayClass(boolean[].class));
-		assertSame(String[][].class, ClassUtils.getArrayClass(String[].class));
-		assertSame(Number[][].class, ClassUtils.getArrayClass(Number[].class));
-		assertNull(ClassUtils.getArrayClass(void.class));
-	}
-
 	@Test
 	public void testUnpackedClass() throws IOException {
 		final File tmpDir = createTemporaryDirectory("class-utils-test-");
diff --git a/src/test/java/org/scijava/util/TypesTest.java b/src/test/java/org/scijava/util/TypesTest.java
@@ -35,6 +35,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
 
 import java.io.Serializable;
 import java.lang.reflect.Field;
@@ -133,6 +134,22 @@ public void testRaws() {
 			Serializable.class, Cloneable.class);
 	}
 
+	/** Tests {@link Types#array}. */
+	@Test
+	public void testArray() {
+		assertSame(boolean[].class, Types.array(boolean.class));
+		assertSame(String[].class, Types.array(String.class));
+		assertSame(Number[].class, Types.array(Number.class));
+		assertSame(boolean[][].class, Types.array(boolean[].class));
+		assertSame(String[][].class, Types.array(String[].class));
+		assertSame(Number[][].class, Types.array(Number[].class));
+		try {
+			Types.array(void.class);
+			fail("Unexpected success creating void[]");
+		}
+		catch (final IllegalArgumentException exc) { }
+	}
+
 	/** Tests {@link Types#param}. */
 	@Test
 	public void testParam() {
