Class ResolvableType
- java.lang.Object
-
- io.lettuce.core.dynamic.support.ResolvableType
-
- All Implemented Interfaces:
Serializable
public class ResolvableType extends Object implements Serializable
Encapsulates a JavaType
, providing access tosupertypes
,interfaces
, andgeneric parameters
along with the ability to ultimatelyresolve
to aClass
.- See Also:
- Serialized Form
-
-
Nested Class Summary
Nested Classes Modifier and Type Class Description static interface
ResolvableType.VariableResolver
Strategy interface used to resolveTypeVariable
s.
-
Field Summary
Fields Modifier and Type Field 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 Description ResolvableType
as(Class<?> type)
Return this type as aResolvableType
of the specified class.ResolvableType
asCollection()
Convenience method to return this type as a resolvableCollection
type.ResolvableType
asMap()
Convenience method to return this type as a resolvableMap
type.boolean
equals(Object other)
static ResolvableType
forArrayComponent(ResolvableType componentType)
Return aResolvableType
as a array of the specifiedcomponentType
.static ResolvableType
forClass(Class<?> sourceClass)
Return aResolvableType
for the specifiedClass
, using the full generic type information for assignability checks.static ResolvableType
forClass(Class<?> sourceClass, Class<?> implementationClass)
Return aResolvableType
for the specifiedClass
with a given implementation.static ResolvableType
forClassWithGenerics(Class<?> sourceClass, ResolvableType... generics)
Return aResolvableType
for the specifiedClass
with pre-declared generics.static ResolvableType
forClassWithGenerics(Class<?> sourceClass, Class<?>... generics)
Return aResolvableType
for the specifiedClass
with pre-declared generics.static ResolvableType
forMethodParameter(MethodParameter methodParameter)
Return aResolvableType
for the specifiedMethodParameter
.static ResolvableType
forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType)
Return aResolvableType
for the specifiedMethodParameter
with a given implementation type.static ResolvableType
forMethodParameter(MethodParameter methodParameter, Type targetType)
Return aResolvableType
for the specifiedMethodParameter
, overriding the target type to resolve with a specific given type.static ResolvableType
forMethodParameter(Method method, int parameterIndex)
Return aResolvableType
for the specifiedMethod
parameter.static ResolvableType
forMethodParameter(Method method, int parameterIndex, Class<?> implementationClass)
Return aResolvableType
for the specifiedMethod
parameter with a given implementation.static ResolvableType
forMethodReturnType(Method method)
Return aResolvableType
for the specifiedMethod
return type.static ResolvableType
forMethodReturnType(Method method, Class<?> implementationClass)
Return aResolvableType
for the specifiedMethod
return type.static ResolvableType
forRawClass(Class<?> sourceClass)
Return aResolvableType
for 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(Type type)
Return aResolvableType
for the specifiedType
.static ResolvableType
forType(Type type, ResolvableType owner)
Return aResolvableType
for the specifiedType
backed by the given owner type.static ResolvableType
forType(Type type, ResolvableType.VariableResolver variableResolver)
ResolvableType
getComponentType()
Return the ResolvableType representing the component type of the array orNONE
if this type does not represent an array.ResolvableType
getGeneric(int... indexes)
Return aResolvableType
representing the generic parameter for the given indexes.ResolvableType[]
getGenerics()
Return an array ofResolvableType
s representing the generic parameters of this type.ResolvableType[]
getInterfaces()
Return aResolvableType
array representing the direct interfaces implemented by this type.ResolvableType
getNested(int nestingLevel)
Return aResolvableType
for the specified nesting level.ResolvableType
getNested(int nestingLevel, Map<Integer,Integer> typeIndexesPerLevel)
Return aResolvableType
for the specified nesting level.Class<?>
getRawClass()
Return the underlying JavaClass
being managed, if available; otherwisenull
.Object
getSource()
Return the underlying source of the resolvable type.ResolvableType
getSuperType()
Return aResolvableType
representing the direct supertype of this type.Type
getType()
Return the underling JavaType
being managed.boolean
hasGenerics()
Returntrue
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.boolean
isArray()
Returntrue
if this type resolves to a Class that represents an array.boolean
isAssignableFrom(ResolvableType other)
Determine whether thisResolvableType
is assignable from the specified other type.boolean
isAssignableFrom(Class<?> other)
Determine whether thisResolvableType
is assignable from the specified other type.boolean
isInstance(Object obj)
Determine whether the given object is an instance of thisResolvableType
.Class<?>
resolve()
Resolve this type to aClass
, returningnull
if the type cannot be resolved.Class<?>
resolve(Class<?> fallback)
Resolve this type to aClass
, returning the specifiedfallback
if the type cannot be resolved.Class<?>
resolveGeneric(int... indexes)
Class<?>[]
resolveGenerics()
Class<?>[]
resolveGenerics(Class<?> fallback)
ResolvableType
resolveType()
Resolve this type by a single level, returning the resolved value orNONE
.String
toString()
Return a String representation of this type in its fully resolved form (including any generic parameters).
-
-
-
Field Detail
-
NONE
public static final ResolvableType NONE
ResolvableType
returned when no value is available.NONE
is used in preference tonull
so that multiple method calls can be safely chained.
-
-
Method Detail
-
getType
public Type getType()
-
getRawClass
public Class<?> getRawClass()
Return the underlying JavaClass
being managed, if available; otherwisenull
.
-
getSource
public Object getSource()
Return the underlying source of the resolvable type. Will return aField
,MethodParameter
orType
depending on how theResolvableType
was constructed. With the exception of theNONE
constant, this method will never returnnull
. 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 thisResolvableType
.- Parameters:
obj
- the object to check- See Also:
isAssignableFrom(Class)
-
isAssignableFrom
public boolean isAssignableFrom(Class<?> other)
Determine whether thisResolvableType
is assignable from the specified other type.- Parameters:
other
- the type to be checked against (as aClass
)- See Also:
isAssignableFrom(ResolvableType)
-
isAssignableFrom
public boolean isAssignableFrom(ResolvableType other)
Determine whether thisResolvableType
is assignable from the specified other type.Attempts to follow the same rules as the Java compiler, considering whether both the
resolved
Class
isassignable from
the given type as well as whether allgenerics
are assignable.- Parameters:
other
- the type to be checked against (as aResolvableType
)- Returns:
true
if the specified other type can be assigned to thisResolvableType
;false
otherwise
-
isArray
public boolean isArray()
Returntrue
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 orNONE
if this type does not represent an array.- See Also:
isArray()
-
asCollection
public ResolvableType asCollection()
Convenience method to return this type as a resolvableCollection
type. ReturnsNONE
if this type does not implement or extendCollection
.
-
asMap
public ResolvableType asMap()
Convenience method to return this type as a resolvableMap
type. ReturnsNONE
if this type does not implement or extendMap
.- See Also:
as(Class)
,asCollection()
-
as
public ResolvableType as(Class<?> type)
Return this type as aResolvableType
of the specified class. Searchessupertype
andinterface
hierarchies to find a match, returningNONE
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, orNONE
if not resolvable as that type - See Also:
asCollection()
,asMap()
,getSuperType()
,getInterfaces()
-
getSuperType
public ResolvableType getSuperType()
Return aResolvableType
representing the direct supertype of this type. If no supertype is available this method returnsNONE
.- See Also:
getInterfaces()
-
getInterfaces
public ResolvableType[] getInterfaces()
Return aResolvableType
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()
Returntrue
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 betrue
only in those two scenarios.
-
getNested
public ResolvableType getNested(int nestingLevel)
Return aResolvableType
for the specified nesting level. SeegetNested(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 aResolvableType
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, givenList<Set<Integer>>
level 1 refers to theList
, level 2 theSet
, and level 3 theInteger
.The
typeIndexesPerLevel
map can be used to reference a specific generic for the given level. For example, an index of 0 would refer to aMap
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. aMap
value).Nesting levels may also apply to array types; for example given
String[]
, a nesting level of 2 refers toString
.If a type does not
contain
generics thesupertype
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 ontypeIndexesPerLevel
- a map containing the generic index for a given nesting level (may benull
)- Returns:
- a
ResolvableType
for the nested level orNONE
-
getGeneric
public ResolvableType getGeneric(int... indexes)
Return aResolvableType
representing the generic parameter for the given indexes. Indexes are zero based; for example given the typeMap<Integer, List<String>>
,getGeneric(0)
will access theInteger
. Nested generics can be accessed by specifying multiple indexes; for examplegetGeneric(1, 0)
will access theString
from the nestedList
. 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 orNONE
- See Also:
hasGenerics()
,getGenerics()
,resolveGeneric(int...)
,resolveGenerics()
-
getGenerics
public ResolvableType[] getGenerics()
Return an array ofResolvableType
s 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 thegetGeneric(int...)
method as it allows access to nested generics and protects againstIndexOutOfBoundsExceptions
.- Returns:
- an array of
ResolvableType
s representing the generic parameters (nevernull
) - See Also:
hasGenerics()
,getGeneric(int...)
,resolveGeneric(int...)
,resolveGenerics()
-
resolveGenerics
public Class<?>[] resolveGenerics()
- Returns:
- an array of resolved generic parameters (the resulting array will never be
null
, but it may containnull
elements}) - See Also:
getGenerics()
,resolve()
-
resolveGenerics
public Class<?>[] resolveGenerics(Class<?> fallback)
Convenience method that willget
andresolve
generic parameters, using the specifiedfallback
if any type cannot be resolved.- Parameters:
fallback
- the fallback class to use if resolution fails (may benull
)- Returns:
- an array of resolved generic parameters (the resulting array will never be
null
, but it may containnull
elements}) - See Also:
getGenerics()
,resolve()
-
resolveGeneric
public Class<?> resolveGeneric(int... indexes)
- Parameters:
indexes
- the indexes that refer to the generic parameter (may be omitted to return the first generic)- Returns:
- a resolved
Class
ornull
- See Also:
getGeneric(int...)
,resolve()
-
resolve
public Class<?> resolve()
Resolve this type to aClass
, returningnull
if the type cannot be resolved. This method will consider bounds ofTypeVariable
s andWildcardType
s if direct resolution fails; however, bounds ofObject.class
will be ignored.- Returns:
- the resolved
Class
, ornull
if not resolvable - See Also:
resolve(Class)
,resolveGeneric(int...)
,resolveGenerics()
-
resolve
public Class<?> resolve(Class<?> fallback)
Resolve this type to aClass
, returning the specifiedfallback
if the type cannot be resolved. This method will consider bounds ofTypeVariable
s andWildcardType
s if direct resolution fails; however, bounds ofObject.class
will be ignored.- Parameters:
fallback
- the fallback class to use if resolution fails (may benull
)- Returns:
- the resolved
Class
or thefallback
- See Also:
resolve()
,resolveGeneric(int...)
,resolveGenerics()
-
resolveType
public ResolvableType resolveType()
Resolve this type by a single level, returning the resolved value orNONE
.Note: The returned
ResolvableType
should only be used as an intermediary as it cannot be serialized.
-
toString
public String toString()
Return a String representation of this type in its fully resolved form (including any generic parameters).
-
forClass
public static ResolvableType forClass(Class<?> sourceClass)
Return aResolvableType
for the specifiedClass
, using the full generic type information for assignability checks. For example:ResolvableType.forClass(MyArrayList.class)
.- Parameters:
sourceClass
- the source class (null
is semantically equivalent toObject.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 aResolvableType
for the specifiedClass
, doing assignability checks against the raw class only (analogous toClass.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 toObject.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 aResolvableType
for the specifiedClass
with a given implementation. For example:ResolvableType.forClass(List.class, MyArrayList.class)
.- Parameters:
sourceClass
- the source class (must not benull
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 aResolvableType
for the specifiedClass
with pre-declared generics.- Parameters:
sourceClass
- the source classgenerics
- 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 aResolvableType
for the specifiedClass
with pre-declared generics.- Parameters:
sourceClass
- the source classgenerics
- 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 aResolvableType
for the specifiedMethod
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 aResolvableType
for the specifiedMethod
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 typeimplementationClass
- 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 aResolvableType
for the specifiedMethod
parameter.- Parameters:
method
- the source method (must not benull
)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 aResolvableType
for the specifiedMethod
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 benull
)parameterIndex
- the parameter indeximplementationClass
- 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 aResolvableType
for the specifiedMethodParameter
.- Parameters:
methodParameter
- the source method parameter (must not benull
)- Returns:
- a
ResolvableType
for the specified method parameter - See Also:
forMethodParameter(Method, int)
-
forMethodParameter
public static ResolvableType forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType)
Return aResolvableType
for the specifiedMethodParameter
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 benull
)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 aResolvableType
for the specifiedMethodParameter
, overriding the target type to resolve with a specific given type.- Parameters:
methodParameter
- the source method parameter (must not benull
)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 aResolvableType
as a array of the specifiedcomponentType
.- Parameters:
componentType
- the component type- Returns:
- a
ResolvableType
as an array of the specified component type
-
forType
public static ResolvableType forType(Type type)
Return aResolvableType
for the specifiedType
. Note: The resultingResolvableType
may not beSerializable
.- Parameters:
type
- the source type ornull
- Returns:
- a
ResolvableType
for the specifiedType
- See Also:
forType(Type, ResolvableType)
-
forType
public static ResolvableType forType(Type type, ResolvableType owner)
Return aResolvableType
for the specifiedType
backed by the given owner type. Note: The resultingResolvableType
may not beSerializable
.- Parameters:
type
- the source type ornull
owner
- the owner type used to resolve variables- Returns:
- a
ResolvableType
for the specifiedType
and owner - See Also:
forType(Type)
-
forType
public static ResolvableType forType(Type type, ResolvableType.VariableResolver variableResolver)
- Parameters:
type
- the source type ornull
variableResolver
- the variable resolver ornull
- Returns:
- a
ResolvableType
for the specifiedType
andResolvableType.VariableResolver
-
-