Deprecate methods now available in GenericUtils

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;
@@ -341,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.
@@ -599,4 +507,17 @@ 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);
+	}
+
 }