public class TypeFactory extends Object implements Serializable
JavaType
instances,
given various inputs.
Instances of this class are accessible using ObjectMapper
as well as many objects it constructs (like
DeserializationConfig
and
SerializationConfig
)),
but usually those objects also
expose convenience methods (constructType
).
So, you can do for example:
JavaType stringType = mapper.constructType(String.class);However, more advanced methods are only exposed by factory so that you may need to use:
JavaType stringCollection = mapper.getTypeFactory().constructCollectionType(List.class, String.class);
Note on optimizations: generic type parameters are resolved for all types, with following exceptions:
Enum
: Self-referential type reference is simply dropped and
Class is exposed as a simple, non-parameterized SimpleType
Comparable
: Type parameter is simply dropped and and
interface is exposed as a simple, non-parameterized SimpleType
Class
type parameter was dropped; resolution
was added back in Jackson 2.14.
Collection
subtypes, resolved type is ALWAYS the parameter for
{link java.util.Collection} and not that of actually resolved subtype.
This is usually (but not always) same parameter.
Map
subtypes, resolved type is ALWAYS the parameter for
{link java.util.Map} and not that of actually resolved subtype.
These are usually (but not always) same parameters.
Modifier and Type | Field and Description |
---|---|
protected ClassLoader |
_classLoader
ClassLoader used by this factory [databind#624].
|
protected TypeModifier[] |
_modifiers
Registered
TypeModifier s: objects that can change details
of JavaType instances factory constructs. |
protected TypeParser |
_parser |
protected LookupCache<Object,JavaType> |
_typeCache
Since type resolution can be expensive (specifically when resolving
actual generic types), we will use small cache to avoid repetitive
resolution of core types
|
protected static SimpleType |
CORE_TYPE_BOOL |
protected static SimpleType |
CORE_TYPE_COMPARABLE
Cache
Comparable because it is both parameteric (relatively costly to
resolve) and mostly useless (no special handling), better handle directly |
protected static SimpleType |
CORE_TYPE_ENUM
Cache
Enum because it is parametric AND self-referential (costly to
resolve) and useless in itself (no special handling). |
protected static SimpleType |
CORE_TYPE_INT |
protected static SimpleType |
CORE_TYPE_JSON_NODE
Cache
JsonNode because it is no critical path of simple tree model
reading and does not have things to override |
protected static SimpleType |
CORE_TYPE_LONG |
protected static SimpleType |
CORE_TYPE_OBJECT |
protected static SimpleType |
CORE_TYPE_STRING |
protected static TypeBindings |
EMPTY_BINDINGS |
protected static TypeFactory |
instance
Globally shared singleton.
|
Modifier | Constructor and Description |
---|---|
protected |
TypeFactory(LookupCache<Object,JavaType> typeCache) |
protected |
TypeFactory(LookupCache<Object,JavaType> typeCache,
TypeParser p,
TypeModifier[] mods,
ClassLoader classLoader) |
protected |
TypeFactory(LRUMap<Object,JavaType> typeCache)
Deprecated.
Since 2.12
|
protected |
TypeFactory(LRUMap<Object,JavaType> typeCache,
TypeParser p,
TypeModifier[] mods,
ClassLoader classLoader)
Deprecated.
Since 2.12
|
Modifier and Type | Method and Description |
---|---|
protected JavaType |
_applyModifiers(Type srcType,
JavaType resolvedType) |
protected JavaType |
_constructSimple(Class<?> raw,
TypeBindings bindings,
JavaType superClass,
JavaType[] superInterfaces)
Factory method to call when no special
JavaType is needed,
no generic parameters are passed. |
protected Class<?> |
_findPrimitive(String className) |
protected JavaType |
_findWellKnownSimple(Class<?> clz)
Helper method called to see if requested, non-generic-parameterized
type is one of common, "well-known" types, instances of which are
pre-constructed and do not need dynamic caching.
|
protected JavaType |
_fromAny(ClassStack context,
Type srcType,
TypeBindings bindings)
Factory method that can be used if type information is passed
as Java typing returned from
getGenericXxx methods
(usually for a return or argument type). |
protected JavaType |
_fromArrayType(ClassStack context,
GenericArrayType type,
TypeBindings bindings) |
protected JavaType |
_fromClass(ClassStack context,
Class<?> rawType,
TypeBindings bindings) |
protected JavaType |
_fromParamType(ClassStack context,
ParameterizedType ptype,
TypeBindings parentBindings)
This method deals with parameterized types, that is,
first class generic classes.
|
protected JavaType |
_fromVariable(ClassStack context,
TypeVariable<?> var,
TypeBindings bindings) |
protected JavaType |
_fromWellKnownClass(ClassStack context,
Class<?> rawType,
TypeBindings bindings,
JavaType superClass,
JavaType[] superInterfaces)
Helper class used to check whether exact class for which type is being constructed
is one of well-known base interfaces or classes that indicates alternate
JavaType implementation. |
protected JavaType |
_fromWellKnownInterface(ClassStack context,
Class<?> rawType,
TypeBindings bindings,
JavaType superClass,
JavaType[] superInterfaces) |
protected JavaType |
_fromWildcard(ClassStack context,
WildcardType type,
TypeBindings bindings) |
protected JavaType |
_newSimpleType(Class<?> raw,
TypeBindings bindings,
JavaType superClass,
JavaType[] superInterfaces)
Factory method that is to create a new
SimpleType with no
checks whatsoever. |
protected JavaType |
_resolveSuperClass(ClassStack context,
Class<?> rawType,
TypeBindings parentBindings) |
protected JavaType[] |
_resolveSuperInterfaces(ClassStack context,
Class<?> rawType,
TypeBindings parentBindings) |
protected JavaType |
_unknownType() |
protected Class<?> |
classForName(String name) |
protected Class<?> |
classForName(String name,
boolean initialize,
ClassLoader loader) |
void |
clearCache()
Method that will clear up any cached type definitions that may
be cached by this
TypeFactory instance. |
ArrayType |
constructArrayType(Class<?> elementType)
Method for constructing an
ArrayType . |
ArrayType |
constructArrayType(JavaType elementType)
Method for constructing an
ArrayType . |
CollectionLikeType |
constructCollectionLikeType(Class<?> collectionClass,
Class<?> elementClass)
Method for constructing a
CollectionLikeType . |
CollectionLikeType |
constructCollectionLikeType(Class<?> collectionClass,
JavaType elementType)
Method for constructing a
CollectionLikeType . |
CollectionType |
constructCollectionType(Class<? extends Collection> collectionClass,
Class<?> elementClass)
Method for constructing a
CollectionType . |
CollectionType |
constructCollectionType(Class<? extends Collection> collectionClass,
JavaType elementType)
Method for constructing a
CollectionType . |
JavaType |
constructFromCanonical(String canonical)
Factory method for constructing a
JavaType out of its canonical
representation (see ResolvedType.toCanonical() ). |
JavaType |
constructGeneralizedType(JavaType baseType,
Class<?> superClass)
Method similar to
constructSpecializedType(com.fasterxml.jackson.databind.JavaType, java.lang.Class<?>) , but that creates a
less-specific type of given type. |
MapLikeType |
constructMapLikeType(Class<?> mapClass,
Class<?> keyClass,
Class<?> valueClass)
Method for constructing a
MapLikeType instance |
MapLikeType |
constructMapLikeType(Class<?> mapClass,
JavaType keyType,
JavaType valueType)
Method for constructing a
MapLikeType instance |
MapType |
constructMapType(Class<? extends Map> mapClass,
Class<?> keyClass,
Class<?> valueClass)
Method for constructing a
MapType instance |
MapType |
constructMapType(Class<? extends Map> mapClass,
JavaType keyType,
JavaType valueType)
Method for constructing a
MapType instance |
JavaType |
constructParametricType(Class<?> parametrized,
Class<?>... parameterClasses)
Factory method for constructing
JavaType that
represents a parameterized type. |
JavaType |
constructParametricType(Class<?> rawType,
JavaType... parameterTypes)
Factory method for constructing
JavaType that
represents a parameterized type. |
JavaType |
constructParametricType(Class<?> rawType,
TypeBindings parameterTypes)
Factory method for constructing
JavaType that
represents a parameterized type. |
JavaType |
constructParametrizedType(Class<?> parametrized,
Class<?> parametersFor,
Class<?>... parameterClasses)
Deprecated.
since 2.9 Use
constructParametricType(Class,Class...) instead |
JavaType |
constructParametrizedType(Class<?> parametrized,
Class<?> parametersFor,
JavaType... parameterTypes)
Deprecated.
since 2.9 Use
constructParametricType(Class,JavaType...) instead |
CollectionLikeType |
constructRawCollectionLikeType(Class<?> collectionClass)
Method that can be used to construct "raw" Collection-like type; meaning that its
parameterization is unknown.
|
CollectionType |
constructRawCollectionType(Class<? extends Collection> collectionClass)
Method that can be used to construct "raw" Collection type; meaning that its
parameterization is unknown.
|
MapLikeType |
constructRawMapLikeType(Class<?> mapClass)
Method that can be used to construct "raw" Map-like type; meaning that its
parameterization is unknown.
|
MapType |
constructRawMapType(Class<? extends Map> mapClass)
Method that can be used to construct "raw" Map type; meaning that its
parameterization is unknown.
|
JavaType |
constructReferenceType(Class<?> rawType,
JavaType referredType)
Method for constructing a
ReferenceType instance with given type parameter
(type MUST take one and only one type parameter) |
JavaType |
constructSimpleType(Class<?> rawType,
Class<?> parameterTarget,
JavaType[] parameterTypes)
Deprecated.
Since 2.7
|
JavaType |
constructSimpleType(Class<?> rawType,
JavaType[] parameterTypes)
Method for constructing a type instance with specified parameterization.
|
JavaType |
constructSpecializedType(JavaType baseType,
Class<?> subclass)
Factory method for creating a subtype of given base type, as defined
by specified subclass; but retaining generic type information if any.
|
JavaType |
constructSpecializedType(JavaType baseType,
Class<?> subclass,
boolean relaxedCompatibilityCheck)
Factory method for creating a subtype of given base type, as defined
by specified subclass; but retaining generic type information if any.
|
JavaType |
constructType(Type type) |
JavaType |
constructType(Type type,
Class<?> contextClass)
Deprecated.
Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
|
JavaType |
constructType(Type type,
JavaType contextType)
Deprecated.
Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
|
JavaType |
constructType(com.fasterxml.jackson.core.type.TypeReference<?> typeRef) |
JavaType |
constructType(Type type,
TypeBindings bindings)
Deprecated.
Since 2.12
|
static TypeFactory |
defaultInstance()
Method used to access the globally shared instance, which has
no custom configuration.
|
Class<?> |
findClass(String className)
Low-level lookup method moved from
ClassUtil ,
to allow for overriding of lookup functionality in environments like OSGi. |
JavaType[] |
findTypeParameters(Class<?> clz,
Class<?> expType)
Deprecated.
Since 2.7 resolve raw type first, then find type parameters
|
JavaType[] |
findTypeParameters(Class<?> clz,
Class<?> expType,
TypeBindings bindings)
Deprecated.
Since 2.7 resolve raw type first, then find type parameters
|
JavaType[] |
findTypeParameters(JavaType type,
Class<?> expType)
Method that is to figure out actual type parameters that given
class binds to generic types defined by given (generic)
interface or class.
|
ClassLoader |
getClassLoader() |
JavaType |
moreSpecificType(JavaType type1,
JavaType type2)
Method that can be called to figure out more specific of two
types (if they are related; that is, one implements or extends the
other); or if not related, return the primary type.
|
static Class<?> |
rawClass(Type t)
Static helper method that can be called to figure out type-erased
call for given JDK type.
|
JavaType |
resolveMemberType(Type type,
TypeBindings contextBindings)
Method to call when resolving types of
Member s
like Fields, Methods and Constructor parameters and there is a
TypeBindings (that describes binding of type parameters within
context) to pass. |
JavaType |
uncheckedSimpleType(Class<?> cls)
Deprecated.
Since 2.8, to indicate users should never call this method.
|
static JavaType |
unknownType()
Method for constructing a marker type that indicates missing generic
type information, which is handled same as simple type for
java.lang.Object . |
TypeFactory |
withCache(LookupCache<Object,JavaType> cache)
Mutant factory method that will construct new
TypeFactory with
identical settings except for different cache; most likely one with
bigger maximum size. |
TypeFactory |
withCache(LRUMap<Object,JavaType> cache)
Deprecated.
Since 2.12
|
TypeFactory |
withClassLoader(ClassLoader classLoader)
"Mutant factory" method which will construct a new instance with specified
ClassLoader to use by findClass(java.lang.String) . |
TypeFactory |
withModifier(TypeModifier mod)
"Mutant factory" method which will construct a new instance with specified
TypeModifier added as the first modifier to call (in case there
are multiple registered). |
protected static final TypeFactory instance
defaultInstance()
for accessing it.protected static final TypeBindings EMPTY_BINDINGS
protected static final SimpleType CORE_TYPE_BOOL
protected static final SimpleType CORE_TYPE_INT
protected static final SimpleType CORE_TYPE_LONG
protected static final SimpleType CORE_TYPE_STRING
protected static final SimpleType CORE_TYPE_OBJECT
protected static final SimpleType CORE_TYPE_COMPARABLE
Comparable
because it is both parameteric (relatively costly to
resolve) and mostly useless (no special handling), better handle directlyprotected static final SimpleType CORE_TYPE_ENUM
Enum
because it is parametric AND self-referential (costly to
resolve) and useless in itself (no special handling).protected static final SimpleType CORE_TYPE_JSON_NODE
JsonNode
because it is no critical path of simple tree model
reading and does not have things to overrideprotected final LookupCache<Object,JavaType> _typeCache
protected final TypeModifier[] _modifiers
TypeModifier
s: objects that can change details
of JavaType
instances factory constructs.protected final TypeParser _parser
protected final ClassLoader _classLoader
@Deprecated protected TypeFactory(LRUMap<Object,JavaType> typeCache)
protected TypeFactory(LookupCache<Object,JavaType> typeCache)
@Deprecated protected TypeFactory(LRUMap<Object,JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader)
protected TypeFactory(LookupCache<Object,JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader)
public TypeFactory withModifier(TypeModifier mod)
TypeModifier
added as the first modifier to call (in case there
are multiple registered).public TypeFactory withClassLoader(ClassLoader classLoader)
ClassLoader
to use by findClass(java.lang.String)
.@Deprecated public TypeFactory withCache(LRUMap<Object,JavaType> cache)
TypeFactory
with
identical settings except for different cache; most likely one with
bigger maximum size.public TypeFactory withCache(LookupCache<Object,JavaType> cache)
TypeFactory
with
identical settings except for different cache; most likely one with
bigger maximum size.public static TypeFactory defaultInstance()
ObjectMapper
to
get the default factory when constructed.public void clearCache()
TypeFactory
instance.
This method should not be commonly used, that is, only use it
if you know there is a problem with retention of type definitions;
the most likely (and currently only known) problem is retention
of Class
instances via JavaType
reference.public ClassLoader getClassLoader()
public static JavaType unknownType()
java.lang.Object
.public static Class<?> rawClass(Type t)
public Class<?> findClass(String className) throws ClassNotFoundException
ClassUtil
,
to allow for overriding of lookup functionality in environments like OSGi.ClassNotFoundException
protected Class<?> classForName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException
ClassNotFoundException
protected Class<?> classForName(String name) throws ClassNotFoundException
ClassNotFoundException
public JavaType constructSpecializedType(JavaType baseType, Class<?> subclass) throws IllegalArgumentException
HashMap.class
as subclass.
Short-cut for:
constructSpecializedType(baseType, subclass, class);that is, will use "strict" compatibility checking, usually used for deserialization purposes (but often not for serialization).
IllegalArgumentException
public JavaType constructSpecializedType(JavaType baseType, Class<?> subclass, boolean relaxedCompatibilityCheck) throws IllegalArgumentException
HashMap.class
as subclass.baseType
- Declared base type with resolved type parameterssubclass
- Runtime subtype to use for resolvingrelaxedCompatibilityCheck
- Whether checking for type-assignment compatibility
should be "relaxed" (true
) or "strict" (false
): typically
serialization uses relaxed, deserialization strict checking.IllegalArgumentException
public JavaType constructGeneralizedType(JavaType baseType, Class<?> superClass)
constructSpecializedType(com.fasterxml.jackson.databind.JavaType, java.lang.Class<?>)
, but that creates a
less-specific type of given type. Usually this is as simple as simply
finding super-type with type erasure of superClass
, but
there may be need for some additional work-arounds.superClass
- public JavaType constructFromCanonical(String canonical) throws IllegalArgumentException
JavaType
out of its canonical
representation (see ResolvedType.toCanonical()
).canonical
- Canonical string representation of a typeIllegalArgumentException
- If canonical representation is malformed,
or class that type represents (including its generic parameters) is
not foundpublic JavaType[] findTypeParameters(JavaType type, Class<?> expType)
type
- Sub-type (leaf type) that implements expType
@Deprecated public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType, TypeBindings bindings)
@Deprecated public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType)
public JavaType moreSpecificType(JavaType type1, JavaType type2)
type1
- Primary type to considertype2
- Secondary type to considerpublic JavaType constructType(com.fasterxml.jackson.core.type.TypeReference<?> typeRef)
public JavaType resolveMemberType(Type type, TypeBindings contextBindings)
Member
s
like Fields, Methods and Constructor parameters and there is a
TypeBindings
(that describes binding of type parameters within
context) to pass.
This is typically used only by code in databind itself.type
- Type of a Member
to resolvecontextBindings
- Type bindings from the context, often class in which
member declared but may be subtype of that type (to bind actual bound
type parametrers). Not used if type
is of type Class<?>
.constructType(Type, TypeBindings)
@Deprecated public JavaType constructType(Type type, TypeBindings bindings)
TypeBindings
and even then it will probably
not do what you want.
Usually you would instead want to call one of constructXxxType()
methods (where Xxx
would be "Array", "Collection[Like]", "Map[Like]"
or "Parametric").@Deprecated public JavaType constructType(Type type, Class<?> contextClass)
@Deprecated public JavaType constructType(Type type, JavaType contextType)
public ArrayType constructArrayType(Class<?> elementType)
ArrayType
.
NOTE: type modifiers are NOT called on array type itself; but are called for element type (and other contained types)
public ArrayType constructArrayType(JavaType elementType)
ArrayType
.
NOTE: type modifiers are NOT called on array type itself; but are called for contained types.
public CollectionType constructCollectionType(Class<? extends Collection> collectionClass, Class<?> elementClass)
CollectionType
.
NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.
public CollectionType constructCollectionType(Class<? extends Collection> collectionClass, JavaType elementType)
CollectionType
.
NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.
public CollectionLikeType constructCollectionLikeType(Class<?> collectionClass, Class<?> elementClass)
CollectionLikeType
.
NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
public CollectionLikeType constructCollectionLikeType(Class<?> collectionClass, JavaType elementType)
CollectionLikeType
.
NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
public MapType constructMapType(Class<? extends Map> mapClass, Class<?> keyClass, Class<?> valueClass)
MapType
instance
NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
public MapType constructMapType(Class<? extends Map> mapClass, JavaType keyType, JavaType valueType)
MapType
instance
NOTE: type modifiers are NOT called on constructed type itself.
public MapLikeType constructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass)
MapLikeType
instance
NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
public MapLikeType constructMapLikeType(Class<?> mapClass, JavaType keyType, JavaType valueType)
MapLikeType
instance
NOTE: type modifiers are NOT called on constructed type itself.
public JavaType constructSimpleType(Class<?> rawType, JavaType[] parameterTypes)
NOTE: type modifiers are NOT called on constructed type itself.
@Deprecated public JavaType constructSimpleType(Class<?> rawType, Class<?> parameterTarget, JavaType[] parameterTypes)
public JavaType constructReferenceType(Class<?> rawType, JavaType referredType)
ReferenceType
instance with given type parameter
(type MUST take one and only one type parameter)
NOTE: type modifiers are NOT called on constructed type itself.
@Deprecated public JavaType uncheckedSimpleType(Class<?> cls)
Unchecked here not only means that no checks are made as to whether given class
might be non-simple type (like CollectionType
) but also that most of supertype
information is not gathered. This means that unless called on primitive types or
String
, results are probably not what you want to use.
public JavaType constructParametricType(Class<?> parametrized, Class<?>... parameterClasses)
JavaType
that
represents a parameterized type. For example, to represent
type List<Set<Integer>>
, you could
call
JavaType inner = TypeFactory.constructParametricType(Set.class, Integer.class); return TypeFactory.constructParametricType(List.class, inner);
NOTE: since 2.11.2 TypeModifier
s ARE called on result (fix for [databind#2796])
parametrized
- Type-erased type to parameterizeparameterClasses
- Type parameters to applypublic JavaType constructParametricType(Class<?> rawType, JavaType... parameterTypes)
JavaType
that
represents a parameterized type. For example, to represent
type List<Set<Integer>>
, you could
JavaType inner = TypeFactory.constructParametricType(Set.class, Integer.class); return TypeFactory.constructParametricType(List.class, inner);
NOTE: since 2.11.2 TypeModifier
s ARE called on result (fix for [databind#2796])
rawType
- Actual type-erased typeparameterTypes
- Type parameters to applypublic JavaType constructParametricType(Class<?> rawType, TypeBindings parameterTypes)
JavaType
that
represents a parameterized type. The type's parameters are
specified as an instance of TypeBindings
. This
is useful if you already have the type's parameters such
as those found on JavaType
. For example, you could call
return TypeFactory.constructParametricType(ArrayList.class, javaType.getBindings());This effectively applies the parameterized types from one
JavaType
to another class.rawType
- Actual type-erased typeparameterTypes
- Type bindings for the raw type@Deprecated public JavaType constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, JavaType... parameterTypes)
constructParametricType(Class,JavaType...)
instead@Deprecated public JavaType constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, Class<?>... parameterClasses)
constructParametricType(Class,Class...)
insteadpublic CollectionType constructRawCollectionType(Class<? extends Collection> collectionClass)
Object.class
parameterization,
and is equivalent to calling:
typeFactory.constructCollectionType(collectionClass, typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
public CollectionLikeType constructRawCollectionLikeType(Class<?> collectionClass)
Object.class
parameterization,
and is equivalent to calling:
typeFactory.constructCollectionLikeType(collectionClass, typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
public MapType constructRawMapType(Class<? extends Map> mapClass)
Object.class
parameterization,
and is equivalent to calling:
typeFactory.constructMapType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
public MapLikeType constructRawMapLikeType(Class<?> mapClass)
Object.class
parameterization,
and is equivalent to calling:
typeFactory.constructMapLikeType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
protected JavaType _constructSimple(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType
is needed,
no generic parameters are passed. Default implementation may check
pre-constructed values for "well-known" types, but if none found
will simply call _newSimpleType(java.lang.Class<?>, com.fasterxml.jackson.databind.type.TypeBindings, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.JavaType[])
protected JavaType _newSimpleType(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
SimpleType
with no
checks whatsoever. Default implementation calls the single argument
constructor of SimpleType
.protected JavaType _unknownType()
protected JavaType _findWellKnownSimple(Class<?> clz)
protected JavaType _fromAny(ClassStack context, Type srcType, TypeBindings bindings)
getGenericXxx
methods
(usually for a return or argument type).protected JavaType _fromClass(ClassStack context, Class<?> rawType, TypeBindings bindings)
bindings
- Mapping of formal parameter declarations (for generic
types) into actual typesprotected JavaType _resolveSuperClass(ClassStack context, Class<?> rawType, TypeBindings parentBindings)
protected JavaType[] _resolveSuperInterfaces(ClassStack context, Class<?> rawType, TypeBindings parentBindings)
protected JavaType _fromWellKnownClass(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType
implementation.protected JavaType _fromWellKnownInterface(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
protected JavaType _fromParamType(ClassStack context, ParameterizedType ptype, TypeBindings parentBindings)
protected JavaType _fromArrayType(ClassStack context, GenericArrayType type, TypeBindings bindings)
protected JavaType _fromVariable(ClassStack context, TypeVariable<?> var, TypeBindings bindings)
protected JavaType _fromWildcard(ClassStack context, WildcardType type, TypeBindings bindings)
Copyright © 2008–2022 FasterXML. All rights reserved.