ResolvableType (Lettuce 5.3.5.RELEASE API)

java.lang.Object
- io.lettuce.core.dynamic.support.ResolvableType

All Implemented Interfaces:

Serializable
```
public class ResolvableType
extends Object
implements Serializable
```
Encapsulates a Java Type, providing access to supertypes, interfaces, and generic parameters along with the ability to ultimately resolve to a Class.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface ResolvableType.VariableResolver
Strategy interface used to resolve TypeVariables.

Nested Classes
Modifier and Type	Class and Description
`static interface`	`ResolvableType.VariableResolver` Strategy interface used to resolve `TypeVariable`s.

Field Summary

Fields
Modifier and Type Field and Description

static ResolvableType NONE
ResolvableType returned when no value is available.

Fields
Modifier and Type	Field and Description
`static ResolvableType`	`NONE` `ResolvableType` returned when no value is available.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ResolvableType`	`as(Class<?> type)` Return this type as a `ResolvableType` of the specified class.
`ResolvableType`	`asCollection()` Convenience method to return this type as a resolvable `Collection` type.
`ResolvableType`	`asMap()` Convenience method to return this type as a resolvable `Map` type.
`boolean`	`equals(Object other)`
`static ResolvableType`	`forArrayComponent(ResolvableType componentType)` Return a `ResolvableType` as a array of the specified `componentType`.
`static ResolvableType`	`forClass(Class<?> sourceClass)` Return a `ResolvableType` for the specified `Class`, using the full generic type information for assignability checks.
`static ResolvableType`	`forClass(Class<?> sourceClass, Class<?> implementationClass)` Return a `ResolvableType` for the specified `Class` with a given implementation.
`static ResolvableType`	`forClassWithGenerics(Class<?> sourceClass, Class<?>... generics)` Return a `ResolvableType` for the specified `Class` with pre-declared generics.
`static ResolvableType`	`forClassWithGenerics(Class<?> sourceClass, ResolvableType... generics)` Return a `ResolvableType` for the specified `Class` with pre-declared generics.
`static ResolvableType`	`forMethodParameter(Method method, int parameterIndex)` Return a `ResolvableType` for the specified `Method` parameter.
`static ResolvableType`	`forMethodParameter(Method method, int parameterIndex, Class<?> implementationClass)` Return a `ResolvableType` for the specified `Method` parameter with a given implementation.
`static ResolvableType`	`forMethodParameter(MethodParameter methodParameter)` Return a `ResolvableType` for the specified `MethodParameter`.
`static ResolvableType`	`forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType)` Return a `ResolvableType` for the specified `MethodParameter` with a given implementation type.
`static ResolvableType`	`forMethodParameter(MethodParameter methodParameter, Type targetType)` Return a `ResolvableType` for the specified `MethodParameter`, overriding the target type to resolve with a specific given type.
`static ResolvableType`	`forMethodReturnType(Method method)` Return a `ResolvableType` for the specified `Method` return type.
`static ResolvableType`	`forMethodReturnType(Method method, Class<?> implementationClass)` Return a `ResolvableType` for the specified `Method` return type.
`static ResolvableType`	`forRawClass(Class<?> sourceClass)` Return a `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.
`static ResolvableType`	`forType(Type type)` Return a `ResolvableType` for the specified `Type`.
`static ResolvableType`	`forType(Type type, ResolvableType.VariableResolver variableResolver)` Return a `ResolvableType` for the specified `Type` backed by a given `ResolvableType.VariableResolver`.
`static ResolvableType`	`forType(Type type, ResolvableType owner)` Return a `ResolvableType` for the specified `Type` backed by the given owner type.
`ResolvableType`	`getComponentType()` Return the ResolvableType representing the component type of the array or `NONE` if this type does not represent an array.
`ResolvableType`	`getGeneric(int... indexes)` Return a `ResolvableType` representing the generic parameter for the given indexes.
`ResolvableType[]`	`getGenerics()` Return an array of `ResolvableType`s representing the generic parameters of this type.
`ResolvableType[]`	`getInterfaces()` Return a `ResolvableType` array representing the direct interfaces implemented by this type.
`ResolvableType`	`getNested(int nestingLevel)` Return a `ResolvableType` for the specified nesting level.
`ResolvableType`	`getNested(int nestingLevel, Map<Integer,Integer> typeIndexesPerLevel)` Return a `ResolvableType` for the specified nesting level.
`Class<?>`	`getRawClass()` Return the underlying Java `Class` being managed, if available; otherwise `null`.
`Object`	`getSource()` Return the underlying source of the resolvable type.
`ResolvableType`	`getSuperType()` Return a `ResolvableType` representing the direct supertype of this type.
`Type`	`getType()` Return the underling Java `Type` being managed.
`boolean`	`hasGenerics()` Return `true` if 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. without substituting that interface's type variables.
`boolean`	`isArray()` Return `true` if this type resolves to a Class that represents an array.
`boolean`	`isAssignableFrom(Class<?> other)` Determine whether this `ResolvableType` is assignable from the specified other type.
`boolean`	`isAssignableFrom(ResolvableType other)` Determine whether this `ResolvableType` is 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`, returning `null` if the type cannot be resolved.
`Class<?>`	`resolve(Class<?> fallback)` Resolve this type to a `Class`, returning the specified `fallback` if the type cannot be resolved.
`Class<?>`	`resolveGeneric(int... indexes)` Convenience method that will `get` and `resolve` a specific generic parameters.
`Class<?>[]`	`resolveGenerics()` Convenience method that will `get` and `resolve` generic parameters.
`Class<?>[]`	`resolveGenerics(Class<?> fallback)` Convenience method that will `get` and `resolve` generic parameters, using the specified `fallback` if any type cannot be resolved.
`ResolvableType`	`resolveType()` Resolve this type by a single level, returning the resolved value or `NONE`.
`String`	`toString()` Return a String representation of this type in its fully resolved form (including any generic parameters).

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - NONE
```
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.
- Method Detail
  - getType
```
public Type getType()
```
    Return the underling Java Type being managed. With the exception of the NONE constant, this method will never return null.
  - getRawClass
```
public Class<?> getRawClass()
```
    Return the underlying Java Class being managed, if available; otherwise null.
  - getSource
```
public Object getSource()
```
    Return the underlying source of the resolvable type. Will return a 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.
  - isInstance
```
public boolean isInstance(Object obj)
```
    Determine whether the given object is an instance of this ResolvableType.
    
    Parameters:
    
    obj - the object to check.
    
    See Also:
    
    isAssignableFrom(Class)
  - isAssignableFrom
```
public boolean isAssignableFrom(Class<?> other)
```
    Determine whether this ResolvableType is assignable from the specified other type.
    
    Parameters:
    
    other - the type to be checked against (as a Class).
    
    See Also:
    
    isAssignableFrom(ResolvableType)
  - isAssignableFrom
```
public boolean isAssignableFrom(ResolvableType other)
```
    Determine whether this 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.
    
    Parameters:
    
    other - the type to be checked against (as a ResolvableType).
    
    Returns:
    
    true if the specified other type can be assigned to this ResolvableType; false otherwise.
  - isArray
```
public boolean isArray()
```
    Return true if this type resolves to a Class that represents an array.
    
    See Also:
    
    getComponentType()
  - getComponentType
```
public ResolvableType getComponentType()
```
    Return the ResolvableType representing the component type of the array or NONE if this type does not represent an array.
    
    See Also:
    
    isArray()
  - asCollection
```
public ResolvableType asCollection()
```
    Convenience method to return this type as a resolvable Collection type. Returns NONE if this type does not implement or extend Collection.
    
    See Also:
    
    as(Class), asMap()
  - asMap
```
public ResolvableType asMap()
```
    Convenience method to return this type as a resolvable Map type. Returns NONE if this type does not implement or extend Map.
    
    See Also:
    
    as(Class), asCollection()
  - as
```
public ResolvableType as(Class<?> type)
```
    Return this type as a 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.
    
    Parameters:
    
    type - the required class type.
    
    Returns:
    
    a ResolvableType representing this object as the specified type, or NONE if not resolvable as that type.
    
    See Also:
    
    asCollection(), asMap(), getSuperType(), getInterfaces()
  - getSuperType
```
public ResolvableType getSuperType()
```
    Return a ResolvableType representing the direct supertype of this type. If no supertype is available this method returns NONE.
    
    See Also:
    
    getInterfaces()
  - getInterfaces
```
public ResolvableType[] getInterfaces()
```
    Return a ResolvableType array representing the direct interfaces implemented by this type. If this type does not implement any interfaces an empty array is returned.
    
    See Also:
    
    getSuperType()
  - hasGenerics
```
public boolean hasGenerics()
```
    Return true if this type contains generic parameters.
    
    See Also:
    
    getGeneric(int...), getGenerics()
  - hasUnresolvableGenerics
```
public 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. without substituting that interface's type variables. The result will be true only in those two scenarios.
  - getNested
```
public ResolvableType getNested(int nestingLevel)
```
    Return a ResolvableType for the specified nesting level. See getNested(int, Map) for details.
    
    Parameters:
    
    nestingLevel - the nesting level.
    
    Returns:
    
    the ResolvableType type, or #NONE.
  - getNested
```
public ResolvableType getNested(int nestingLevel,
                                Map<Integer,Integer> typeIndexesPerLevel)
```
    Return a 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.
    
    Parameters:
    
    nestingLevel - the required nesting level, indexed from 1 for the current type, 2 for the first nested generic, 3 for the second and so on.
    
    typeIndexesPerLevel - a map containing the generic index for a given nesting level (may be null).
    
    Returns:
    
    a ResolvableType for the nested level or NONE.
  - getGeneric
```
public ResolvableType getGeneric(int... indexes)
```
    Return a 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.
    
    Parameters:
    
    indexes - the indexes that refer to the generic parameter (may be omitted to return the first generic).
    
    Returns:
    
    a ResolvableType for the specified generic or NONE.
    
    See Also:
    
    hasGenerics(), getGenerics(), resolveGeneric(int...), resolveGenerics()
  - getGenerics
```
public ResolvableType[] getGenerics()
```
    Return an array of 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.
    
    Returns:
    
    an array of ResolvableTypes representing the generic parameters (never null).
    
    See Also:
    
    hasGenerics(), getGeneric(int...), resolveGeneric(int...), resolveGenerics()
  - resolveGenerics
```
public Class<?>[] resolveGenerics()
```
    Convenience method that will get and resolve generic parameters.
    
    Returns:
    
    an array of resolved generic parameters (the resulting array will never be null, but it may contain null elements}).
    
    See Also:
    
    getGenerics(), resolve()
  - resolveGenerics
```
public Class<?>[] resolveGenerics(Class<?> fallback)
```
    Convenience method that will get and resolve generic parameters, using the specified fallback if any type cannot be resolved.
    
    Parameters:
    
    fallback - the fallback class to use if resolution fails (may be null).
    
    Returns:
    
    an array of resolved generic parameters (the resulting array will never be null, but it may contain null elements}).
    
    See Also:
    
    getGenerics(), resolve()
  - resolveGeneric
```
public Class<?> resolveGeneric(int... indexes)
```
    Convenience method that will get and resolve a specific generic parameters.
    
    Parameters:
    
    indexes - the indexes that refer to the generic parameter (may be omitted to return the first generic).
    
    Returns:
    
    a resolved Class or null.
    
    See Also:
    
    getGeneric(int...), resolve()
  - resolve
```
public Class<?> resolve()
```
    Resolve this type to a 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.
    
    Returns:
    
    the resolved Class, or null if not resolvable.
    
    See Also:
    
    resolve(Class), resolveGeneric(int...), resolveGenerics()
  - resolve
```
public Class<?> resolve(Class<?> fallback)
```
    Resolve this type to a 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.
    
    Parameters:
    
    fallback - the fallback class to use if resolution fails (may be null).
    
    Returns:
    
    the resolved Class or the fallback.
    
    See Also:
    
    resolve(), resolveGeneric(int...), resolveGenerics()
  - resolveType
```
public ResolvableType resolveType()
```
    Resolve this type by a single level, returning the resolved value or NONE.
    Note: The returned ResolvableType should only be used as an intermediary as it cannot be serialized.
  - equals
```
public boolean equals(Object other)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Return a String representation of this type in its fully resolved form (including any generic parameters).
    
    Overrides:
    
    toString in class Object
  - forClass
```
public static ResolvableType forClass(Class<?> sourceClass)
```
    Return a ResolvableType for the specified Class, using the full generic type information for assignability checks. For example: ResolvableType.forClass(MyArrayList.class).
    
    Parameters:
    
    sourceClass - the source class (null is semantically equivalent to Object.class for typical use cases here}.
    
    Returns:
    
    a ResolvableType for the specified class.
    
    See Also:
    
    forClass(Class, Class), forClassWithGenerics(Class, Class...)
  - forRawClass
```
public static ResolvableType forRawClass(Class<?> sourceClass)
```
    Return a 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.forClass(MyArrayList.class).
    
    Parameters:
    
    sourceClass - the source class (null is semantically equivalent to Object.class for typical use cases here}.
    
    Returns:
    
    a ResolvableType for the specified class.
    
    See Also:
    
    forClass(Class), getRawClass()
  - forClass
```
public static ResolvableType forClass(Class<?> sourceClass,
                                      Class<?> implementationClass)
```
    Return a ResolvableType for the specified Class with a given implementation. For example: ResolvableType.forClass(List.class, MyArrayList.class).
    
    Parameters:
    
    sourceClass - the source class (must not be null.
    
    implementationClass - the implementation class.
    
    Returns:
    
    a ResolvableType for the specified class backed by the given implementation class.
    
    See Also:
    
    forClass(Class), forClassWithGenerics(Class, Class...)
  - forClassWithGenerics
```
public static ResolvableType forClassWithGenerics(Class<?> sourceClass,
                                                  Class<?>... generics)
```
    Return a ResolvableType for the specified Class with pre-declared generics.
    
    Parameters:
    
    sourceClass - the source class.
    
    generics - the generics of the class.
    
    Returns:
    
    a ResolvableType for the specific class and generics.
    
    See Also:
    
    forClassWithGenerics(Class, ResolvableType...)
  - forClassWithGenerics
```
public static ResolvableType forClassWithGenerics(Class<?> sourceClass,
                                                  ResolvableType... generics)
```
    Return a ResolvableType for the specified Class with pre-declared generics.
    
    Parameters:
    
    sourceClass - the source class.
    
    generics - the generics of the class.
    
    Returns:
    
    a ResolvableType for the specific class and generics.
    
    See Also:
    
    forClassWithGenerics(Class, Class...)
  - forMethodReturnType
```
public static ResolvableType forMethodReturnType(Method method)
```
    Return a ResolvableType for the specified Method return type.
    
    Parameters:
    
    method - the source for the method return type.
    
    Returns:
    
    a ResolvableType for the specified method return.
    
    See Also:
    
    forMethodReturnType(Method, Class)
  - forMethodReturnType
```
public static ResolvableType forMethodReturnType(Method method,
                                                 Class<?> implementationClass)
```
    Return a 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.
    
    Parameters:
    
    method - the source for the method return type.
    
    implementationClass - the implementation class.
    
    Returns:
    
    a ResolvableType for the specified method return.
    
    See Also:
    
    forMethodReturnType(Method)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(Method method,
                                                int parameterIndex)
```
    Return a ResolvableType for the specified Method parameter.
    
    Parameters:
    
    method - the source method (must not be null).
    
    parameterIndex - the parameter index.
    
    Returns:
    
    a ResolvableType for the specified method parameter.
    
    See Also:
    
    forMethodParameter(Method, int, Class), forMethodParameter(MethodParameter)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(Method method,
                                                int parameterIndex,
                                                Class<?> implementationClass)
```
    Return a 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.
    
    Parameters:
    
    method - the source method (must not be null).
    
    parameterIndex - the parameter index.
    
    implementationClass - the implementation class.
    
    Returns:
    
    a ResolvableType for the specified method parameter.
    
    See Also:
    
    forMethodParameter(Method, int, Class), forMethodParameter(MethodParameter)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(MethodParameter methodParameter)
```
    Return a ResolvableType for the specified MethodParameter.
    
    Parameters:
    
    methodParameter - the source method parameter (must not be null).
    
    Returns:
    
    a ResolvableType for the specified method parameter.
    
    See Also:
    
    forMethodParameter(Method, int)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(MethodParameter methodParameter,
                                                ResolvableType implementationType)
```
    Return a 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.
    
    Parameters:
    
    methodParameter - the source method parameter (must not be null).
    
    implementationType - the implementation type.
    
    Returns:
    
    a ResolvableType for the specified method parameter.
    
    See Also:
    
    forMethodParameter(MethodParameter)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(MethodParameter methodParameter,
                                                Type targetType)
```
    Return a ResolvableType for the specified MethodParameter, overriding the target type to resolve with a specific given type.
    
    Parameters:
    
    methodParameter - the source method parameter (must not be null).
    
    targetType - the type to resolve (a part of the method parameter's type).
    
    Returns:
    
    a ResolvableType for the specified method parameter.
    
    See Also:
    
    forMethodParameter(Method, int)
  - forArrayComponent
```
public static ResolvableType forArrayComponent(ResolvableType componentType)
```
    Return a ResolvableType as a array of the specified componentType.
    
    Parameters:
    
    componentType - the component type.
    
    Returns:
    
    a ResolvableType as an array of the specified component type.
  - forType
```
public static ResolvableType forType(Type type)
```
    Return a ResolvableType for the specified Type. Note: The resulting ResolvableType may not be Serializable.
    
    Parameters:
    
    type - the source type or null.
    
    Returns:
    
    a ResolvableType for the specified Type.
    
    See Also:
    
    forType(Type, ResolvableType)
  - forType
```
public static ResolvableType forType(Type type,
                                     ResolvableType owner)
```
    Return a ResolvableType for the specified Type backed by the given owner type. Note: The resulting ResolvableType may not be Serializable.
    
    Parameters:
    
    type - the source type or null.
    
    owner - the owner type used to resolve variables.
    
    Returns:
    
    a ResolvableType for the specified Type and owner.
    
    See Also:
    
    forType(Type)
  - forType
```
public static ResolvableType forType(Type type,
                                     ResolvableType.VariableResolver variableResolver)
```
    Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
    
    Parameters:
    
    type - the source type or null.
    
    variableResolver - the variable resolver or null.
    
    Returns:
    
    a ResolvableType for the specified Type and ResolvableType.VariableResolver.

Class ResolvableType

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NONE

Method Detail

getType

getRawClass

getSource

isInstance

isAssignableFrom

isAssignableFrom

isArray

getComponentType

asCollection

asMap

as

getSuperType

getInterfaces

hasGenerics

hasUnresolvableGenerics

getNested

getNested

getGeneric

getGenerics

resolveGenerics

resolveGenerics

resolveGeneric

resolve

resolve

resolveType

equals

hashCode

toString

forClass

forRawClass

forClass

forClassWithGenerics

forClassWithGenerics

forMethodReturnType

forMethodReturnType

forMethodParameter

forMethodParameter

forMethodParameter

forMethodParameter

forMethodParameter

forArrayComponent

forType

forType

forType