com.fasterxml.jackson.databind.type
Class TypeFactory

java.lang.Object  extended by com.fasterxml.jackson.databind.type.TypeFactory

public final class TypeFactory
extends Object

Class used for creating concrete 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);


Field Summary
protected  HierarchicType_cachedArrayListType
          Lazily constructed copy of type hierarchy from ArrayList to its supertypes.
protected  HierarchicType_cachedHashMapType
          Lazily constructed copy of type hierarchy from HashMap to its supertypes.
protected  TypeModifier[]_modifiers
          Registered TypeModifiers: objects that can change details of JavaType instances factory constructs.
protected  TypeParser_parser
           
protected  LRUMap<ClassKey,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 SimpleTypeCORE_TYPE_BOOL
           
protected static SimpleTypeCORE_TYPE_INT
           
protected static SimpleTypeCORE_TYPE_LONG
           
protected static SimpleTypeCORE_TYPE_STRING
           
protected static TypeFactoryinstance
          Globally shared singleton.
 
Constructor Summary
protected TypeFactory(TypeParser p, TypeModifier[] mods)
           
 
Method Summary
protected  HierarchicType_arrayListSuperInterfaceChain(HierarchicType current)
           
 JavaType_constructType(Type type, TypeBindings context)
          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  HierarchicType_doFindSuperInterfaceChain(HierarchicType current, Class<?> target)
           
protected  HierarchicType_findSuperClassChain(Type currentType, Class<?> target)
           
protected  HierarchicType_findSuperInterfaceChain(Type currentType, Class<?> target)
           
protected  HierarchicType_findSuperTypeChain(Class<?> subtype, Class<?> supertype)
          Helper method used to find inheritance (implements, extends) path between given types, if one exists (caller generally checks before calling this method).
protected  JavaType_fromArrayType(GenericArrayType type, TypeBindings context)
           
protected  JavaType_fromClass(Class<?> clz, TypeBindings context)
           
protected  JavaType_fromParameterizedClass(Class<?> clz, List<JavaType> paramTypes)
          Method used by TypeParser when generics-aware version is constructed.
protected  JavaType_fromParamType(ParameterizedType type, TypeBindings context)
          This method deals with parameterized types, that is, first class generic classes.
protected  JavaType_fromVariable(TypeVariable<?> type, TypeBindings context)
           
protected  JavaType_fromWildcard(WildcardType type, TypeBindings context)
           
protected  HierarchicType_hashMapSuperInterfaceChain(HierarchicType current)
           
protected  JavaType_resolveVariableViaSubTypes(HierarchicType leafType, String variableName, TypeBindings bindings)
           
protected  JavaType_unknownType()
           
 ArrayTypeconstructArrayType(Class<?> elementType)
          Method for constructing an ArrayType.
 ArrayTypeconstructArrayType(JavaType elementType)
          Method for constructing an ArrayType.
 CollectionLikeTypeconstructCollectionLikeType(Class<?> collectionClass, Class<?> elementClass)
          Method for constructing a CollectionLikeType.
 CollectionLikeTypeconstructCollectionLikeType(Class<?> collectionClass, JavaType elementType)
          Method for constructing a CollectionLikeType.
 CollectionTypeconstructCollectionType(Class<? extends Collection> collectionClass, Class<?> elementClass)
          Method for constructing a CollectionType.
 CollectionTypeconstructCollectionType(Class<? extends Collection> collectionClass, JavaType elementType)
          Method for constructing a CollectionType.
 JavaTypeconstructFromCanonical(String canonical)
          Factory method for constructing a JavaType out of its canonical representation (see ResolvedType.toCanonical()).
 MapLikeTypeconstructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass)
          Method for constructing a MapLikeType instance
 MapLikeTypeconstructMapLikeType(Class<?> mapClass, JavaType keyType, JavaType valueType)
          Method for constructing a MapLikeType instance
 MapTypeconstructMapType(Class<? extends Map> mapClass, Class<?> keyClass, Class<?> valueClass)
          Method for constructing a MapType instance
 MapTypeconstructMapType(Class<? extends Map> mapClass, JavaType keyType, JavaType valueType)
          Method for constructing a MapType instance
 JavaTypeconstructParametricType(Class<?> parametrized, Class<?>... parameterClasses)
          Factory method for constructing JavaType that represents a parameterized type.
 JavaTypeconstructParametricType(Class<?> parametrized, JavaType... parameterTypes)
          Factory method for constructing JavaType that represents a parameterized type.
 CollectionLikeTypeconstructRawCollectionLikeType(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.
 JavaTypeconstructSimpleType(Class<?> rawType, JavaType[] parameterTypes)
          Method for constructing a type instance with specified parameterization.
 JavaTypeconstructSpecializedType(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(Type type)
           
 JavaTypeconstructType(Type type, Class<?> context)
           
 JavaTypeconstructType(Type type, JavaType context)
           
 JavaTypeconstructType(com.fasterxml.jackson.core.type.TypeReference<?> typeRef)
           
 JavaTypeconstructType(Type type, TypeBindings bindings)
           
static TypeFactorydefaultInstance()
          Method used to access the globally shared instance, which has no custom configuration.
 JavaType[]findTypeParameters(Class<?> clz, Class<?> expType)
           
 JavaType[]findTypeParameters(Class<?> clz, Class<?> expType, TypeBindings bindings)
           
 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.
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)
          Method that will force construction of a simple type, without trying to check for more specialized types.
static JavaTypeunknownType()
          Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type for java.lang.Object.
 TypeFactorywithModifier(TypeModifier mod)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

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 uses defaultInstance() for accessing it.


CORE_TYPE_STRING

protected static final SimpleType CORE_TYPE_STRING

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

_typeCache

protected final LRUMap<ClassKey,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


_cachedHashMapType

protected HierarchicType _cachedHashMapType
Lazily constructed copy of type hierarchy from HashMap to its supertypes.


_cachedArrayListType

protected HierarchicType _cachedArrayListType
Lazily constructed copy of type hierarchy from ArrayList to its supertypes.


_modifiers

protected final TypeModifier[] _modifiers
Registered TypeModifiers: objects that can change details of JavaType instances factory constructs.


_parser

protected final TypeParser _parser
Constructor Detail

TypeFactory

protected TypeFactory(TypeParser p,                      TypeModifier[] mods)
Method Detail

withModifier

public TypeFactory withModifier(TypeModifier mod)

defaultInstance

public static TypeFactory defaultInstance()
Method used to access the globally shared instance, which has no custom configuration. Used by ObjectMapper to get the default factory when constructed.


unknownType

public 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.


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.


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&ltString,Integer>" by giving HashMap.class as subclass.


constructFromCanonical

public JavaType constructFromCanonical(String canonical)                                throws IllegalArgumentException
Factory method for constructing a JavaType out of its canonical representation (see ResolvedType.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 implements expType

findTypeParameters

public JavaType[] findTypeParameters(Class<?> clz,                                     Class<?> expType)

findTypeParameters

public JavaType[] findTypeParameters(Class<?> clz,                                     Class<?> expType,                                     TypeBindings bindings)

constructType

public JavaType constructType(Type type)

constructType

public JavaType constructType(Type type,                              TypeBindings bindings)

constructType

public JavaType constructType(com.fasterxml.jackson.core.type.TypeReference<?> typeRef)

constructType

public JavaType constructType(Type type,                              Class<?> context)

constructType

public JavaType constructType(Type type,                              JavaType context)

_constructType

public JavaType _constructType(Type type,                               TypeBindings context)
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).


constructArrayType

public ArrayType constructArrayType(Class<?> elementType)
Method for constructing an ArrayType.

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 an ArrayType.

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 a CollectionType.

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 a CollectionType.

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 a CollectionLikeType.

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 a CollectionLikeType.

NOTE: 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 a MapType instance

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 a MapType instance

NOTE: 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 a MapLikeType instance

NOTE: 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 a MapLikeType instance

NOTE: 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.


uncheckedSimpleType

public JavaType uncheckedSimpleType(Class<?> cls)
Method that will force construction of a simple type, without trying to check for more specialized types.

NOTE: no type modifiers are called on type either, so calling this method should only be used if caller really knows what it's doing...


constructParametricType

public JavaType constructParametricType(Class<?> parametrized,                                        Class<?>... parameterClasses)
Factory method for constructing JavaType that represents a parameterized type. For example, to represent type List<Set<Integer>>, you could call
  TypeFactory.parametricType(List.class, Integer.class);

NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.


constructParametricType

public JavaType constructParametricType(Class<?> parametrized,                                        JavaType... parameterTypes)
Factory method for constructing JavaType that represents a parameterized type. For example, to represent type List<Set<Integer>>, you could call
  JavaType inner = TypeFactory.parametricType(Set.class, Integer.class);  TypeFactory.parametricType(List.class, inner);

NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.


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 using Object.class parameterization, 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 using Object.class parameterization, 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 using 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.


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 using 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.


_fromClass

protected JavaType _fromClass(Class<?> clz,                              TypeBindings context)
Parameters:
context - Mapping of formal parameter declarations (for generic types) into actual types

_fromParameterizedClass

protected JavaType _fromParameterizedClass(Class<?> clz,                                           List<JavaType> paramTypes)
Method used by TypeParser when generics-aware version is constructed.


_fromParamType

protected JavaType _fromParamType(ParameterizedType type,                                  TypeBindings context)
This method deals with parameterized types, that is, first class generic classes.


_fromArrayType

protected JavaType _fromArrayType(GenericArrayType type,                                  TypeBindings context)

_fromVariable

protected JavaType _fromVariable(TypeVariable<?> type,                                 TypeBindings context)

_fromWildcard

protected JavaType _fromWildcard(WildcardType type,                                 TypeBindings context)

_resolveVariableViaSubTypes

protected JavaType _resolveVariableViaSubTypes(HierarchicType leafType,                                               String variableName,                                               TypeBindings bindings)

_unknownType

protected JavaType _unknownType()

_findSuperTypeChain

protected HierarchicType _findSuperTypeChain(Class<?> subtype,                                             Class<?> supertype)
Helper method used to find inheritance (implements, extends) path between given types, if one exists (caller generally checks before calling this method). Returned type represents given subtype, with supertype linkage extending to supertype.


_findSuperClassChain

protected HierarchicType _findSuperClassChain(Type currentType,                                              Class<?> target)

_findSuperInterfaceChain

protected HierarchicType _findSuperInterfaceChain(Type currentType,                                                  Class<?> target)

_doFindSuperInterfaceChain

protected HierarchicType _doFindSuperInterfaceChain(HierarchicType current,                                                    Class<?> target)

_hashMapSuperInterfaceChain

protected HierarchicType _hashMapSuperInterfaceChain(HierarchicType current)

_arrayListSuperInterfaceChain

protected HierarchicType _arrayListSuperInterfaceChain(HierarchicType current)


Copyright © 2012
fasterxml.com. All Rights Reserved.


NOTHING
NOTHING
Add the Maven Dependecy to your project: maven dependecy for com.amazonaws : aws-java-sdk : 1.3.14