Class TypeFactory
- java.lang.Object
-
- com.fasterxml.jackson.databind.type.TypeFactory
-
- All Implemented Interfaces:
Serializable
public class TypeFactory extends Object implements Serializable
Class used for creating concreteJavaTypeinstances, given various inputs.Instances of this class are accessible using
ObjectMapperas well as many objects it constructs (likeDeserializationConfigandSerializationConfig)), 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);
- See Also:
- Serialized Form
-
-
Field Summary
Fields Modifier and Type Field Description protected ClassLoader_classLoaderClassLoader used by this factory [databind#624].protected TypeModifier[]_modifiersRegisteredTypeModifiers: objects that can change details ofJavaTypeinstances factory constructs.protected TypeParser_parserprotected LRUMap<Object,JavaType>_typeCacheSince type resolution can be expensive (specifically when resolving actual generic types), we will use small cache to avoid repetitive resolution of core typesprotected static SimpleTypeCORE_TYPE_BOOLprotected static SimpleTypeCORE_TYPE_CLASSCacheClassbecause it is nominally parametric, but has no really useful information.protected static SimpleTypeCORE_TYPE_COMPARABLECacheComparablebecause it is both parameteric (relatively costly to resolve) and mostly useless (no special handling), better handle directlyprotected static SimpleTypeCORE_TYPE_ENUMCacheEnumbecause it is parametric AND self-referential (costly to resolve) and useless in itself (no special handling).protected static SimpleTypeCORE_TYPE_INTprotected static SimpleTypeCORE_TYPE_JSON_NODECacheJsonNodebecause it is no critical path of simple tree model reading and does not have things to overrideprotected static SimpleTypeCORE_TYPE_LONGprotected static SimpleTypeCORE_TYPE_OBJECTprotected static SimpleTypeCORE_TYPE_STRINGprotected static TypeBindingsEMPTY_BINDINGSprotected static TypeFactoryinstanceGlobally shared singleton.
-
Constructor Summary
Constructors Modifier Constructor Description protectedTypeFactory(LRUMap<Object,JavaType> typeCache)protectedTypeFactory(LRUMap<Object,JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader)
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods Modifier and Type Method Description protected JavaType_constructSimple(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)Factory method to call when no specialJavaTypeis 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 type, TypeBindings bindings)Factory method that can be used if type information is passed as Java typing returned fromgetGenericXxxmethods (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 alternateJavaTypeimplementation.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 newSimpleTypewith 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)voidclearCache()Method that will clear up any cached type definitions that may be cached by thisTypeFactoryinstance.ArrayTypeconstructArrayType(JavaType elementType)Method for constructing anArrayType.ArrayTypeconstructArrayType(Class<?> elementType)Method for constructing anArrayType.CollectionLikeTypeconstructCollectionLikeType(Class<?> collectionClass, JavaType elementType)Method for constructing aCollectionLikeType.CollectionLikeTypeconstructCollectionLikeType(Class<?> collectionClass, Class<?> elementClass)Method for constructing aCollectionLikeType.CollectionTypeconstructCollectionType(Class<? extends Collection> collectionClass, JavaType elementType)Method for constructing aCollectionType.CollectionTypeconstructCollectionType(Class<? extends Collection> collectionClass, Class<?> elementClass)Method for constructing aCollectionType.JavaTypeconstructFromCanonical(String canonical)Factory method for constructing aJavaTypeout of its canonical representation (seeResolvedType.toCanonical()).JavaTypeconstructGeneralizedType(JavaType baseType, Class<?> superClass)Method similar toconstructSpecializedType(com.fasterxml.jackson.databind.JavaType, java.lang.Class<?>), but that creates a less-specific type of given type.MapLikeTypeconstructMapLikeType(Class<?> mapClass, JavaType keyType, JavaType valueType)Method for constructing aMapLikeTypeinstanceMapLikeTypeconstructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass)Method for constructing aMapLikeTypeinstanceMapTypeconstructMapType(Class<? extends Map> mapClass, JavaType keyType, JavaType valueType)Method for constructing aMapTypeinstanceMapTypeconstructMapType(Class<? extends Map> mapClass, Class<?> keyClass, Class<?> valueClass)Method for constructing aMapTypeinstanceJavaTypeconstructParametricType(Class<?> rawType, JavaType... parameterTypes)Factory method for constructingJavaTypethat represents a parameterized type.JavaTypeconstructParametricType(Class<?> parametrized, Class<?>... parameterClasses)Factory method for constructingJavaTypethat represents a parameterized type.JavaTypeconstructParametrizedType(Class<?> parametrized, Class<?> parametersFor, JavaType... parameterTypes)Deprecated.since 2.9 UseconstructParametricType(Class,JavaType...)insteadJavaTypeconstructParametrizedType(Class<?> parametrized, Class<?> parametersFor, Class<?>... parameterClasses)Deprecated.since 2.9 UseconstructParametricType(Class,Class...)insteadCollectionLikeTypeconstructRawCollectionLikeType(Class<?> collectionClass)Method that can be used to construct "raw" Collection-like type; meaning that its parameterization is unknown.CollectionTypeconstructRawCollectionType(Class<? extends Collection> collectionClass)Method that can be used to construct "raw" Collection type; meaning that its parameterization is unknown.MapLikeTypeconstructRawMapLikeType(Class<?> mapClass)Method that can be used to construct "raw" Map-like type; meaning that its parameterization is unknown.MapTypeconstructRawMapType(Class<? extends Map> mapClass)Method that can be used to construct "raw" Map type; meaning that its parameterization is unknown.JavaTypeconstructReferenceType(Class<?> rawType, JavaType referredType)JavaTypeconstructSimpleType(Class<?> rawType, JavaType[] parameterTypes)Method for constructing a type instance with specified parameterization.JavaTypeconstructSimpleType(Class<?> rawType, Class<?> parameterTarget, JavaType[] parameterTypes)Deprecated.Since 2.7JavaTypeconstructSpecializedType(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.JavaTypeconstructType(com.fasterxml.jackson.core.type.TypeReference<?> typeRef)JavaTypeconstructType(Type type)JavaTypeconstructType(Type type, JavaType contextType)Deprecated.Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)JavaTypeconstructType(Type type, TypeBindings bindings)JavaTypeconstructType(Type type, Class<?> contextClass)Deprecated.Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)static TypeFactorydefaultInstance()Method used to access the globally shared instance, which has no custom configuration.Class<?>findClass(String className)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 parametersClassLoadergetClassLoader()JavaTypemoreSpecificType(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.JavaTypeuncheckedSimpleType(Class<?> cls)Deprecated.Since 2.8, to indicate users should never call this method.static JavaTypeunknownType()Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type forjava.lang.Object.TypeFactorywithCache(LRUMap<Object,JavaType> cache)Mutant factory method that will construct newTypeFactorywith identical settings except for different cache; most likely one with bigger maximum size.TypeFactorywithClassLoader(ClassLoader classLoader)"Mutant factory" method which will construct a new instance with specifiedClassLoaderto use byfindClass(java.lang.String).TypeFactorywithModifier(TypeModifier mod)"Mutant factory" method which will construct a new instance with specifiedTypeModifieradded as the first modifier to call (in case there are multiple registered).
-
-
-
Field Detail
-
instance
protected static final TypeFactory 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
protected static final TypeBindings EMPTY_BINDINGS
-
CORE_TYPE_BOOL
protected static final SimpleType CORE_TYPE_BOOL
-
CORE_TYPE_INT
protected static final SimpleType CORE_TYPE_INT
-
CORE_TYPE_LONG
protected static final SimpleType CORE_TYPE_LONG
-
CORE_TYPE_STRING
protected static final SimpleType CORE_TYPE_STRING
-
CORE_TYPE_OBJECT
protected static final SimpleType CORE_TYPE_OBJECT
-
CORE_TYPE_COMPARABLE
protected static final SimpleType CORE_TYPE_COMPARABLE
CacheComparablebecause it is both parameteric (relatively costly to resolve) and mostly useless (no special handling), better handle directly- Since:
- 2.7
-
CORE_TYPE_ENUM
protected static final SimpleType CORE_TYPE_ENUM
CacheEnumbecause it is parametric AND self-referential (costly to resolve) and useless in itself (no special handling).- Since:
- 2.7
-
CORE_TYPE_CLASS
protected static final SimpleType CORE_TYPE_CLASS
CacheClassbecause it is nominally parametric, but has no really useful information.- Since:
- 2.7
-
CORE_TYPE_JSON_NODE
protected static final SimpleType CORE_TYPE_JSON_NODE
CacheJsonNodebecause it is no critical path of simple tree model reading and does not have things to override- Since:
- 2.10
-
_typeCache
protected final LRUMap<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
-
_modifiers
protected final TypeModifier[] _modifiers
RegisteredTypeModifiers: objects that can change details ofJavaTypeinstances factory constructs.
-
_parser
protected final TypeParser _parser
-
_classLoader
protected final ClassLoader _classLoader
ClassLoader used by this factory [databind#624].
-
-
Constructor Detail
-
TypeFactory
protected TypeFactory(LRUMap<Object,JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader)
-
-
Method Detail
-
withModifier
public TypeFactory withModifier(TypeModifier mod)
"Mutant factory" method which will construct a new instance with specifiedTypeModifieradded as the first modifier to call (in case there are multiple registered).
-
withClassLoader
public TypeFactory withClassLoader(ClassLoader classLoader)
"Mutant factory" method which will construct a new instance with specifiedClassLoaderto use byfindClass(java.lang.String).
-
withCache
public TypeFactory withCache(LRUMap<Object,JavaType> cache)
Mutant factory method that will construct newTypeFactorywith identical settings except for different cache; most likely one with bigger maximum size.- Since:
- 2.8
-
defaultInstance
public static TypeFactory defaultInstance()
Method used to access the globally shared instance, which has no custom configuration. Used byObjectMapperto get the default factory when constructed.
-
clearCache
public void clearCache()
Method that will clear up any cached type definitions that may be cached by thisTypeFactoryinstance. 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 ofClassinstances viaJavaTypereference.- Since:
- 2.4.1
-
getClassLoader
public ClassLoader getClassLoader()
-
unknownType
public static JavaType unknownType()
Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type forjava.lang.Object.
-
rawClass
public static Class<?> rawClass(Type t)
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
public Class<?> findClass(String className) throws ClassNotFoundException
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
protected Class<?> classForName(String name) throws ClassNotFoundException
- Throws:
ClassNotFoundException
-
constructSpecializedType
public 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. Can be used, for example, to get equivalent of "HashMap<String,Integer>" from "Map<String,Integer>" by givingHashMap.classas subclass.
-
constructGeneralizedType
public JavaType constructGeneralizedType(JavaType baseType, Class<?> superClass)
Method similar toconstructSpecializedType(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
public JavaType constructFromCanonical(String canonical) throws IllegalArgumentException
Factory method for constructing aJavaTypeout 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
public 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. 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 public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType)
Deprecated.Since 2.7 resolve raw type first, then find type parameters
-
moreSpecificType
public 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.- Parameters:
type1- Primary type to considertype2- Secondary type to consider- Since:
- 2.2
-
constructType
public JavaType constructType(Type type, TypeBindings bindings)
-
constructType
public JavaType constructType(com.fasterxml.jackson.core.type.TypeReference<?> typeRef)
-
constructType
@Deprecated public JavaType constructType(Type type, Class<?> contextClass)
Deprecated.Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
-
constructType
@Deprecated public JavaType constructType(Type type, JavaType contextType)
Deprecated.Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
-
constructArrayType
public ArrayType constructArrayType(Class<?> elementType)
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
public ArrayType constructArrayType(JavaType elementType)
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 aMapTypeinstanceNOTE: 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 aMapTypeinstanceNOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
-
constructMapLikeType
public MapLikeType constructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass)
Method for constructing aMapLikeTypeinstanceNOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
-
constructMapLikeType
public MapLikeType constructMapLikeType(Class<?> mapClass, JavaType keyType, JavaType valueType)
Method for constructing aMapLikeTypeinstanceNOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
-
constructSimpleType
public JavaType constructSimpleType(Class<?> rawType, JavaType[] parameterTypes)
Method for constructing a type instance with specified parameterization.NOTE: was briefly deprecated for 2.6.
-
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
public JavaType constructReferenceType(Class<?> rawType, JavaType referredType)
- Since:
- 2.6
-
uncheckedSimpleType
@Deprecated public JavaType uncheckedSimpleType(Class<?> cls)
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
public JavaType constructParametricType(Class<?> parametrized, Class<?>... parameterClasses)
Factory method for constructingJavaTypethat represents a parameterized type. For example, to represent typeList<Set<Integer>>, you could callJavaType inner = TypeFactory.constructParametricType(Set.class, Set.class, Integer.class); return TypeFactory.constructParametricType(ArrayList.class, List.class, inner);
The reason for first two arguments to be separate is that parameterization may apply to a super-type. For example, if generic type was instead to be constructed for
ArrayList<Integer>, the usual call would be:TypeFactory.constructParametricType(ArrayList.class, List.class, Integer.class);
since parameterization is applied toList. In most cases distinction does not matter, but there are types where it does; one such example is parameterization of types that implementIterator.NOTE: type modifiers are NOT called on constructed type.
- Parameters:
parametrized- Actual full typeparameterClasses- Type parameters to apply- Since:
- 2.5 NOTE: was briefly deprecated for 2.6
-
constructParametricType
public JavaType constructParametricType(Class<?> rawType, JavaType... parameterTypes)
Factory method for constructingJavaTypethat represents a parameterized type. For example, to represent typeList<Set<Integer>>, you couldJavaType inner = TypeFactory.constructParametricType(Set.class, Set.class, Integer.class); return TypeFactory.constructParametricType(ArrayList.class, List.class, inner);
The reason for first two arguments to be separate is that parameterization may apply to a super-type. For example, if generic type was instead to be constructed for
ArrayList<Integer>, the usual call would be:TypeFactory.constructParametricType(ArrayList.class, List.class, Integer.class);
since parameterization is applied toList. In most cases distinction does not matter, but there are types where it does; one such example is parameterization of types that implementIterator.NOTE: type modifiers are NOT called on constructed type.
- Parameters:
rawType- Actual type-erased typeparameterTypes- Type parameters to apply- Since:
- 2.5 NOTE: was briefly deprecated for 2.6
-
constructParametrizedType
@Deprecated public JavaType constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, JavaType... parameterTypes)
Deprecated.since 2.9 UseconstructParametricType(Class,JavaType...)instead- Since:
- 2.5 -- but will probably deprecated in 2.7 or 2.8 (not needed with 2.7)
-
constructParametrizedType
@Deprecated public JavaType constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, Class<?>... parameterClasses)
Deprecated.since 2.9 UseconstructParametricType(Class,Class...)instead- Since:
- 2.5 -- but will probably deprecated in 2.7 or 2.8 (not needed with 2.7)
-
constructRawCollectionType
public CollectionType constructRawCollectionType(Class<? extends Collection> collectionClass)
Method that can be used to construct "raw" Collection type; meaning that its parameterization is unknown. This is similar to usingObject.classparameterization, and is equivalent to calling:typeFactory.constructCollectionType(collectionClass, typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
-
constructRawCollectionLikeType
public CollectionLikeType constructRawCollectionLikeType(Class<?> collectionClass)
Method that can be used to construct "raw" Collection-like type; meaning that its parameterization is unknown. This is similar to usingObject.classparameterization, and is equivalent to calling:typeFactory.constructCollectionLikeType(collectionClass, typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
-
constructRawMapType
public MapType constructRawMapType(Class<? extends Map> mapClass)
Method that can be used to construct "raw" Map type; meaning that its parameterization is unknown. This is similar to usingObject.classparameterization, and is equivalent to calling:typeFactory.constructMapType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
-
constructRawMapLikeType
public MapLikeType constructRawMapLikeType(Class<?> mapClass)
Method that can be used to construct "raw" Map-like type; meaning that its parameterization is unknown. This is similar to usingObject.classparameterization, 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 specialJavaTypeis 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[])- Since:
- 2.7
-
_newSimpleType
protected JavaType _newSimpleType(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
Factory method that is to create a newSimpleTypewith no checks whatsoever. Default implementation calls the single argument constructor ofSimpleType.- Since:
- 2.7
-
_unknownType
protected JavaType _unknownType()
-
_findWellKnownSimple
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.- Since:
- 2.7
-
_fromAny
protected JavaType _fromAny(ClassStack context, Type type, TypeBindings bindings)
Factory method that can be used if type information is passed as Java typing returned fromgetGenericXxxmethods (usually for a return or argument type).
-
_fromClass
protected JavaType _fromClass(ClassStack context, Class<?> rawType, TypeBindings bindings)
- 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 alternateJavaTypeimplementation.
-
_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
protected JavaType _fromArrayType(ClassStack context, GenericArrayType type, TypeBindings bindings)
-
_fromVariable
protected JavaType _fromVariable(ClassStack context, TypeVariable<?> var, TypeBindings bindings)
-
_fromWildcard
protected JavaType _fromWildcard(ClassStack context, WildcardType type, TypeBindings bindings)
-
-