public class TypeResolver extends Object implements Serializable
Note that resolver instances are stateful in that resolvers cache resolved types for efficiency. Since this is internal state and not directly visible to callers, access to state is fully synchronized so that access from multiple threads is safe.
Modifier and Type | Field and Description |
---|---|
protected static HashMap<ClassKey,ResolvedType> |
_primitiveTypes
Since number of primitive types is small, and they are frequently needed,
let's actually pre-create them for efficient reuse.
|
protected ResolvedTypeCache |
_resolvedTypes
Simple cache of types resolved by this resolved; capped to last 200 resolved types.
|
Constructor and Description |
---|
TypeResolver() |
Modifier and Type | Method and Description |
---|---|
ResolvedArrayType |
arrayType(Type elementType)
Factory method for constructing array type of given element type.
|
static boolean |
isSelfReference(ResolvedType type)
Helper method that can be used to checked whether given resolved type
(with erased type of
java.lang.Object ) is a placeholder
for "self-reference"; these are nasty recursive ("self") types
needed with some interfaces |
ResolvedType |
resolve(TypeBindings typeBindings,
Type jdkType)
Factory method for resolving specified Java
Type , given
TypeBindings needed to resolve any type variables. |
ResolvedType |
resolve(Type type,
Type... typeParameters)
Factory method for resolving given base type
using specified types as type parameters.
|
ResolvedType |
resolveSubtype(ResolvedType supertype,
Class<?> subtype)
Factory method for constructing sub-classing specified type; class specified
as sub-class must be compatible according to basic Java inheritance rules
(subtype must propery extend or implement specified supertype).
|
protected static final HashMap<ClassKey,ResolvedType> _primitiveTypes
protected final ResolvedTypeCache _resolvedTypes
public ResolvedType resolve(Type type, Type... typeParameters)
ResolvedType type = TypeResolver.resolve(List.class, Integer.class);which would be equivalent to
ResolvedType type = TypeResolver.resolve(new GenericType<List<Integer>>() { });Note that you can mix different types of type parameters, whether already resolved (
ResolvedType
), type-erased (Class
) or
generic type reference (GenericType
).public ResolvedArrayType arrayType(Type elementType)
public ResolvedType resolve(TypeBindings typeBindings, Type jdkType)
Type
, given
TypeBindings
needed to resolve any type variables.
Use of this method is discouraged (use if and only if you really know what you
are doing!); but if used, type bindings passed should come from ResolvedType
instance of declaring class (or interface).
NOTE: order of arguments was reversed for 0.8, to avoid problems with overload varargs method.
public ResolvedType resolveSubtype(ResolvedType supertype, Class<?> subtype) throws IllegalArgumentException, UnsupportedOperationException
A typical use case here is to refine a generic type; for example, given
that we have generic type like List<Integer>
, but we want
a more specific implementation type like
class ArrayList
but with same parameterization (here just Integer
),
we could achieve it by:
ResolvedType mapType = typeResolver.resolve(List.class, Integer.class); ResolveType concreteMapType = typeResolver.resolveSubType(mapType, ArrayList.class);(in this case, it would have been simpler to resolve directly; but in some cases we are handled supertype and want to refine it, in which case steps would be the same but separated by other code)
Note that this method will fail if extension can not succeed; either because
this type is not extendable (sub-classable) -- which is true for primitive
and array types -- or because given class is not a subtype of this type.
To check whether subtyping could succeed, you can call
ResolvedType.canCreateSubtypes()
to see if supertype can ever
be extended.
supertype
- Type to subtype (extend)subtype
- Type-erased sub-class or sub-interfaceIllegalArgumentException
- If this type can be extended in general, but not into specified sub-classUnsupportedOperationException
- If this type can not be sub-classedpublic static boolean isSelfReference(ResolvedType type)
java.lang.Object
) is a placeholder
for "self-reference"; these are nasty recursive ("self") types
needed with some interfacesCopyright © 2015 fasterxml.com. All rights reserved.