/**
*
*/
package org.minnal.utils.reflection;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
/**
* Helper methods for class type parameters.
* @see <a href="http://gafter.blogspot.com/2006/12/super-type-tokens.html">Super Type Tokens</a>
*/
public final class Generics {
private Generics() { /* singleton */ }
/**
* Finds the type parameter for the given class.
*
* @param klass a parameterized class
* @return the class's type parameter
*/
public static Class<?> getTypeParameter(Class<?> klass) {
return getTypeParameter(klass, Object.class);
}
/**
* Finds the type parameter for the given class which is assignable to the bound class.
*
* @param klass a parameterized class
* @param bound the type bound
* @param <T> the type bound
* @return the class's type parameter
*/
public static <T> Class<T> getTypeParameter(Class<?> klass, Class<? super T> bound) {
Type t = klass;
while (t instanceof Class<?>) {
for (Type type : ((Class<?>) t).getGenericInterfaces()) {
if (! (type instanceof Class<?>)) {
t = type;
break;
}
}
if (t instanceof Class<?>) {
t = ((Class<?>) t).getGenericSuperclass();
}
}
if (t == null) {
t = klass;
}
/* This is not guaranteed to work for all cases with convoluted piping
* of type parameters: but it can at least resolve straight-forward
* extension with single type parameter (as per [Issue-89]).
* And when it fails to do that, will indicate with specific exception.
*/
if (t instanceof ParameterizedType) {
// should typically have one of type parameters (first one) that matches:
for (Type param : ((ParameterizedType) t).getActualTypeArguments()) {
if (param instanceof Class<?>) {
final Class<T> cls = determineClass(bound, param);
if (cls != null) { return cls; }
}
else if (param instanceof TypeVariable) {
for (Type paramBound : ((TypeVariable<?>) param).getBounds()) {
if (paramBound instanceof Class<?>) {
final Class<T> cls = determineClass(bound, paramBound);
if (cls != null) { return cls; }
}
}
}
}
}
throw new IllegalStateException("Cannot figure out type parameterization for " + klass.getName());
}
@SuppressWarnings("unchecked")
private static <T> Class<T> determineClass(Class<? super T> bound, Type candidate) {
if (candidate instanceof Class<?>) {
final Class<?> cls = (Class<?>) candidate;
if (bound.isAssignableFrom(cls)) {
return (Class<T>) cls;
}
}
return null;
}
}