Merge branch 'generic-utils'

This branch reorganizes the lower-level generics-related helper methods
of ClassUtils and ConversionUtils into a dedicated utility class:
GenericUtils. The old method signatures have been deprecated.

The original idea was to use some of these methods to assist with better
ObjectIndex lazy object resolution, but it turns out that even with
clever use of generics reflection, it is not tenable to reliably detect
the type from the LazyObjects instance alone. So the new features of
GenericUtils, while very nifty and probably useful in the future, are
not in immediate use anywhere within SciJava Common.

Author: ctrueden

src/main/java/org/scijava/util/ClassUtils.java

@@ -31,8 +31,6 @@
 
 package org.scijava.util;
 
-import com.googlecode.gentyref.GenericTypeReflector;
-
 import java.io.File;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Array;
@@ -54,72 +52,6 @@ private ClassUtils() {
 		// prevent instantiation of utility class
 	}
 
-	// -- Type conversion and casting --
-
-	/**
-	 * @deprecated use {@link ConversionUtils#convert(Object, Class)}
-	 */
-	@Deprecated
-	public static <T> T convert(final Object value, final Class<T> type) {
-		return ConversionUtils.convert(value, type);
-	}
-
-	/**
-	 * @deprecated use {@link ConversionUtils#canConvert(Class, Class)}
-	 */
-	@Deprecated
-	public static boolean canConvert(final Class<?> c, final Class<?> type) {
-		return ConversionUtils.canConvert(c, type);
-	}
-
-	/**
-	 * @deprecated use {@link ConversionUtils#canConvert(Object, Class)}
-	 */
-	@Deprecated
-	public static boolean canConvert(final Object value, final Class<?> type) {
-		return ConversionUtils.canConvert(value, type);
-	}
-
-	/**
-	 * @deprecated use {@link ConversionUtils#cast(Object, Class)}
-	 */
-	@Deprecated
-	public static <T> T cast(final Object obj, final Class<T> type) {
-		return ConversionUtils.cast(obj, type);
-	}
-
-	/**
-	 * @deprecated use {@link ConversionUtils#canCast(Class, Class)}
-	 */
-	@Deprecated
-	public static boolean canCast(final Class<?> c, final Class<?> type) {
-		return ConversionUtils.canCast(c, type);
-	}
-
-	/**
-	 * @deprecated use {@link ConversionUtils#canCast(Object, Class)}
-	 */
-	@Deprecated
-	public static boolean canCast(final Object obj, final Class<?> type) {
-		return ConversionUtils.canCast(obj, type);
-	}
-
-	/**
-	 * @deprecated use {@link ConversionUtils#getNonprimitiveType(Class)}
-	 */
-	@Deprecated
-	public static <T> Class<T> getNonprimitiveType(final Class<T> type) {
-		return ConversionUtils.getNonprimitiveType(type);
-	}
-
-	/**
-	 * @deprecated use {@link ConversionUtils#getNullValue(Class)}
-	 */
-	@Deprecated
-	public static <T> T getNullValue(final Class<T> type) {
-		return ConversionUtils.getNullValue(type);
-	}
-
 	// -- Class loading, querying and reflection --
 
 	/**
@@ -407,96 +339,6 @@ public static Field getField(final Class<?> c, final String fieldName) {
 		}
 	}
 
-	/**
-	 * Returns the "safe" type(s) of the given field, as viewed from the specified
-	 * type. This may be narrower than what {@link Field#getType()} returns, if
-	 * the field is declared in a superclass, or {@code type} has a type parameter
-	 * that is used in the type of the field.
-	 * <p>
-	 * For example, suppose we have the following three classes:
-	 * </p>
-	 * 
-	 * <pre>
-	 * public class Thing&lt;T&gt; {
-	 * 	public T thing;
-	 * }
-	 * 
-	 * public class NumberThing&lt;N extends Number&gt; extends Thing&lt;N&gt; { }
-	 * 
-	 * public class IntegerThing extends NumberThing&lt;Integer&gt; { }
-	 * </pre>
-	 * 
-	 * Then this method operates as follows:
-	 * 
-	 * <pre>
-	 * field = ClassUtils.getField(Thing.class, "thing");
-	 * 
-	 * field.getType(); // Object
-	 * 
-	 * ClassUtils.getTypes(field, Thing.class).get(0); // Object
-	 * ClassUtils.getTypes(field, NumberThing.class).get(0); // Number
-	 * ClassUtils.getTypes(field, IntegerThing.class).get(0); // Integer
-	 * </pre>
-	 * 
-	 * <p>
-	 * In cases of complex generics which take the intersection of
-	 * multiple types using the {@code &} operator, there may be multiple types
-	 * returned by this method. For example:
-	 * </p>
-	 * 
-	 * <pre>
-	 * public class ComplexThing&lt;T extends Serializable &amp; Cloneable&gt; extends Thing&lt;T&gt; { }
-	 * 
-	 * ClassUtils.getTypes(field, ComplexThing.class); // Serializable, Cloneable
-	 * </pre>
-	 * 
-	 * @see #getGenericType(Field, Class)
-	 */
-	public static List<Class<?>> getTypes(final Field field, final Class<?> type)
-	{
-		final Type genericType = getGenericType(field, type);
-		return GenericTypeReflector.getUpperBoundClassAndInterfaces(genericType);
-	}
-
-	/**
-	 * Returns the "safe" generic type of the given field, as viewed from the
-	 * given type. This may be narrower than what {@link Field#getGenericType()}
-	 * returns, if the field is declared in a superclass, or {@code type} has a
-	 * type parameter that is used in the type of the field.
-	 * <p>
-	 * For example, suppose we have the following three classes:
-	 * </p>
-	 * 
-	 * <pre>
-	 * public class Thing&lt;T&gt; {
-	 * 	public T thing;
-	 * }
-	 * 
-	 * public class NumberThing&lt;N extends Number&gt; extends Thing&lt;N&gt; { }
-	 * 
-	 * public class IntegerThing extends NumberThing&lt;Integer&gt; { }
-	 * </pre>
-	 * 
-	 * Then this method operates as follows:
-	 * 
-	 * <pre>
-	 * field = ClassUtils.getField(Thing.class, "thing");
-	 * 
-	 * field.getType(); // Object
-	 * field.getGenericType(); // T
-	 * 
-	 * ClassUtils.getGenericType(field, Thing.class); // T
-	 * ClassUtils.getGenericType(field, NumberThing.class); // N extends Number
-	 * ClassUtils.getGenericType(field, IntegerThing.class); // Integer
-	 * </pre>
-	 * 
-	 * @see #getTypes(Field, Class)
-	 */
-	public static Type getGenericType(final Field field, final Class<?> type) {
-		final Type wildType = GenericTypeReflector.addWildcardParameters(type);
-		return GenericTypeReflector.getExactFieldType(field, wildType);
-	}
-
 	/**
 	 * Gets the given field's value of the specified object instance, or null if
 	 * the value cannot be obtained.
@@ -521,8 +363,9 @@ public static void setValue(final Field field, final Object instance,
 	{
 		try {
 			field.setAccessible(true);
-			field.set(instance, ConversionUtils
-				.convert(value, field.getGenericType()));
+			final Type fieldType =
+				GenericUtils.getFieldType(field, instance.getClass());
+			field.set(instance, ConversionUtils.convert(value, fieldType));
 		}
 		catch (final IllegalAccessException e) {
 			throw new IllegalArgumentException("No access to field: " +
@@ -599,4 +442,67 @@ public static int compare(final Class<?> c1, final Class<?> c2) {
 		return MiscUtils.compare(name1, name2);
 	}
 
+	// -- Deprecated methods --
+
+	/** @deprecated use {@link ConversionUtils#convert(Object, Class)} */
+	@Deprecated
+	public static <T> T convert(final Object value, final Class<T> type) {
+		return ConversionUtils.convert(value, type);
+	}
+
+	/** @deprecated use {@link ConversionUtils#canConvert(Class, Class)} */
+	@Deprecated
+	public static boolean canConvert(final Class<?> c, final Class<?> type) {
+		return ConversionUtils.canConvert(c, type);
+	}
+
+	/** @deprecated use {@link ConversionUtils#canConvert(Object, Class)} */
+	@Deprecated
+	public static boolean canConvert(final Object value, final Class<?> type) {
+		return ConversionUtils.canConvert(value, type);
+	}
+
+	/** @deprecated use {@link ConversionUtils#cast(Object, Class)} */
+	@Deprecated
+	public static <T> T cast(final Object obj, final Class<T> type) {
+		return ConversionUtils.cast(obj, type);
+	}
+
+	/** @deprecated use {@link ConversionUtils#canCast(Class, Class)} */
+	@Deprecated
+	public static boolean canCast(final Class<?> c, final Class<?> type) {
+		return ConversionUtils.canCast(c, type);
+	}
+
+	/** @deprecated use {@link ConversionUtils#canCast(Object, Class)} */
+	@Deprecated
+	public static boolean canCast(final Object obj, final Class<?> type) {
+		return ConversionUtils.canCast(obj, type);
+	}
+
+	/** @deprecated use {@link ConversionUtils#getNonprimitiveType(Class)} */
+	@Deprecated
+	public static <T> Class<T> getNonprimitiveType(final Class<T> type) {
+		return ConversionUtils.getNonprimitiveType(type);
+	}
+
+	/** @deprecated use {@link ConversionUtils#getNullValue(Class)} */
+	@Deprecated
+	public static <T> T getNullValue(final Class<T> type) {
+		return ConversionUtils.getNullValue(type);
+	}
+
+	/** @deprecated use {@link GenericUtils#getFieldClasses(Field, Class)} */
+	@Deprecated
+	public static List<Class<?>> getTypes(final Field field, final Class<?> type)
+	{
+		return GenericUtils.getFieldClasses(field, type);
+	}
+
+	/** @deprecated use {@link GenericUtils#getFieldType(Field, Class)} */
+	@Deprecated
+	public static Type getGenericType(final Field field, final Class<?> type) {
+		return GenericUtils.getFieldType(field, type);
+	}
+
 }

src/main/java/org/scijava/util/ConversionUtils.java

@@ -33,11 +33,9 @@
 
 import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
-import java.lang.reflect.TypeVariable;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
@@ -438,44 +436,6 @@ public static <T> T getNullValue(final Class<T> type) {
 		return result;
 	}
 
-	/**
-	 * Gets the raw class corresponding to the given type.
-	 * <p>
-	 * If the type is a {@link Class} it is simply casted. In the case of a
-	 * {@link ParameterizedType}, then {@link ParameterizedType#getRawType()} is
-	 * returned. Otherwise, returns null.
-	 * </p>
-	 */
-	public static Class<?> getClass(final Type type) {
-		if (type instanceof Class) return (Class<?>) type;
-
-		if (type instanceof ParameterizedType) {
-			return getClass(((ParameterizedType) type).getRawType());
-		}
-
-		if (type instanceof TypeVariable<?>) {
-			final Type[] types = ((TypeVariable<?>) type).getBounds();
-			if (types.length == 1) return getClass(types[0]);
-		}
-
-		return null;
-	}
-
-	/**
-	 * Gets the component type of the given array type, or null if not an array.
-	 * Supports both regular array types (i.e., {@link Class#getComponentType()}
-	 * if {@code type} is a {@link Class}) and generic array types (i.e.,
-	 * {@link GenericArrayType#getGenericComponentType()} if {@code type} is a
-	 * {@link GenericArrayType}).
-	 */
-	public static Class<?> getComponentClass(final Type type) {
-		if (type instanceof Class) return ((Class<?>) type).getComponentType();
-		if (type instanceof GenericArrayType) {
-			return getClass(((GenericArrayType) type).getGenericComponentType());
-		}
-		return null;
-	}
-
 	// -- Helper methods --
 
 	private static Constructor<?> getConstructor(final Class<?> type,
@@ -560,4 +520,18 @@ private static Collection<Object> createCollection(final Class<?> type) {
 		}
 	}
 
+	// -- Deprecated methods --
+
+	/** @deprecated use {@link GenericUtils#getClass(Type)} */
+	@Deprecated
+	public static Class<?> getClass(final Type type) {
+		return GenericUtils.getClass(type);
+	}
+
+	/** @deprecated use {@link GenericUtils#getComponentClass(Type)} */
+	@Deprecated
+	public static Class<?> getComponentClass(final Type type) {
+		return GenericUtils.getComponentClass(type);
+	}
+
 }