GenericUtils: add handy getFieldTypeString method

ctrueden · ctrueden · commit 53f6015a6b07 · 2015-02-11T14:02:58.000-06:00
This method gives you the field type declaration which you would need to use in Java source code as e.g. a method argument, which would be compile-time type compatible with the field in question in that context. Many thanks to rgettman on StackOverflow for taking the time to respond to my question about how to do this: http://stackoverflow.com/questions/28143029
diff --git a/src/main/java/org/scijava/util/GenericUtils.java b/src/main/java/org/scijava/util/GenericUtils.java
@@ -35,8 +35,11 @@
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
 import java.util.List;
+import java.util.Stack;
 
 /**
  * Useful methods for working with {@link Type} objects, particularly generic
@@ -225,4 +228,158 @@ public static Type getTypeParameter(final Type type, final Class<?> c,
 			c.getTypeParameters()[paramNo]);
 	}
 
+	/**
+	 * Obtains a string for the given field when viewed through the specified
+	 * subclass, which matches the syntax of Java source code.
+	 * <p>
+	 * Many thanks to <a
+	 * href="http://stackoverflow.com/questions/28143029">rgettman on
+	 * StackOverflow</a> for developing this logic.
+	 * </p>
+	 *
+	 * @param c The class from which to view the field in question.
+	 * @param field The field for which to generate a type string.
+	 * @return A type string describing the method, which matches the syntax of
+	 *         Java source code.
+	 */
+	public static String getFieldTypeString(final Class<?> c, final Field field) {
+		final Type genericType = field.getGenericType();
+		// Declared as actual type name...
+		if (genericType instanceof Class) {
+			final Class<?> genericTypeClass = (Class<?>) genericType;
+			return genericTypeClass.getName();
+		}
+		// .. or as a generic type?
+		else if (genericType instanceof TypeVariable) {
+			final TypeVariable<?> typeVariable = (TypeVariable<?>) genericType;
+			final Class<?> declaringClass = field.getDeclaringClass();
+
+			// Create a Stack of classes going from c up to, but not including,
+			// the declaring class.
+			final Stack<Class<?>> stack = new Stack<Class<?>>();
+			Class<?> currClass = c;
+			while (!currClass.equals(declaringClass)) {
+				stack.push(currClass);
+				currClass = currClass.getSuperclass();
+			}
+			// Get the original type parameter from the declaring class.
+			int typeVariableIndex = -1;
+			String typeVariableName = typeVariable.getName();
+			TypeVariable<?>[] currTypeParameters = currClass.getTypeParameters();
+			for (int i = 0; i < currTypeParameters.length; i++) {
+				final TypeVariable<?> currTypeVariable = currTypeParameters[i];
+				if (currTypeVariable.getName().equals(typeVariableName)) {
+					typeVariableIndex = i;
+					break;
+				}
+			}
+
+			if (typeVariableIndex == -1) {
+				throw new IllegalStateException("Expected Type variable \"" +
+					typeVariable.getName() + "\" in class " + c +
+					"; but it was not found.");
+			}
+
+			// If the type parameter is from the same class, don't bother walking down
+			// a non-existent hierarchy.
+			if (declaringClass.equals(c)) {
+				return getTypeVariableString(typeVariable);
+			}
+
+			// Pop them in order, keeping track of which index is the type variable.
+			while (!stack.isEmpty()) {
+				currClass = stack.pop();
+				// Must be ParameterizedType, not Class, because type arguments must be
+				// supplied to the generic superclass.
+				final ParameterizedType superclassParameterizedType =
+					(ParameterizedType) currClass.getGenericSuperclass();
+				final Type currType =
+					superclassParameterizedType.getActualTypeArguments()[typeVariableIndex];
+				if (currType instanceof Class) {
+					// Type argument is an actual Class, e.g.
+					// "extends ArrayList<Integer>".
+					currClass = (Class<?>) currType;
+					return currClass.getName();
+				}
+				else if (currType instanceof TypeVariable) {
+					// e.g., "T"
+					TypeVariable<?> currTypeVariable = (TypeVariable<?>) currType;
+					typeVariableName = currTypeVariable.getName();
+					// Reached passed-in class (bottom of hierarchy)? Report it.
+					if (currClass.equals(c)) {
+						return getTypeVariableString(currTypeVariable);
+					}
+					// Not at bottom? Find the type parameter to set up for next loop.
+					typeVariableIndex = -1;
+					currTypeParameters = currClass.getTypeParameters();
+					for (int i = 0; i < currTypeParameters.length; i++) {
+						currTypeVariable = currTypeParameters[i];
+						if (currTypeVariable.getName().equals(typeVariableName)) {
+							typeVariableIndex = i;
+							break;
+						}
+					}
+
+					if (typeVariableIndex == -1) {
+						// Shouldn't get here.
+						throw new IllegalStateException("Expected Type variable \"" +
+							typeVariable.getName() + "\" in class " + currClass.getName() +
+							"; but it was not found.");
+					}
+				}
+				else if (currType instanceof ParameterizedType) {
+					final ParameterizedType pType = (ParameterizedType) currType;
+					// e.g., "List<T>"
+					return pType.toString();
+				}
+			}
+		}
+		// Shouldn't get here.
+		final String genericTypeClassName = genericType == null ? "null" : genericType.getClass().getName();
+		throw new IllegalStateException("Unsupported type of Type: " + genericTypeClassName);
+	}
+
+	/** Gets a string describing a generic type parameter including its bounds. */
+	public static String
+		getTypeVariableString(final TypeVariable<?> typeVariable)
+	{
+		final StringBuilder buf = new StringBuilder();
+		buf.append(typeVariable.getName());
+		final Type[] bounds = typeVariable.getBounds();
+		boolean first = true;
+		// Don't report explicit "extends Object".
+		if (bounds.length == 1 && bounds[0].equals(Object.class)) {
+			return buf.toString();
+		}
+		for (final Type bound : bounds) {
+			if (first) {
+				buf.append(" extends ");
+				first = false;
+			}
+			else {
+				buf.append(" & ");
+			}
+			if (bound instanceof Class) {
+				// e.g., "java.util.RandomAccess"
+				final Class<?> boundClass = (Class<?>) bound;
+				buf.append(boundClass.getName());
+			}
+			else if (bound instanceof TypeVariable) {
+				// e.g., "T"
+				final TypeVariable<?> typeVariableBound = (TypeVariable<?>) bound;
+				buf.append(typeVariableBound.getName());
+			}
+			else if (bound instanceof ParameterizedType) {
+				// e.g., "java.util.Collection<T>"
+				final ParameterizedType pType = (ParameterizedType) bound;
+				buf.append(pType.toString());
+			}
+			else {
+				throw new IllegalStateException("Unknown bound type: " +
+					bound.getClass().getName());
+			}
+		}
+		return buf.toString();
+	}
+
 }
diff --git a/src/test/java/org/scijava/util/GenericUtilsTest.java b/src/test/java/org/scijava/util/GenericUtilsTest.java
@@ -40,6 +40,7 @@
 import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.List;
+import java.util.RandomAccess;
 
 import org.junit.Test;
 
@@ -135,6 +136,26 @@ public void testGetGenericType() {
 			Serializable.class, Cloneable.class);
 	}
 
+	@Test
+	public void testGetFieldTypeString() {
+		final Field f1 = ClassUtils.getField(Thing.class, "thing");
+		assertFieldString("T", Thing.class, f1);
+		assertFieldString("N extends java.lang.Number", NumberThing.class, f1);
+		assertFieldString("java.lang.Integer", IntegerThing.class, f1);
+		assertFieldString("java.lang.Integer", SpecificIntegerThing.class, f1);
+		assertFieldString("java.util.List<T>", ListThing.class, f1);
+		assertFieldString("java.util.List<Double>", ListDoubleThing.class, f1);
+		assertFieldString(
+			"RT extends org.scijava.util.GenericUtilsTest.RecursiveThing<RT>",
+			RecursiveThing.class, f1);
+
+		final Field f2 = ClassUtils.getField(Superclass.class, "thing");
+		assertFieldString("A extends java.io.Serializable", Superclass.class, f2);
+		assertFieldString(
+			"B extends java.util.RandomAccess & java.io.Serializable",
+			Subclass.class, f2);
+	}
+
 	// -- Helper classes --
 
 	private static class Thing<T> {
@@ -156,6 +177,36 @@ private static class ComplexThing<T extends Serializable & Cloneable> extends
 		// NB: No implementation needed.
 	}
 
+	private static class SpecificIntegerThing extends IntegerThing {
+		// NB: No implementation needed.
+	}
+
+	private static class ListThing<T> extends Thing<List<T>> {
+		// NB: No implementation needed.
+	}
+
+	private static class ListDoubleThing extends ListThing<Double> {
+		// NB: No implementation needed.
+	}
+
+	private static class RecursiveThing<RT extends RecursiveThing<RT>> extends
+		Thing<RT>
+	{
+		// NB: No implementation needed.
+	}
+
+	private static class Superclass<A extends Serializable, B> {
+		@SuppressWarnings("unused")
+		private A thing;
+	}
+
+	/** NB: A and B are reversed in the extends clause! */
+	private static class Subclass<A, B extends RandomAccess & Serializable>
+		extends Superclass<B, A>
+	{
+		// NB: Marker class.
+	}
+
 	// -- Helper methods --
 
 	/** Convenience method to get the {@link Type} of a field. */
@@ -185,4 +236,10 @@ private <T> void assertAllTheSame(final List<T> list, final T... values) {
 		}
 	}
 
+	private void assertFieldString(final String expected, final Class<?> c,
+		final Field field)
+	{
+		assertEquals(expected, GenericUtils.getFieldTypeString(c, field));
+	}
+
 }
