Class TypeFactory
- All Implemented Interfaces:
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:
- For optimization purposes, type resolution is skipped for following commonly seen
types that do have type parameters, but ones that are rarely needed:
Enum
: Self-referential type reference is simply dropped and Class is exposed as a simple, non-parameterizedSimpleType
Comparable
: Type parameter is simply dropped and and interface is exposed as a simple, non-parameterizedSimpleType
- Up until Jackson 2.13,
Class
type parameter was dropped; resolution was added back in Jackson 2.14.
- For
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. - For
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.
- See Also:
-
Field Summary
Modifier and TypeFieldDescriptionprotected final ClassLoader
ClassLoader used by this factory [databind#624].protected final TypeModifier[]
RegisteredTypeModifier
s: objects that can change details ofJavaType
instances factory constructs.protected final TypeParser
protected final LookupCache<Object,
JavaType> Since type resolution can be expensive (specifically when resolving actual generic types), we will use small cache to avoid repetitive resolution of core typesprotected static final SimpleType
protected static final SimpleType
CacheComparable
because it is both parameteric (relatively costly to resolve) and mostly useless (no special handling), better handle directlyprotected static final SimpleType
CacheEnum
because it is parametric AND self-referential (costly to resolve) and useless in itself (no special handling).protected static final SimpleType
protected static final SimpleType
CacheJsonNode
because it is no critical path of simple tree model reading and does not have things to overrideprotected static final SimpleType
protected static final SimpleType
protected static final SimpleType
protected static final TypeBindings
protected static final TypeFactory
Globally shared singleton. -
Constructor Summary
ModifierConstructorDescriptionprotected
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.12protected
TypeFactory
(LRUMap<Object, JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader) Deprecated.Since 2.12 -
Method Summary
Modifier and TypeMethodDescriptionprotected JavaType
_applyModifiers
(Type srcType, JavaType resolvedType) protected JavaType
_constructSimple
(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) Factory method to call when no specialJavaType
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 fromgetGenericXxx
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 alternateJavaType
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 newSimpleType
with no checks whatsoever.protected JavaType
_resolveSuperClass
(ClassStack context, Class<?> rawType, TypeBindings parentBindings) protected JavaType[]
_resolveSuperInterfaces
(ClassStack context, Class<?> rawType, TypeBindings parentBindings) protected JavaType
protected Class<?>
classForName
(String name) protected Class<?>
classForName
(String name, boolean initialize, ClassLoader loader) void
Method that will clear up any cached type definitions that may be cached by thisTypeFactory
instance.constructArrayType
(JavaType elementType) Method for constructing anArrayType
.constructArrayType
(Class<?> elementType) Method for constructing anArrayType
.constructCollectionLikeType
(Class<?> collectionClass, JavaType elementType) Method for constructing aCollectionLikeType
.constructCollectionLikeType
(Class<?> collectionClass, Class<?> elementClass) Method for constructing aCollectionLikeType
.constructCollectionType
(Class<? extends Collection> collectionClass, JavaType elementType) Method for constructing aCollectionType
.constructCollectionType
(Class<? extends Collection> collectionClass, Class<?> elementClass) Method for constructing aCollectionType
.constructFromCanonical
(String canonical) Factory method for constructing aJavaType
out of its canonical representation (seeResolvedType.toCanonical()
).constructGeneralizedType
(JavaType baseType, Class<?> superClass) Method similar toconstructSpecializedType(edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.databind.JavaType, java.lang.Class<?>)
, but that creates a less-specific type of given type.constructMapLikeType
(Class<?> mapClass, JavaType keyType, JavaType valueType) Method for constructing aMapLikeType
instanceconstructMapLikeType
(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass) Method for constructing aMapLikeType
instanceconstructMapType
(Class<? extends Map> mapClass, JavaType keyType, JavaType valueType) Method for constructing aMapType
instanceconstructMapType
(Class<? extends Map> mapClass, Class<?> keyClass, Class<?> valueClass) Method for constructing aMapType
instanceconstructParametricType
(Class<?> rawType, JavaType... parameterTypes) Factory method for constructingJavaType
that represents a parameterized type.constructParametricType
(Class<?> rawType, TypeBindings parameterTypes) Factory method for constructingJavaType
that represents a parameterized type.constructParametricType
(Class<?> parametrized, Class<?>... parameterClasses) Factory method for constructingJavaType
that represents a parameterized type.constructParametrizedType
(Class<?> parametrized, Class<?> parametersFor, JavaType... parameterTypes) Deprecated.since 2.9 UseconstructParametricType(Class,JavaType...)
insteadconstructParametrizedType
(Class<?> parametrized, Class<?> parametersFor, Class<?>... parameterClasses) Deprecated.since 2.9 UseconstructParametricType(Class,Class...)
insteadconstructRawCollectionLikeType
(Class<?> collectionClass) Method that can be used to construct "raw" Collection-like type; meaning that its parameterization is unknown.constructRawCollectionType
(Class<? extends Collection> collectionClass) Method that can be used to construct "raw" Collection type; meaning that its parameterization is unknown.constructRawMapLikeType
(Class<?> mapClass) Method that can be used to construct "raw" Map-like type; meaning that its parameterization is unknown.constructRawMapType
(Class<? extends Map> mapClass) Method that can be used to construct "raw" Map type; meaning that its parameterization is unknown.constructReferenceType
(Class<?> rawType, JavaType referredType) Method for constructing aReferenceType
instance with given type parameter (type MUST take one and only one type parameter)constructSimpleType
(Class<?> rawType, JavaType[] parameterTypes) Method for constructing a type instance with specified parameterization.constructSimpleType
(Class<?> rawType, Class<?> parameterTarget, JavaType[] parameterTypes) Deprecated.Since 2.7constructSpecializedType
(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.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.constructType
(TypeReference<?> typeRef) constructType
(Type type) constructType
(Type type, JavaType contextType) Deprecated.Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)constructType
(Type type, TypeBindings bindings) Deprecated.Since 2.12constructType
(Type type, Class<?> contextClass) Deprecated.Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)static TypeFactory
Method used to access the globally shared instance, which has no custom configuration.Class<?>
Low-level lookup method moved fromClassUtil
, to allow for overriding of lookup functionality in environments like OSGi.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.JavaType[]
findTypeParameters
(Class<?> clz, Class<?> expType) Deprecated.Since 2.7 resolve raw type first, then find type parametersJavaType[]
findTypeParameters
(Class<?> clz, Class<?> expType, TypeBindings bindings) Deprecated.Since 2.7 resolve raw type first, then find type parametersmoreSpecificType
(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<?>
Static helper method that can be called to figure out type-erased call for given JDK type.resolveMemberType
(Type type, TypeBindings contextBindings) Method to call when resolving types ofMember
s like Fields, Methods and Constructor parameters and there is aTypeBindings
(that describes binding of type parameters within context) to pass.uncheckedSimpleType
(Class<?> cls) Deprecated.Since 2.8, to indicate users should never call this method.static JavaType
Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type forjava.lang.Object
.withCache
(LookupCache<Object, JavaType> cache) Mutant factory method that will construct newTypeFactory
with identical settings except for different cache; most likely one with bigger maximum size.Deprecated.Since 2.12withClassLoader
(ClassLoader classLoader) "Mutant factory" method which will construct a new instance with specifiedClassLoader
to use byfindClass(java.lang.String)
.withModifier
(TypeModifier mod) "Mutant factory" method which will construct a new instance with specifiedTypeModifier
added as the first modifier to call (in case there are multiple registered).
-
Field Details
-
instance
Globally shared singleton. Not accessed directly; non-core code should use per-ObjectMapper instance (via configuration objects). Core Jackson code usesdefaultInstance()
for accessing it. -
EMPTY_BINDINGS
-
CORE_TYPE_BOOL
-
CORE_TYPE_INT
-
CORE_TYPE_LONG
-
CORE_TYPE_STRING
-
CORE_TYPE_OBJECT
-
CORE_TYPE_COMPARABLE
CacheComparable
because it is both parameteric (relatively costly to resolve) and mostly useless (no special handling), better handle directly- Since:
- 2.7
-
CORE_TYPE_ENUM
CacheEnum
because it is parametric AND self-referential (costly to resolve) and useless in itself (no special handling).- Since:
- 2.7
-
CORE_TYPE_JSON_NODE
CacheJsonNode
because it is no critical path of simple tree model reading and does not have things to override- Since:
- 2.10
-
_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 -
_modifiers
RegisteredTypeModifier
s: objects that can change details ofJavaType
instances factory constructs. -
_parser
-
_classLoader
ClassLoader used by this factory [databind#624].
-
-
Constructor Details
-
TypeFactory
Deprecated.Since 2.12- Since:
- 2.8
-
TypeFactory
- Since:
- 2.12
-
TypeFactory
@Deprecated protected TypeFactory(LRUMap<Object, JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader) Deprecated.Since 2.12 -
TypeFactory
protected TypeFactory(LookupCache<Object, JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader) - Since:
- 2.12
-
-
Method Details
-
withModifier
"Mutant factory" method which will construct a new instance with specifiedTypeModifier
added as the first modifier to call (in case there are multiple registered). -
withClassLoader
"Mutant factory" method which will construct a new instance with specifiedClassLoader
to use byfindClass(java.lang.String)
. -
withCache
Deprecated.Since 2.12Mutant factory method that will construct newTypeFactory
with identical settings except for different cache; most likely one with bigger maximum size.- Since:
- 2.8
-
withCache
Mutant factory method that will construct newTypeFactory
with identical settings except for different cache; most likely one with bigger maximum size.- Since:
- 2.12
-
defaultInstance
Method used to access the globally shared instance, which has no custom configuration. Used byObjectMapper
to get the default factory when constructed. -
clearCache
public void clearCache()Method that will clear up any cached type definitions that may be cached by thisTypeFactory
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 ofClass
instances viaJavaType
reference.- Since:
- 2.4.1
-
getClassLoader
-
unknownType
Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type forjava.lang.Object
. -
rawClass
Static helper method that can be called to figure out type-erased call for given JDK type. It can be called statically since type resolution process can never change actual type-erased class; thereby static default instance is used for determination. -
findClass
Low-level lookup method moved fromClassUtil
, to allow for overriding of lookup functionality in environments like OSGi.- Throws:
ClassNotFoundException
- Since:
- 2.6
-
classForName
protected Class<?> classForName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException - Throws:
ClassNotFoundException
-
classForName
- Throws:
ClassNotFoundException
-
_findPrimitive
-
constructSpecializedType
public JavaType constructSpecializedType(JavaType baseType, Class<?> subclass) throws IllegalArgumentException Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any. Can be used, for example, to get equivalent of "HashMap<String,Integer>" from "Map<String,Integer>" by givingHashMap.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).- Throws:
IllegalArgumentException
-
constructSpecializedType
public JavaType constructSpecializedType(JavaType baseType, Class<?> subclass, boolean relaxedCompatibilityCheck) throws IllegalArgumentException Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any. Can be used, for example, to get equivalent of "HashMap<String,Integer>" from "Map<String,Integer>" by givingHashMap.class
as subclass.- Parameters:
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.- Returns:
- Resolved sub-type
- Throws:
IllegalArgumentException
- Since:
- 2.11
-
constructGeneralizedType
Method similar toconstructSpecializedType(edu.internet2.middleware.grouperClientExt.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 ofsuperClass
, but there may be need for some additional work-arounds.- Parameters:
superClass
-- Since:
- 2.7
-
constructFromCanonical
Factory method for constructing aJavaType
out of its canonical representation (seeResolvedType.toCanonical()
).- Parameters:
canonical
- Canonical string representation of a type- Throws:
IllegalArgumentException
- If canonical representation is malformed, or class that type represents (including its generic parameters) is not found
-
findTypeParameters
Method that is to figure out actual type parameters that given class binds to generic types defined by given (generic) interface or class. This could mean, for example, trying to figure out key and value types for Map implementations.- Parameters:
type
- Sub-type (leaf type) that implementsexpType
-
findTypeParameters
@Deprecated public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType, TypeBindings bindings) Deprecated.Since 2.7 resolve raw type first, then find type parameters -
findTypeParameters
Deprecated.Since 2.7 resolve raw type first, then find type parameters -
moreSpecificType
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.- Parameters:
type1
- Primary type to considertype2
- Secondary type to consider- Since:
- 2.2
-
constructType
-
constructType
-
resolveMemberType
Method to call when resolving types ofMember
s like Fields, Methods and Constructor parameters and there is aTypeBindings
(that describes binding of type parameters within context) to pass. This is typically used only by code in databind itself.- Parameters:
type
- Type of aMember
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 iftype
is of typeClass<?>
.- Returns:
- Fully resolve type
- Since:
- 2.12 as replacement for deprecated
constructType(Type, TypeBindings)
-
constructType
Deprecated.Since 2.12Method that you very likely should NOT be using -- you need to know a lot about internal details ofTypeBindings
and even then it will probably not do what you want. Usually you would instead want to call one ofconstructXxxType()
methods (whereXxx
would be "Array", "Collection[Like]", "Map[Like]" or "Parametric"). -
constructType
Deprecated.Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1) -
constructType
Deprecated.Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1) -
constructArrayType
Method for constructing anArrayType
.NOTE: type modifiers are NOT called on array type itself; but are called for element type (and other contained types)
-
constructArrayType
Method for constructing anArrayType
.NOTE: type modifiers are NOT called on array type itself; but are called for contained types.
-
constructCollectionType
public CollectionType constructCollectionType(Class<? extends Collection> collectionClass, Class<?> elementClass) Method for constructing aCollectionType
.NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.
-
constructCollectionType
public CollectionType constructCollectionType(Class<? extends Collection> collectionClass, JavaType elementType) Method for constructing aCollectionType
.NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.
-
constructCollectionLikeType
public CollectionLikeType constructCollectionLikeType(Class<?> collectionClass, Class<?> elementClass) Method for constructing aCollectionLikeType
.NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
-
constructCollectionLikeType
public CollectionLikeType constructCollectionLikeType(Class<?> collectionClass, JavaType elementType) Method for constructing aCollectionLikeType
.NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
-
constructMapType
public MapType constructMapType(Class<? extends Map> mapClass, Class<?> keyClass, Class<?> valueClass) Method for constructing aMapType
instanceNOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
-
constructMapType
public MapType constructMapType(Class<? extends Map> mapClass, JavaType keyType, JavaType valueType) Method for constructing aMapType
instanceNOTE: type modifiers are NOT called on constructed type itself.
-
constructMapLikeType
Method for constructing aMapLikeType
instanceNOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
-
constructMapLikeType
Method for constructing aMapLikeType
instanceNOTE: type modifiers are NOT called on constructed type itself.
-
constructSimpleType
Method for constructing a type instance with specified parameterization.NOTE: type modifiers are NOT called on constructed type itself.
-
constructSimpleType
@Deprecated public JavaType constructSimpleType(Class<?> rawType, Class<?> parameterTarget, JavaType[] parameterTypes) Deprecated.Since 2.7Method for constructing a type instance with specified parameterization.- Since:
- 2.6
-
constructReferenceType
Method for constructing aReferenceType
instance with given type parameter (type MUST take one and only one type parameter)NOTE: type modifiers are NOT called on constructed type itself.
- Since:
- 2.6
-
uncheckedSimpleType
Deprecated.Since 2.8, to indicate users should never call this method.Method that use by core Databind functionality, and that should NOT be called by application code outside databind package.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 orString
, results are probably not what you want to use. -
constructParametricType
Factory method for constructingJavaType
that represents a parameterized type. For example, to represent typeList<Set<Integer>>
, you could callJavaType 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])- Parameters:
parametrized
- Type-erased type to parameterizeparameterClasses
- Type parameters to apply- Since:
- 2.5 NOTE: was briefly deprecated for 2.6
-
constructParametricType
Factory method for constructingJavaType
that represents a parameterized type. For example, to represent typeList<Set<Integer>>
, you couldJavaType 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])- Parameters:
rawType
- Actual type-erased typeparameterTypes
- Type parameters to apply- Returns:
- Fully resolved type for given base type and type parameters
-
constructParametricType
Factory method for constructingJavaType
that represents a parameterized type. The type's parameters are specified as an instance ofTypeBindings
. This is useful if you already have the type's parameters such as those found onJavaType
. For example, you could callreturn TypeFactory.constructParametricType(ArrayList.class, javaType.getBindings());
This effectively applies the parameterized types from oneJavaType
to another class.- Parameters:
rawType
- Actual type-erased typeparameterTypes
- Type bindings for the raw type- Since:
- 2.12
-
constructParametrizedType
@Deprecated public JavaType constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, JavaType... parameterTypes) Deprecated.since 2.9 UseconstructParametricType(Class,JavaType...)
instead- Since:
- 2.5
-
constructParametrizedType
@Deprecated public JavaType constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, Class<?>... parameterClasses) Deprecated.since 2.9 UseconstructParametricType(Class,Class...)
instead- Since:
- 2.5
-
constructRawCollectionType
Method that can be used to construct "raw" Collection type; meaning that its parameterization is unknown. This is similar to usingObject.class
parameterization, and is equivalent to calling:typeFactory.constructCollectionType(collectionClass, typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
-
constructRawCollectionLikeType
Method that can be used to construct "raw" Collection-like type; meaning that its parameterization is unknown. This is similar to usingObject.class
parameterization, and is equivalent to calling:typeFactory.constructCollectionLikeType(collectionClass, typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
-
constructRawMapType
Method that can be used to construct "raw" Map type; meaning that its parameterization is unknown. This is similar to usingObject.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.
-
constructRawMapLikeType
Method that can be used to construct "raw" Map-like type; meaning that its parameterization is unknown. This is similar to usingObject.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.
-
_constructSimple
protected JavaType _constructSimple(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) Factory method to call when no specialJavaType
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<?>, edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.databind.type.TypeBindings, edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.databind.JavaType, edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.databind.JavaType[])
- Since:
- 2.7
-
_newSimpleType
protected JavaType _newSimpleType(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) Factory method that is to create a newSimpleType
with no checks whatsoever. Default implementation calls the single argument constructor ofSimpleType
.- Since:
- 2.7
-
_unknownType
-
_findWellKnownSimple
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.- Since:
- 2.7
-
_fromAny
Factory method that can be used if type information is passed as Java typing returned fromgetGenericXxx
methods (usually for a return or argument type). -
_applyModifiers
-
_fromClass
- Parameters:
bindings
- Mapping of formal parameter declarations (for generic types) into actual types
-
_resolveSuperClass
protected JavaType _resolveSuperClass(ClassStack context, Class<?> rawType, TypeBindings parentBindings) -
_resolveSuperInterfaces
protected JavaType[] _resolveSuperInterfaces(ClassStack context, Class<?> rawType, TypeBindings parentBindings) -
_fromWellKnownClass
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 alternateJavaType
implementation. -
_fromWellKnownInterface
protected JavaType _fromWellKnownInterface(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) -
_fromParamType
protected JavaType _fromParamType(ClassStack context, ParameterizedType ptype, TypeBindings parentBindings) This method deals with parameterized types, that is, first class generic classes. -
_fromArrayType
-
_fromVariable
-
_fromWildcard
-