public class ResolvableType extends Object implements Serializable
Type, providing access to
 supertypes, interfaces, and
 generic parameters along with the ability to ultimately
 resolve to a Class.
 ResolvableTypes may be obtained from fields,
 method parameters,
 method returns or
 classes. Most methods on this class will themselves return
 ResolvableTypes, allowing easy navigation. For example:
 
 private HashMap<Integer, List<String>> myMap;
 public void example() {
     ResolvableType t = ResolvableType.forField(getClass().getDeclaredField("myMap"));
     t.getSuperType(); // AbstractMap<Integer, List<String>>
     t.asMap(); // Map<Integer, List<String>>
     t.getGeneric(0).resolve(); // Integer
     t.getGeneric(1).resolve(); // List
     t.getGeneric(1); // List<String>
     t.resolveGeneric(1, 0); // String
 }
 forField(Field), 
forMethodParameter(Method, int), 
forMethodReturnType(Method), 
forConstructorParameter(Constructor, int), 
forClass(Class), 
forType(Type), 
forInstance(Object), 
ResolvableTypeProvider, 
Serialized Form| Modifier and Type | Field and Description | 
|---|---|
| static ResolvableType | NONEResolvableTypereturned when no value is available. | 
| Modifier and Type | Method and Description | 
|---|---|
| ResolvableType | as(Class<?> type)Return this type as a  ResolvableTypeof the specified class. | 
| ResolvableType | asCollection()Convenience method to return this type as a resolvable  Collectiontype. | 
| ResolvableType | asMap()Convenience method to return this type as a resolvable  Maptype. | 
| static void | clearCache()Clear the internal  ResolvableType/SerializableTypeWrappercache. | 
| boolean | equals(Object other) | 
| static ResolvableType | forArrayComponent(ResolvableType componentType)Return a  ResolvableTypeas a array of the specifiedcomponentType. | 
| static ResolvableType | forClass(Class<?> clazz)Return a  ResolvableTypefor the specifiedClass,
 using the full generic type information for assignability checks. | 
| static ResolvableType | forClass(Class<?> baseType,
        Class<?> implementationClass)Return a  ResolvableTypefor the specified base type
 (interface or base class) with a given implementation class. | 
| static ResolvableType | forClassWithGenerics(Class<?> clazz,
                    Class<?>... generics)Return a  ResolvableTypefor the specifiedClasswith pre-declared generics. | 
| static ResolvableType | forClassWithGenerics(Class<?> clazz,
                    ResolvableType... generics)Return a  ResolvableTypefor the specifiedClasswith pre-declared generics. | 
| static ResolvableType | forConstructorParameter(Constructor<?> constructor,
                       int parameterIndex)Return a  ResolvableTypefor the specifiedConstructorparameter. | 
| static ResolvableType | forConstructorParameter(Constructor<?> constructor,
                       int parameterIndex,
                       Class<?> implementationClass)Return a  ResolvableTypefor the specifiedConstructorparameter
 with a given implementation. | 
| static ResolvableType | forField(Field field)Return a  ResolvableTypefor the specifiedField. | 
| static ResolvableType | forField(Field field,
        Class<?> implementationClass)Return a  ResolvableTypefor the specifiedFieldwith a given
 implementation. | 
| static ResolvableType | forField(Field field,
        int nestingLevel)Return a  ResolvableTypefor the specifiedFieldwith the
 given nesting level. | 
| static ResolvableType | forField(Field field,
        int nestingLevel,
        Class<?> implementationClass)Return a  ResolvableTypefor the specifiedFieldwith a given
 implementation and the given nesting level. | 
| static ResolvableType | forField(Field field,
        ResolvableType implementationType)Return a  ResolvableTypefor the specifiedFieldwith a given
 implementation. | 
| static ResolvableType | forInstance(Object instance)Return a  ResolvableTypefor the specified instance. | 
| static ResolvableType | forMethodParameter(Method method,
                  int parameterIndex)Return a  ResolvableTypefor the specifiedMethodparameter. | 
| static ResolvableType | forMethodParameter(Method method,
                  int parameterIndex,
                  Class<?> implementationClass)Return a  ResolvableTypefor the specifiedMethodparameter with a
 given implementation. | 
| static ResolvableType | forMethodParameter(MethodParameter methodParameter)Return a  ResolvableTypefor the specifiedMethodParameter. | 
| static ResolvableType | forMethodParameter(MethodParameter methodParameter,
                  ResolvableType implementationType)Return a  ResolvableTypefor the specifiedMethodParameterwith a
 given implementation type. | 
| static ResolvableType | forMethodParameter(MethodParameter methodParameter,
                  Type targetType)Return a  ResolvableTypefor the specifiedMethodParameter,
 overriding the target type to resolve with a specific given type. | 
| static ResolvableType | forMethodReturnType(Method method)Return a  ResolvableTypefor the specifiedMethodreturn type. | 
| static ResolvableType | forMethodReturnType(Method method,
                   Class<?> implementationClass)Return a  ResolvableTypefor the specifiedMethodreturn type. | 
| static ResolvableType | forRawClass(Class<?> clazz)Return a  ResolvableTypefor the specifiedClass,
 doing assignability checks against the raw class only (analogous toClass.isAssignableFrom(java.lang.Class<?>), which this serves as a wrapper for. | 
| static ResolvableType | forType(ParameterizedTypeReference<?> typeReference)Return a  ResolvableTypefor the specifiedParameterizedTypeReference. | 
| static ResolvableType | forType(Type type)Return a  ResolvableTypefor the specifiedType. | 
| static ResolvableType | forType(Type type,
       ResolvableType owner)Return a  ResolvableTypefor the specifiedTypebacked by the given
 owner type. | 
| ResolvableType | getComponentType()Return the ResolvableType representing the component type of the array or
  NONEif this type does not represent an array. | 
| ResolvableType | getGeneric(int... indexes)Return a  ResolvableTyperepresenting the generic parameter for the
 given indexes. | 
| ResolvableType[] | getGenerics()Return an array of  ResolvableTypesrepresenting the generic parameters of
 this type. | 
| ResolvableType[] | getInterfaces()Return a  ResolvableTypearray representing the direct interfaces
 implemented by this type. | 
| ResolvableType | getNested(int nestingLevel)Return a  ResolvableTypefor the specified nesting level. | 
| ResolvableType | getNested(int nestingLevel,
         Map<Integer,Integer> typeIndexesPerLevel)Return a  ResolvableTypefor the specified nesting level. | 
| Class<?> | getRawClass()Return the underlying Java  Classbeing managed, if available;
 otherwisenull. | 
| Object | getSource()Return the underlying source of the resolvable type. | 
| ResolvableType | getSuperType()Return a  ResolvableTyperepresenting the direct supertype of this type. | 
| Type | getType()Return the underling Java  Typebeing managed. | 
| boolean | hasGenerics()Return  trueif this type contains generic parameters. | 
| int | hashCode() | 
| boolean | hasUnresolvableGenerics()Determine whether the underlying type has any unresolvable generics:
 either through an unresolvable type variable on the type itself
 or through implementing a generic interface in a raw fashion,
 i.e. | 
| boolean | isArray()Return  trueif this type resolves to a Class that represents an array. | 
| boolean | isAssignableFrom(Class<?> other)Determine whether this  ResolvableTypeis assignable from the
 specified other type. | 
| boolean | isAssignableFrom(ResolvableType other)Determine whether this  ResolvableTypeis assignable from the
 specified other type. | 
| boolean | isInstance(Object obj)Determine whether the given object is an instance of this  ResolvableType. | 
| Class<?> | resolve()Resolve this type to a  Class, returningnullif the type cannot be resolved. | 
| Class<?> | resolve(Class<?> fallback)Resolve this type to a  Class, returning the specifiedfallbackif the type cannot be resolved. | 
| Class<?> | resolveGeneric(int... indexes) | 
| Class<?>[] | resolveGenerics() | 
| Class<?>[] | resolveGenerics(Class<?> fallback) | 
| Class<?> | toClass()Return this type as a resolved  Class, falling back toObjectif no specific class can be resolved. | 
| String | toString()Return a String representation of this type in its fully resolved form
 (including any generic parameters). | 
public static final ResolvableType NONE
ResolvableType returned when no value is available. NONE is used
 in preference to null so that multiple method calls can be safely chained.@Nullable public Class<?> getRawClass()
Class being managed, if available;
 otherwise null.public Object getSource()
Field,
 MethodParameter or Type depending on how the ResolvableType
 was constructed. With the exception of the NONE constant, this method will
 never return null. This method is primarily to provide access to additional
 type information or meta-data that alternative JVM languages may provide.public Class<?> toClass()
Class, falling back to
 Object if no specific class can be resolved.Class or the Object fallbackgetRawClass(), 
resolve(Class)public boolean isInstance(@Nullable Object obj)
ResolvableType.obj - the object to checkisAssignableFrom(Class)public boolean isAssignableFrom(Class<?> other)
ResolvableType is assignable from the
 specified other type.other - the type to be checked against (as a Class)isAssignableFrom(ResolvableType)public boolean isAssignableFrom(ResolvableType other)
ResolvableType is assignable from the
 specified other type.
 Attempts to follow the same rules as the Java compiler, considering
 whether both the resolved Class is
 assignable from the given type
 as well as whether all generics are assignable.
other - the type to be checked against (as a ResolvableType)true if the specified other type can be assigned to this
 ResolvableType; false otherwisepublic boolean isArray()
true if this type resolves to a Class that represents an array.getComponentType()public ResolvableType getComponentType()
NONE if this type does not represent an array.isArray()public ResolvableType asCollection()
Collection type.
 Returns NONE if this type does not implement or extend
 Collection.public ResolvableType asMap()
Map type.
 Returns NONE if this type does not implement or extend
 Map.as(Class), 
asCollection()public ResolvableType as(Class<?> type)
ResolvableType of the specified class. Searches
 supertype and interface
 hierarchies to find a match, returning NONE if this type does not
 implement or extend the specified class.type - the required type (typically narrowed)ResolvableType representing this object as the specified
 type, or NONE if not resolvable as that typeasCollection(), 
asMap(), 
getSuperType(), 
getInterfaces()public ResolvableType getSuperType()
ResolvableType representing the direct supertype of this type.
 If no supertype is available this method returns NONE.
 Note: The resulting ResolvableType instance may not be Serializable.
getInterfaces()public ResolvableType[] getInterfaces()
ResolvableType array representing the direct interfaces
 implemented by this type. If this type does not implement any interfaces an
 empty array is returned.
 Note: The resulting ResolvableType instances may not be Serializable.
getSuperType()public boolean hasGenerics()
true if this type contains generic parameters.getGeneric(int...), 
getGenerics()public boolean hasUnresolvableGenerics()
true only in those two scenarios.public ResolvableType getNested(int nestingLevel)
ResolvableType for the specified nesting level.
 See getNested(int, Map) for details.nestingLevel - the nesting levelResolvableType type, or #NONEpublic ResolvableType getNested(int nestingLevel, @Nullable Map<Integer,Integer> typeIndexesPerLevel)
ResolvableType for the specified nesting level.
 The nesting level refers to the specific generic parameter that should be returned.
 A nesting level of 1 indicates this type; 2 indicates the first nested generic;
 3 the second; and so on. For example, given List<Set<Integer>> level 1 refers
 to the List, level 2 the Set, and level 3 the Integer.
 
The typeIndexesPerLevel map can be used to reference a specific generic
 for the given level. For example, an index of 0 would refer to a Map key;
 whereas, 1 would refer to the value. If the map does not contain a value for a
 specific level the last generic will be used (e.g. a Map value).
 
Nesting levels may also apply to array types; for example given
 String[], a nesting level of 2 refers to String.
 
If a type does not contain generics the
 supertype hierarchy will be considered.
nestingLevel - the required nesting level, indexed from 1 for the
 current type, 2 for the first nested generic, 3 for the second and so ontypeIndexesPerLevel - a map containing the generic index for a given
 nesting level (may be null)ResolvableType for the nested level, or NONEpublic ResolvableType getGeneric(@Nullable int... indexes)
ResolvableType representing the generic parameter for the
 given indexes. Indexes are zero based; for example given the type
 Map<Integer, List<String>>, getGeneric(0) will access the
 Integer. Nested generics can be accessed by specifying multiple indexes;
 for example getGeneric(1, 0) will access the String from the
 nested List. For convenience, if no indexes are specified the first
 generic is returned.
 If no generic is available at the specified indexes NONE is returned.
indexes - the indexes that refer to the generic parameter
 (may be omitted to return the first generic)ResolvableType for the specified generic, or NONEhasGenerics(), 
getGenerics(), 
resolveGeneric(int...), 
resolveGenerics()public ResolvableType[] getGenerics()
ResolvableTypes representing the generic parameters of
 this type. If no generics are available an empty array is returned. If you need to
 access a specific generic consider using the getGeneric(int...) method as
 it allows access to nested generics and protects against
 IndexOutOfBoundsExceptions.ResolvableTypes representing the generic parameters
 (never null)hasGenerics(), 
getGeneric(int...), 
resolveGeneric(int...), 
resolveGenerics()public Class<?>[] resolveGenerics()
null, but it may contain null elements})getGenerics(), 
resolve()public Class<?>[] resolveGenerics(Class<?> fallback)
get and resolve generic parameters, using the specified fallback if any type
 cannot be resolved.fallback - the fallback class to use if resolution failsgetGenerics(), 
resolve()@Nullable public Class<?> resolveGeneric(int... indexes)
indexes - the indexes that refer to the generic parameter
 (may be omitted to return the first generic)Class or nullgetGeneric(int...), 
resolve()@Nullable public Class<?> resolve()
Class, returning null
 if the type cannot be resolved. This method will consider bounds of
 TypeVariables and WildcardTypes if
 direct resolution fails; however, bounds of Object.class will be ignored.
 If this method returns a non-null Class and hasGenerics()
 returns false, the given type effectively wraps a plain Class,
 allowing for plain Class processing if desirable.
Class, or null if not resolvableresolve(Class), 
resolveGeneric(int...), 
resolveGenerics()public Class<?> resolve(Class<?> fallback)
Class, returning the specified
 fallback if the type cannot be resolved. This method will consider bounds
 of TypeVariables and WildcardTypes if
 direct resolution fails; however, bounds of Object.class will be ignored.fallback - the fallback class to use if resolution failsClass or the fallbackresolve(), 
resolveGeneric(int...), 
resolveGenerics()public String toString()
public static ResolvableType forClass(@Nullable Class<?> clazz)
ResolvableType for the specified Class,
 using the full generic type information for assignability checks.
 For example: ResolvableType.forClass(MyArrayList.class).clazz - the class to introspect (null is semantically
 equivalent to Object.class for typical use cases here)ResolvableType for the specified classforClass(Class, Class), 
forClassWithGenerics(Class, Class...)public static ResolvableType forRawClass(@Nullable Class<?> clazz)
ResolvableType for the specified Class,
 doing assignability checks against the raw class only (analogous to
 Class.isAssignableFrom(java.lang.Class<?>), which this serves as a wrapper for.
 For example: ResolvableType.forRawClass(List.class).clazz - the class to introspect (null is semantically
 equivalent to Object.class for typical use cases here)ResolvableType for the specified classforClass(Class), 
getRawClass()public static ResolvableType forClass(Class<?> baseType, Class<?> implementationClass)
ResolvableType for the specified base type
 (interface or base class) with a given implementation class.
 For example: ResolvableType.forClass(List.class, MyArrayList.class).baseType - the base type (must not be null)implementationClass - the implementation classResolvableType for the specified base type backed by the
 given implementation classforClass(Class), 
forClassWithGenerics(Class, Class...)public static ResolvableType forClassWithGenerics(Class<?> clazz, Class<?>... generics)
ResolvableType for the specified Class with pre-declared generics.clazz - the class (or interface) to introspectgenerics - the generics of the classResolvableType for the specific class and genericsforClassWithGenerics(Class, ResolvableType...)public static ResolvableType forClassWithGenerics(Class<?> clazz, ResolvableType... generics)
ResolvableType for the specified Class with pre-declared generics.clazz - the class (or interface) to introspectgenerics - the generics of the classResolvableType for the specific class and genericsforClassWithGenerics(Class, Class...)public static ResolvableType forInstance(Object instance)
ResolvableType for the specified instance. The instance does not
 convey generic information but if it implements ResolvableTypeProvider a
 more precise ResolvableType can be used than the simple one based on
 the Class instance.instance - the instanceResolvableType for the specified instanceResolvableTypeProviderpublic static ResolvableType forField(Field field)
ResolvableType for the specified Field.field - the source fieldResolvableType for the specified fieldforField(Field, Class)public static ResolvableType forField(Field field, Class<?> implementationClass)
ResolvableType for the specified Field with a given
 implementation.
 Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation class.
field - the source fieldimplementationClass - the implementation classResolvableType for the specified fieldforField(Field)public static ResolvableType forField(Field field, @Nullable ResolvableType implementationType)
ResolvableType for the specified Field with a given
 implementation.
 Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation type.
field - the source fieldimplementationType - the implementation typeResolvableType for the specified fieldforField(Field)public static ResolvableType forField(Field field, int nestingLevel)
ResolvableType for the specified Field with the
 given nesting level.field - the source fieldnestingLevel - the nesting level (1 for the outer level; 2 for a nested
 generic type; etc)forField(Field)public static ResolvableType forField(Field field, int nestingLevel, @Nullable Class<?> implementationClass)
ResolvableType for the specified Field with a given
 implementation and the given nesting level.
 Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation class.
field - the source fieldnestingLevel - the nesting level (1 for the outer level; 2 for a nested
 generic type; etc)implementationClass - the implementation classResolvableType for the specified fieldforField(Field)public static ResolvableType forConstructorParameter(Constructor<?> constructor, int parameterIndex)
ResolvableType for the specified Constructor parameter.constructor - the source constructor (must not be null)parameterIndex - the parameter indexResolvableType for the specified constructor parameterforConstructorParameter(Constructor, int, Class)public static ResolvableType forConstructorParameter(Constructor<?> constructor, int parameterIndex, Class<?> implementationClass)
ResolvableType for the specified Constructor parameter
 with a given implementation. Use this variant when the class that declares the
 constructor includes generic parameter variables that are satisfied by the
 implementation class.constructor - the source constructor (must not be null)parameterIndex - the parameter indeximplementationClass - the implementation classResolvableType for the specified constructor parameterforConstructorParameter(Constructor, int)public static ResolvableType forMethodReturnType(Method method)
ResolvableType for the specified Method return type.method - the source for the method return typeResolvableType for the specified method returnforMethodReturnType(Method, Class)public static ResolvableType forMethodReturnType(Method method, Class<?> implementationClass)
ResolvableType for the specified Method return type.
 Use this variant when the class that declares the method includes generic
 parameter variables that are satisfied by the implementation class.method - the source for the method return typeimplementationClass - the implementation classResolvableType for the specified method returnforMethodReturnType(Method)public static ResolvableType forMethodParameter(Method method, int parameterIndex)
ResolvableType for the specified Method parameter.method - the source method (must not be null)parameterIndex - the parameter indexResolvableType for the specified method parameterforMethodParameter(Method, int, Class), 
forMethodParameter(MethodParameter)public static ResolvableType forMethodParameter(Method method, int parameterIndex, Class<?> implementationClass)
ResolvableType for the specified Method parameter with a
 given implementation. Use this variant when the class that declares the method
 includes generic parameter variables that are satisfied by the implementation class.method - the source method (must not be null)parameterIndex - the parameter indeximplementationClass - the implementation classResolvableType for the specified method parameterforMethodParameter(Method, int, Class), 
forMethodParameter(MethodParameter)public static ResolvableType forMethodParameter(MethodParameter methodParameter)
ResolvableType for the specified MethodParameter.methodParameter - the source method parameter (must not be null)ResolvableType for the specified method parameterforMethodParameter(Method, int)public static ResolvableType forMethodParameter(MethodParameter methodParameter, @Nullable ResolvableType implementationType)
ResolvableType for the specified MethodParameter with a
 given implementation type. Use this variant when the class that declares the method
 includes generic parameter variables that are satisfied by the implementation type.methodParameter - the source method parameter (must not be null)implementationType - the implementation typeResolvableType for the specified method parameterforMethodParameter(MethodParameter)public static ResolvableType forMethodParameter(MethodParameter methodParameter, @Nullable Type targetType)
ResolvableType for the specified MethodParameter,
 overriding the target type to resolve with a specific given type.methodParameter - the source method parameter (must not be null)targetType - the type to resolve (a part of the method parameter's type)ResolvableType for the specified method parameterforMethodParameter(Method, int)public static ResolvableType forArrayComponent(ResolvableType componentType)
ResolvableType as a array of the specified componentType.componentType - the component typeResolvableType as an array of the specified component typepublic static ResolvableType forType(@Nullable Type type)
ResolvableType for the specified Type.
 Note: The resulting ResolvableType instance may not be Serializable.
type - the source type (potentially null)ResolvableType for the specified TypeforType(Type, ResolvableType)public static ResolvableType forType(@Nullable Type type, @Nullable ResolvableType owner)
ResolvableType for the specified Type backed by the given
 owner type.
 Note: The resulting ResolvableType instance may not be Serializable.
type - the source type or nullowner - the owner type used to resolve variablesResolvableType for the specified Type and ownerforType(Type)public static ResolvableType forType(ParameterizedTypeReference<?> typeReference)
ResolvableType for the specified ParameterizedTypeReference.
 Note: The resulting ResolvableType instance may not be Serializable.
typeReference - the reference to obtain the source type fromResolvableType for the specified ParameterizedTypeReferenceforType(Type)public static void clearCache()
ResolvableType/SerializableTypeWrapper cache.