ClassUtils: add methods for precise field typing

These methods exploit generics to deduce more details of the type of the
field in question, with respect to a particular (usually sub-)class.
See the method javadoc for further details.

This introduces an (encapsulated) dependency on the excellent gentyref
library, which does the bulk of the work.

Many thanks to Wouter Coekaerts for creating gentyref, and for his
patience in explaining some of the finer points of Java generics:
    coekie/gentyref#2

Author: ctrueden

pom.xml

@@ -24,6 +24,12 @@
 			<version>1.4</version>
 		</dependency>
 
+		<dependency>
+			<groupId>com.googlecode.gentyref</groupId>
+			<artifactId>gentyref</artifactId>
+			<version>1.1.0</version>
+		</dependency>
+
 		<dependency>
 			<groupId>junit</groupId>
 			<artifactId>junit</artifactId>

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

@@ -31,10 +31,13 @@
 
 package org.scijava.util;
 
+import com.googlecode.gentyref.GenericTypeReflector;
+
 import java.io.File;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Array;
 import java.lang.reflect.Field;
+import java.lang.reflect.Type;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.ArrayList;
@@ -404,6 +407,96 @@ 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.