public static Class<?> getResolvedMethodReturnType(Class<?> clazz, Method m) { if (m == null) { return null; } if (m.getGenericReturnType() instanceof TypeVariable<?>) { return resolveTypeVariable(clazz, (TypeVariable<?>) m.getGenericReturnType()); } return m.getReturnType(); }
public static Class<?> getResolvedFieldType(Class<?> clazz, Field f) { if (f == null) { return null; } if (f.getGenericType() instanceof TypeVariable<?>) { return resolveTypeVariable(clazz, (TypeVariable<?>) f.getGenericType()); } return f.getType(); }
public static Class<?>[] getResolvedMethodParameterTypes(Class<?> clazz, Method m) { if (m == null) { return null; } Type[] genericParameterTypes = m.getGenericParameterTypes(); Class<?>[] parameterTypes = new Class<?>[genericParameterTypes.length]; for (int i = 0; i < genericParameterTypes.length; i++) { if (genericParameterTypes[i] instanceof TypeVariable<?>) { parameterTypes[i] = resolveTypeVariable(clazz, (TypeVariable<?>) genericParameterTypes[i]); } else if (genericParameterTypes[i] instanceof ParameterizedType) { parameterTypes[i] = (Class<?>) ((ParameterizedType) genericParameterTypes[i]).getRawType(); } else { parameterTypes[i] = (Class<?>) genericParameterTypes[i]; } } return parameterTypes; }
public Class<?> getResolvedType(Class<?> concreteClass) { Type t = method != null ? method.getGenericParameterTypes()[index] : constructor.getGenericParameterTypes()[index]; if (t instanceof TypeVariable<?>) { return ReflectionUtils.resolveTypeVariable(concreteClass, (TypeVariable<?>) t); } return getType(); }
public static Class<?>[] getResolvedMethodExceptionTypes(Class<?> clazz, Method m) { if (m == null) { return null; } Type[] genericExceptionTypes = m.getGenericExceptionTypes(); Class<?>[] exceptionTypes = new Class<?>[genericExceptionTypes.length]; for (int i = 0; i < genericExceptionTypes.length; i++) { if (genericExceptionTypes[i] instanceof TypeVariable<?>) { exceptionTypes[i] = resolveTypeVariable(clazz, (TypeVariable<?>) genericExceptionTypes[i]); } else if (genericExceptionTypes[i] instanceof ParameterizedType) { exceptionTypes[i] = (Class<?>) ((ParameterizedType) genericExceptionTypes[i]).getRawType(); } else { exceptionTypes[i] = (Class<?>) genericExceptionTypes[i]; } } return exceptionTypes; }
public static boolean isSorted(Constructor<?> constructor, int index) { Class<?> concreteClass = constructor.getDeclaringClass(); Type type = constructor.getGenericParameterTypes()[index]; if (type instanceof Class<?>) { return isSorted((Class<?>) type); } else if (type instanceof TypeVariable<?>) { return isSorted(ReflectionUtils.resolveTypeVariable(concreteClass, (TypeVariable<?>) type)); } else { return isSorted(constructor.getParameterTypes()[index]); } }
public static Class<?> resolveType(Class<?> concreteClass, Type type) { if (type instanceof TypeVariable<?>) { return resolveTypeVariable(concreteClass, (TypeVariable<?>) type); } else if (type instanceof ParameterizedType) { return (Class<?>) ((ParameterizedType) type).getRawType(); } else if (type instanceof GenericArrayType) { return getArrayClass((GenericArrayType) type); } else if (type instanceof WildcardType) { WildcardType wildcardType = ((WildcardType) type); if (wildcardType.getLowerBounds().length > 0) { return resolveType(concreteClass, wildcardType.getLowerBounds()[0]); } else { return resolveType(concreteClass, wildcardType.getUpperBounds()[0]); } } else { // We assume here that only class types, type variables and parameterized types are // possible as argument types for the parameterized type return (Class<?>) type; } }
public Class<?> getResolvedType(Class<?> concreteClass) { Type t = method != null ? method.getGenericExceptionTypes()[index] : constructor.getGenericExceptionTypes()[index]; if (t instanceof TypeVariable<?>) { return ReflectionUtils.resolveTypeVariable(concreteClass, (TypeVariable<?>) t); } return getType(); }