Uses of Class
org.codehaus.jackson.type.JavaType

Packages that use JavaType
org.codehaus.jackson Main public API classes of the core streaming JSON processor: most importantly JsonFactory used for constructing Json parser (JsonParser) and generator (JsonParser) instances. 
org.codehaus.jackson.jaxrs Jackson-based JAX-RS provider that can automatically serialize and deserialize resources for JSON content type (MediaType). 
org.codehaus.jackson.map Contains basic mapper (conversion) functionality that allows for converting between regular streaming json content and Java objects (beans or Tree Model: support for both is via ObjectMapper class, as well as convenience methods included in JsonParser 
org.codehaus.jackson.map.deser Contains implementation classes of deserialization part of data binding. 
org.codehaus.jackson.map.introspect Functionality needed for Bean introspection, required for detecting accessors and mutators for Beans, as well as locating and handling method annotations. 
org.codehaus.jackson.map.jsontype Package that contains interfaces that define how to implement functionality for dynamically resolving type during deserialization. 
org.codehaus.jackson.map.jsontype.impl Package that contains standard implementations for TypeResolverBuilder and org.codehaus.jackson.map.jsontype.JsonTypeResolver it can construct. 
org.codehaus.jackson.map.ser Contains implementation classes of serialization part of data binding. 
org.codehaus.jackson.map.type Package that contains concrete implementations of JavaType, as well as the factory (TypeFactory) for constructing instances from various input data types (like Class, Type) and programmatically (for structured types, arrays, Lists and Maps). 
org.codehaus.jackson.map.util Utility classes for Mapper package. 
org.codehaus.jackson.type Contains classes needed for type introspection, mostly used by data binding functionality. 
org.codehaus.jackson.xc Package that contains Xml Compatibility functionality for Jackson. 
 

Uses of JavaType in org.codehaus.jackson
 

Methods in org.codehaus.jackson with parameters of type JavaType
abstract
<T> T
ObjectCodec.readValue(JsonParser jp, JavaType valueType)
          Method to deserialize JSON content as tree expressed using set of JsonNode instances.
 

Uses of JavaType in org.codehaus.jackson.jaxrs
 

Methods in org.codehaus.jackson.jaxrs that return JavaType
protected  JavaType JacksonJsonProvider._convertType(Type jdkType)
          Method used to construct a JDK generic type into type definition Jackson understands.
 

Uses of JavaType in org.codehaus.jackson.map
 

Fields in org.codehaus.jackson.map declared as JavaType
protected  JavaType ObjectWriter._rootType
          Specified root serialization type to use; can be same as runtime type, but usually one of its super types
protected  JavaType BeanDescription._type
          Bean type information, including raw class and possible * generics information
 

Fields in org.codehaus.jackson.map with type parameters of type JavaType
protected  ConcurrentHashMap<JavaType,JsonDeserializer<Object>> ObjectMapper._rootDeserializers
          We will use a separate main-level Map for keeping track of root-level deserializers.
 

Methods in org.codehaus.jackson.map that return JavaType
 JavaType BeanDescription.getType()
          Method for accessing declared type of bean being introspected, including full generic type information (from declaration)
 

Methods in org.codehaus.jackson.map with parameters of type JavaType
protected  Object ObjectMapper._convert(Object fromValue, JavaType toValueType)
           
protected  JsonDeserializer<Object> ObjectMapper._findRootDeserializer(DeserializationConfig cfg, JavaType valueType)
          Method called to locate deserializer for the passed root-level value.
protected  Object ObjectMapper._readMapAndClose(JsonParser jp, JavaType valueType)
           
protected  Object ObjectMapper._readValue(DeserializationConfig cfg, JsonParser jp, JavaType valueType)
          Actual implementation of value reading+binding operation.
 TypeDeserializer ObjectMapper.DefaultTypeResolverBuilder.buildTypeDeserializer(JavaType baseType, Collection<NamedType> subtypes)
           
 TypeSerializer ObjectMapper.DefaultTypeResolverBuilder.buildTypeSerializer(JavaType baseType, Collection<NamedType> subtypes)
           
 boolean ObjectMapper.canDeserialize(JavaType type)
          Method that can be called to check whether mapper thinks it could deserialize an Object of given type.
<T> T
ObjectMapper.convertValue(Object fromValue, JavaType toValueType)
           
abstract  JsonDeserializer<Object> DeserializerFactory.createBeanDeserializer(DeserializationConfig config, JavaType type, DeserializerProvider p)
          Method called to create (or, for completely immutable deserializers, reuse) a deserializer that can convert Json content into values of specified Java "bean" (POJO) type.
 JsonSerializer<Object> SerializerFactory.createSerializer(JavaType type, SerializationConfig config)
          Method called to create (or, for immutable serializers, reuse) a serializer for given type.
 TypeSerializer SerializerFactory.createTypeSerializer(JavaType baseType, SerializationConfig config)
          Method called to create a type information serializer for given base type, if one is needed.
abstract  Class<?> AnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType baseContentType, String propName)
          Method for accessing additional narrowing type definition that a method can have, to define more specific content type to use; content refers to Map values and Collection/array elements.
 Class<?> AnnotationIntrospector.Pair.findDeserializationContentType(Annotated am, JavaType baseContentType, String propName)
           
abstract  Class<?> AnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType baseKeyType, String propName)
          Method for accessing additional narrowing type definition that a method can have, to define more specific key type to use.
 Class<?> AnnotationIntrospector.Pair.findDeserializationKeyType(Annotated am, JavaType baseKeyType, String propName)
           
abstract  Class<?> AnnotationIntrospector.findDeserializationType(Annotated am, JavaType baseType, String propName)
          Method for accessing annotated type definition that a method can have, to be used as the type for serialization instead of the runtime type.
 Class<?> AnnotationIntrospector.Pair.findDeserializationType(Annotated am, JavaType baseType, String propName)
           
abstract  KeyDeserializer DeserializerProvider.findKeyDeserializer(DeserializationConfig config, JavaType type)
          Method called to get hold of a deserializer to use for deserializing keys for Map.
abstract  TypeResolverBuilder<?> AnnotationIntrospector.findPropertyContentTypeResolver(AnnotatedMember am, JavaType containerType)
          Method for checking if given structured property entity (field or method that has nominal value of Map, Collection or array type) has annotations that indicate that specific type resolver is to be used for handling type information of contained values.
 TypeResolverBuilder<?> AnnotationIntrospector.Pair.findPropertyContentTypeResolver(AnnotatedMember am, JavaType baseType)
           
abstract  TypeResolverBuilder<?> AnnotationIntrospector.findPropertyTypeResolver(AnnotatedMember am, JavaType baseType)
          Method for checking if given property entity (field or method) has annotations that indicate that specific type resolver is to be used for handling instances.
 TypeResolverBuilder<?> AnnotationIntrospector.Pair.findPropertyTypeResolver(AnnotatedMember am, JavaType baseType)
           
 TypeDeserializer DeserializerFactory.findTypeDeserializer(DeserializationConfig config, JavaType baseType)
          Method called to find and create a type information deserializer for given base type, if one is needed.
abstract  JsonDeserializer<Object> DeserializerProvider.findTypedValueDeserializer(DeserializationConfig config, JavaType type)
          Method called to locate deserializer for given type, as well as matching type deserializer (if one is needed); and if type deserializer is needed, construct a "wrapped" deserializer that can extract and use type information for calling actual deserializer.
abstract  JsonSerializer<Object> SerializerProvider.findTypedValueSerializer(JavaType valueType, boolean cache)
          Method called to locate regular serializer, matching type serializer, and if both found, wrap them in a serializer that calls both in correct sequence.
abstract  TypeResolverBuilder<?> AnnotationIntrospector.findTypeResolver(AnnotatedClass ac, JavaType baseType)
          Method for checking if given class has annotations that indicate that specific type resolver is to be used for handling instances.
 TypeResolverBuilder<?> AnnotationIntrospector.Pair.findTypeResolver(AnnotatedClass ac, JavaType baseType)
           
abstract  JsonDeserializer<Object> DeserializerProvider.findValueDeserializer(DeserializationConfig config, JavaType type, JavaType referrer, String refPropName)
          Method called to get hold of a deserializer for a value of given type; or if no such deserializer can be found, a default handler (which may do a best-effort generic serialization or just simply throw an exception when invoked).
abstract  JsonSerializer<Object> SerializerProvider.findValueSerializer(JavaType serializationType)
           
abstract  T ClassIntrospector.forDeserialization(DeserializationConfig cfg, JavaType type, ClassIntrospector.MixInResolver r)
          Factory method that constructs an introspector that has all information needed for deserialization purposes.
 TypeResolverBuilder<?> SerializationConfig.getDefaultTyper(JavaType baseType)
           
 TypeResolverBuilder<?> MapperConfig.getDefaultTyper(JavaType baseType)
          Method called to locate a type info handler for types that do not have one explicitly declared via annotations (or other configuration).
 TypeResolverBuilder<?> DeserializationConfig.getDefaultTyper(JavaType baseType)
           
abstract  boolean DeserializerProvider.hasValueDeserializerFor(DeserializationConfig config, JavaType type)
          Method called to find out whether provider would be able to find a deserializer for given type, using a root reference (i.e.
<T extends BeanDescription>
T
DeserializationConfig.introspect(JavaType type)
          Method that will introspect full bean properties for the purpose of building a bean deserializer
<T> T
ObjectMapper.readValue(byte[] src, int offset, int len, JavaType valueType)
           
<T> T
ObjectMapper.readValue(File src, JavaType valueType)
           
<T> T
ObjectMapper.readValue(InputStream src, JavaType valueType)
           
<T> T
ObjectMapper.readValue(JsonParser jp, JavaType valueType)
          Method to deserialize Json content into a Java type, reference to which is passed as argument.
<T> T
ObjectMapper.readValue(JsonParser jp, JavaType valueType, DeserializationConfig cfg)
          Method to deserialize Json content into a Java type, reference to which is passed as argument.
<T> T
ObjectMapper.readValue(Reader src, JavaType valueType)
           
<T> T
ObjectMapper.readValue(String content, JavaType valueType)
           
<T> T
ObjectMapper.readValue(URL src, JavaType valueType)
           
abstract  void SerializerProvider.serializeValue(SerializationConfig cfg, JsonGenerator jgen, Object value, JavaType rootType, SerializerFactory jsf)
          The method to be called by ObjectMapper to execute recursive serialization, using serializers that this provider has access to; and using specified root type for locating first-level serializer.
 ObjectWriter ObjectMapper.typedWriter(JavaType rootType)
          Factory method for constructing ObjectWriter that will serialize objects using specified root type, instead of actual runtime type of value.
abstract  JsonMappingException DeserializationContext.unknownTypeException(JavaType baseType, String id)
          Helper method for constructing exception to indicate that given type id (parsed from JSON) could not be converted to a Java type.
 boolean ObjectMapper.DefaultTypeResolverBuilder.useForType(JavaType t)
          Method called to check if the default type handler should be used for given type.
 ObjectWriter ObjectWriter.withType(JavaType rootType)
           
 

Constructors in org.codehaus.jackson.map with parameters of type JavaType
BeanDescription(JavaType type)
           
ObjectWriter(ObjectMapper mapper, Class<?> view, JavaType rootType)
          Constructor used by ObjectMapper for initial instantiation
ObjectWriter(ObjectWriter base, SerializationConfig config, Class<?> view, JavaType rootType)
          Copy constructor used for building variations.
 

Uses of JavaType in org.codehaus.jackson.map.deser
 

Fields in org.codehaus.jackson.map.deser declared as JavaType
protected  JavaType BeanDeserializer._beanType
           
 

Fields in org.codehaus.jackson.map.deser with type parameters of type JavaType
protected  ConcurrentHashMap<JavaType,JsonDeserializer<Object>> StdDeserializerProvider._cachedDeserializers
          We will also cache some dynamically constructed deserializers; specifically, ones that are expensive to construct.
protected  HashMap<JavaType,JsonDeserializer<Object>> StdDeserializerProvider._incompleteDeserializers
          During deserializer construction process we may need to keep track of partially completed deserializers, to resolve cyclic dependencies.
 

Methods in org.codehaus.jackson.map.deser with type parameters of type JavaType
protected
<T extends JavaType>
T
BasicDeserializerFactory.modifyTypeByAnnotation(DeserializationConfig config, Annotated a, T type, String propName)
          Method called to see if given method has annotations that indicate a more specific type than what the argument specifies.
 

Methods in org.codehaus.jackson.map.deser that return JavaType
 JavaType SettableBeanProperty.getType()
           
 JavaType SettableAnyProperty.getType()
           
 JavaType StdDeserializer.getValueType()
          Exact structured type deserializer handles, if known; null for non-structured (scalar) types.
 JavaType MapDeserializer.getValueType()
           
 JavaType BeanDeserializer.getValueType()
           
 JavaType ArrayDeserializer.getValueType()
           
protected  JavaType BasicDeserializerFactory.resolveType(DeserializationConfig config, BasicBeanDescription beanDesc, Type rawType, Annotated a)
          Helper method used to resolve method return types and field types.
 

Methods in org.codehaus.jackson.map.deser that return types with arguments of type JavaType
static HashMap<JavaType,JsonDeserializer<Object>> ArrayDeserializers.getAll()
           
 

Methods in org.codehaus.jackson.map.deser with parameters of type JavaType
protected  JsonDeserializer<Object> StdDeserializerProvider._createAndCache2(DeserializationConfig config, JavaType type, JavaType referrer, String refPropName)
          Method that handles actual construction (via factory) and caching (both intermediate and eventual)
protected  JsonDeserializer<Object> StdDeserializerProvider._createAndCacheValueDeserializer(DeserializationConfig config, JavaType type, JavaType referrer, String refPropName)
          Method that will try to create a deserializer for given type, and resolve and cache it if necessary
protected  JsonDeserializer<Object> StdDeserializerProvider._createDeserializer(DeserializationConfig config, JavaType type, JavaType referrer, String refPropName)
           
protected  JsonDeserializer<Object> StdDeserializerProvider._findCachedDeserializer(JavaType type)
           
protected  KeyDeserializer StdDeserializerProvider._handleUnknownKeyDeserializer(JavaType type)
           
protected  JsonDeserializer<Object> StdDeserializerProvider._handleUnknownValueDeserializer(JavaType type)
           
 JsonDeserializer<Object> BeanDeserializerFactory.buildBeanDeserializer(DeserializationConfig config, JavaType type, BasicBeanDescription beanDesc)
          Method that is to actually build a bean deserializer instance.
 JsonDeserializer<Object> BeanDeserializerFactory.buildThrowableDeserializer(DeserializationConfig config, JavaType type, BasicBeanDescription beanDesc)
           
protected  BeanDeserializer BeanDeserializerFactory.constructBeanDeserializerInstance(DeserializationConfig config, JavaType type, BasicBeanDescription beanDesc)
          Method for construcing "empty" deserializer: overridable to allow sub-classing of BeanDeserializer.
protected  ThrowableDeserializer BeanDeserializerFactory.constructThrowableDeserializerInstance(DeserializationConfig config, JavaType type, BasicBeanDescription beanDesc)
           
 JsonDeserializer<Object> CustomDeserializerFactory.createBeanDeserializer(DeserializationConfig config, JavaType type, DeserializerProvider p)
           
 JsonDeserializer<Object> BeanDeserializerFactory.createBeanDeserializer(DeserializationConfig config, JavaType type, DeserializerProvider p)
          Method that DeserializerProviders call to create a new deserializer for types other than Collections, Maps, arrays and enums.
 JsonDeserializer<Object> BasicDeserializerFactory.createBeanDeserializer(DeserializationConfig config, JavaType type, DeserializerProvider p)
           
protected  JsonDeserializer<Object> StdDeserializer.findDeserializer(DeserializationConfig config, DeserializerProvider provider, JavaType type, String propertyName, Map<JavaType,JsonDeserializer<Object>> seen)
          Helper method used to locate deserializers for properties the bean itself contains.
 KeyDeserializer StdDeserializerProvider.findKeyDeserializer(DeserializationConfig config, JavaType type)
           
 TypeDeserializer BasicDeserializerFactory.findPropertyContentTypeDeserializer(DeserializationConfig config, JavaType containerType, AnnotatedMember propertyEntity)
          Method called to find and create a type information deserializer for values of given container (list, array, map) property, if one is needed.
 TypeDeserializer BasicDeserializerFactory.findPropertyTypeDeserializer(DeserializationConfig config, JavaType baseType, AnnotatedMember propertyEntity)
          Method called to create a type information deserializer for values of given non-container property, if one is needed.
 TypeDeserializer BasicDeserializerFactory.findTypeDeserializer(DeserializationConfig config, JavaType baseType)
           
 JsonDeserializer<Object> StdDeserializerProvider.findTypedValueDeserializer(DeserializationConfig config, JavaType type)
           
 JsonDeserializer<Object> StdDeserializerProvider.findValueDeserializer(DeserializationConfig config, JavaType type, JavaType referrer, String refPropName)
           
 boolean StdDeserializerProvider.hasValueDeserializerFor(DeserializationConfig config, JavaType type)
          Method that can be called to find out whether a deserializer can be found for given type
 JsonMappingException StdDeserializationContext.unknownTypeException(JavaType type, String id)
           
 

Method parameters in org.codehaus.jackson.map.deser with type arguments of type JavaType
protected  JsonDeserializer<Object> StdDeserializer.findDeserializer(DeserializationConfig config, DeserializerProvider provider, JavaType type, String propertyName, Map<JavaType,JsonDeserializer<Object>> seen)
          Helper method used to locate deserializers for properties the bean itself contains.
 

Constructors in org.codehaus.jackson.map.deser with parameters of type JavaType
BeanDeserializer(JavaType type)
           
MapDeserializer(JavaType mapType, Constructor<Map<Object,Object>> defCtor, KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser)
           
SettableAnyProperty(JavaType type, Method setter)
           
SettableBeanProperty.CreatorProperty(String propName, JavaType type, TypeDeserializer typeDeser, Class<?> declaringClass, int index)
           
SettableBeanProperty.FieldProperty(String propName, JavaType type, TypeDeserializer typeDeser, Field f)
           
SettableBeanProperty.MethodProperty(String propName, JavaType type, TypeDeserializer typeDeser, Method setter)
           
SettableBeanProperty.SetterlessProperty(String propName, JavaType type, TypeDeserializer typeDeser, Method getter)
           
SettableBeanProperty(String propName, JavaType type, TypeDeserializer typeDeser)
           
ThrowableDeserializer(JavaType type)
           
 

Uses of JavaType in org.codehaus.jackson.map.introspect
 

Methods in org.codehaus.jackson.map.introspect that return JavaType
 JavaType Annotated.getType(TypeBindings context)
          Full generic type of the annotated element; definition of what exactly this means depends on sub-class.
 

Methods in org.codehaus.jackson.map.introspect with parameters of type JavaType
 Class<?> NopAnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType t, String propName)
           
 Class<?> JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType baseContentType, String propName)
           
 Class<?> NopAnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType t, String propName)
           
 Class<?> JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType baseKeyType, String propName)
           
 Class<?> NopAnnotationIntrospector.findDeserializationType(Annotated am, JavaType t, String propName)
           
 Class<?> JacksonAnnotationIntrospector.findDeserializationType(Annotated am, JavaType baseType, String propName)
           
 TypeResolverBuilder<?> NopAnnotationIntrospector.findPropertyContentTypeResolver(AnnotatedMember am, JavaType baseType)
           
 TypeResolverBuilder<?> JacksonAnnotationIntrospector.findPropertyContentTypeResolver(AnnotatedMember am, JavaType baseType)
           
 TypeResolverBuilder<?> NopAnnotationIntrospector.findPropertyTypeResolver(AnnotatedMember am, JavaType baseType)
           
 TypeResolverBuilder<?> JacksonAnnotationIntrospector.findPropertyTypeResolver(AnnotatedMember am, JavaType baseType)
           
 TypeResolverBuilder<?> NopAnnotationIntrospector.findTypeResolver(AnnotatedClass ac, JavaType baseType)
           
 TypeResolverBuilder<?> JacksonAnnotationIntrospector.findTypeResolver(AnnotatedClass ac, JavaType baseType)
           
 BasicBeanDescription BasicClassIntrospector.forDeserialization(DeserializationConfig cfg, JavaType type, ClassIntrospector.MixInResolver r)
           
 

Constructors in org.codehaus.jackson.map.introspect with parameters of type JavaType
BasicBeanDescription(JavaType type, AnnotatedClass ac, AnnotationIntrospector ai)
           
 

Uses of JavaType in org.codehaus.jackson.map.jsontype
 

Methods in org.codehaus.jackson.map.jsontype that return JavaType
 JavaType TypeIdResolver.typeFromId(String id)
          Method called to resolve type from given type identifier.
 

Methods in org.codehaus.jackson.map.jsontype with parameters of type JavaType
 TypeDeserializer TypeResolverBuilder.buildTypeDeserializer(JavaType baseType, Collection<NamedType> subtypes)
          Method for building type deserializer based on current configuration of this builder.
 TypeSerializer TypeResolverBuilder.buildTypeSerializer(JavaType baseType, Collection<NamedType> subtypes)
          Method for building type serializer based on current configuration of this builder.
 void TypeIdResolver.init(JavaType baseType)
          Method that will be called once before any type resolution calls; used to initialize instance with configuration.
 

Uses of JavaType in org.codehaus.jackson.map.jsontype.impl
 

Fields in org.codehaus.jackson.map.jsontype.impl declared as JavaType
protected  JavaType TypeIdResolverBase._baseType
           
protected  JavaType TypeDeserializerBase._baseType
           
 

Fields in org.codehaus.jackson.map.jsontype.impl with type parameters of type JavaType
protected  HashMap<String,JavaType> TypeNameIdResolver._idToType
          Mappings from type id to JavaType, used for deserialization
 

Methods in org.codehaus.jackson.map.jsontype.impl that return JavaType
 JavaType TypeNameIdResolver.typeFromId(String id)
           
 JavaType MinimalClassNameIdResolver.typeFromId(String id)
           
 JavaType ClassNameIdResolver.typeFromId(String id)
           
 

Methods in org.codehaus.jackson.map.jsontype.impl with parameters of type JavaType
 TypeDeserializer StdTypeResolverBuilder.buildTypeDeserializer(JavaType baseType, Collection<NamedType> subtypes)
           
 TypeSerializer StdTypeResolverBuilder.buildTypeSerializer(JavaType baseType, Collection<NamedType> subtypes)
           
static TypeNameIdResolver TypeNameIdResolver.construct(JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser)
           
protected  TypeIdResolver StdTypeResolverBuilder.idResolver(JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser)
          Helper method that will either return configured custom type id resolver, or construct a standard resolver given configuration.
 void TypeIdResolverBase.init(JavaType bt)
           
 

Constructors in org.codehaus.jackson.map.jsontype.impl with parameters of type JavaType
AsArrayTypeDeserializer(JavaType bt, TypeIdResolver idRes)
           
AsPropertyTypeDeserializer(JavaType bt, TypeIdResolver idRes, String propName)
           
AsWrapperTypeDeserializer(JavaType bt, TypeIdResolver idRes)
           
ClassNameIdResolver(JavaType baseType)
           
MinimalClassNameIdResolver(JavaType baseType)
           
TypeDeserializerBase(JavaType baseType, TypeIdResolver idRes)
           
TypeIdResolverBase(JavaType baseType)
           
TypeNameIdResolver(JavaType baseType, HashMap<String,String> typeToId, HashMap<String,JavaType> idToType)
           
 

Constructor parameters in org.codehaus.jackson.map.jsontype.impl with type arguments of type JavaType
TypeNameIdResolver(JavaType baseType, HashMap<String,String> typeToId, HashMap<String,JavaType> idToType)
           
 

Uses of JavaType in org.codehaus.jackson.map.ser
 

Fields in org.codehaus.jackson.map.ser declared as JavaType
protected  JavaType BeanPropertyWriter._cfgSerializationType
          Type to use for locating serializer; normally same as return type of the accessor method, but may be overridden by annotations.
protected  JavaType ArraySerializers.ObjectArraySerializer._elementType
           
protected  JavaType BeanPropertyWriter._nonTrivialBaseType
          Base type of the property, if the declared type is "non-trivial"; meaning it is either a structured type (collection, map, array), or parametrized.
protected  JavaType MapSerializer._valueType
          Declared type of contained values
protected  JavaType EnumMapSerializer._valueType
           
 

Methods in org.codehaus.jackson.map.ser that return JavaType
protected  JavaType PropertyBuilder.findSerializationType(Annotated a, boolean useStaticTyping)
          Method that will try to determine statically defined type of property being serialized, based on annotations (for overrides), and alternatively declared type (if static typing for serialization is enabled).
 JavaType BeanPropertyWriter.getSerializationType()
           
 

Methods in org.codehaus.jackson.map.ser with parameters of type JavaType
protected  JsonSerializer<Object> StdSerializerProvider._createAndCacheUntypedSerializer(JavaType type)
           
protected  JsonSerializer<Object> StdSerializerProvider._createUntypedSerializer(JavaType type)
           
protected  void StdSerializerProvider._serializeValue(JsonGenerator jgen, Object value, JavaType rootType)
          Method called on the actual non-blueprint provider instance object, to kick off the serialization, when root type is explicitly specified and not determined from value.
 void SerializerCache.addNonTypedSerializer(JavaType type, JsonSerializer<Object> ser)
           
 void SerializerCache.addTypedSerializer(JavaType type, JsonSerializer<Object> ser)
          Method called if none of lookups succeeded, and caller had to construct a serializer.
protected  JsonSerializer<?> BasicSerializerFactory.buildCollectionSerializer(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
           
protected  JsonSerializer<?> BasicSerializerFactory.buildEnumMapSerializer(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
           
protected  JsonSerializer<?> BasicSerializerFactory.buildEnumSetSerializer(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
           
protected  JsonSerializer<?> BasicSerializerFactory.buildIndexedListSerializer(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
           
protected  JsonSerializer<?> BasicSerializerFactory.buildIterableSerializer(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
           
protected  JsonSerializer<?> BasicSerializerFactory.buildIteratorSerializer(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
           
protected  JsonSerializer<?> BasicSerializerFactory.buildMapSerializer(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
          Helper method that handles configuration details when constructing serializers for Map types.
protected  JsonSerializer<?> BasicSerializerFactory.buildObjectArraySerializer(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
          Helper method that handles configuration details when constructing serializers for Object[] (and subtypes).
static ContainerSerializerBase<?> ContainerSerializers.collectionSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
           
static MapSerializer MapSerializer.construct(String[] ignoredList, JavaType mapType, boolean staticValueType, TypeSerializer vts)
          Factory method used to construct Map serializers.
 JsonSerializer<Object> CustomSerializerFactory.createSerializer(JavaType type, SerializationConfig config)
           
 JsonSerializer<Object> BeanSerializerFactory.createSerializer(JavaType type, SerializationConfig config)
          Main serializer constructor method.
 JsonSerializer<Object> BasicSerializerFactory.createSerializer(JavaType type, SerializationConfig config)
           
 TypeSerializer BasicSerializerFactory.createTypeSerializer(JavaType baseType, SerializationConfig config)
          Method called to construct a type serializer for values with given declared base type.
static JsonSerializer<?> ContainerSerializers.enumSetSerializer(JavaType enumType)
           
 JsonSerializer<Object> BeanSerializerFactory.findBeanSerializer(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
          Method that will try to construct a BeanSerializer for given class.
 TypeSerializer BeanSerializerFactory.findPropertyContentTypeSerializer(JavaType containerType, SerializationConfig config, AnnotatedMember propertyEntity)
          Method called to create a type information serializer for values of given container property if one is needed.
 TypeSerializer BeanSerializerFactory.findPropertyTypeSerializer(JavaType baseType, SerializationConfig config, AnnotatedMember propertyEntity)
          Method called to create a type information serializer for values of given non-container property if one is needed.
 JsonSerializer<?> BasicSerializerFactory.findSerializerByAddonType(JavaType javaType, SerializationConfig config, BasicBeanDescription beanDesc)
          Reflection-based serialized find method, which checks if given class implements one of recognized "add-on" interfaces.
 JsonSerializer<?> BasicSerializerFactory.findSerializerByLookup(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
          Fast lookup-based accessor method, which will only check for type itself, but not consider super-classes or implemented interfaces.
 JsonSerializer<?> BasicSerializerFactory.findSerializerByPrimaryType(JavaType type, SerializationConfig config, BasicBeanDescription beanDesc)
          Reflection-based serialized find method, which checks if given class is a sub-type of one of well-known classes, or implements a "primary" interface.
 JsonSerializer<Object> StdSerializerProvider.findTypedValueSerializer(JavaType valueType, boolean cache)
           
 JsonSerializer<Object> StdSerializerProvider.findValueSerializer(JavaType valueType)
          This variant was added in 1.5, to allow for efficient access using full structured types, not just classes.
static ContainerSerializerBase<?> ContainerSerializers.indexedListSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
           
static ContainerSerializerBase<?> ContainerSerializers.iterableSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
           
static ContainerSerializerBase<?> ContainerSerializers.iteratorSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
           
static ContainerSerializerBase<?> ArraySerializers.objectArraySerializer(JavaType elementType, boolean staticTyping, TypeSerializer vts)
           
 void SerializerCache.TypedKeyFull.reset(JavaType type)
           
 void StdSerializerProvider.serializeValue(SerializationConfig config, JsonGenerator jgen, Object value, JavaType rootType, SerializerFactory jsf)
           
 void BeanPropertyWriter.setNonTrivialBaseType(JavaType t)
          Method called to define type to consider as "non-trivial" basetype, needed for dynamic serialization resolution for complex (usually container) types
 JsonSerializer<Object> SerializerCache.typedValueSerializer(JavaType type)
           
 JsonSerializer<Object> ReadOnlyClassToSerializerMap.typedValueSerializer(JavaType type)
           
 JsonSerializer<Object> SerializerCache.untypedValueSerializer(JavaType type)
           
 JsonSerializer<Object> ReadOnlyClassToSerializerMap.untypedValueSerializer(JavaType type)
           
 

Constructors in org.codehaus.jackson.map.ser with parameters of type JavaType
ArraySerializers.ObjectArraySerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
           
BeanPropertyWriter(String name, JsonSerializer<Object> ser, TypeSerializer typeSer, JavaType serType, Method acc, Field f, boolean suppressNulls, Object suppressableValue)
           
ContainerSerializers.CollectionSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
           
ContainerSerializers.EnumSetSerializer(JavaType elemType)
           
ContainerSerializers.IndexedListSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
           
ContainerSerializers.IterableSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
           
ContainerSerializers.IteratorSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
           
EnumMapSerializer(JavaType valueType, boolean staticTyping, EnumValues keyEnums, TypeSerializer vts)
           
MapSerializer(HashSet<String> ignoredEntries, JavaType valueType, boolean valueTypeIsStatic, TypeSerializer vts)
           
SerializerCache.TypedKeyFull(JavaType type)
           
 

Uses of JavaType in org.codehaus.jackson.map.type
 

Subclasses of JavaType in org.codehaus.jackson.map.type
 class ArrayType
          Array types represent Java arrays, both primitive and object valued.
 class CollectionType
          Type that represents Java Collection types (Lists, Sets).
 class MapType
          Type that represents Java Map types.
 class SimpleType
          Simple types are defined as anything other than one of recognized container types (arrays, Collections, Maps).
 class TypeBase
           
 

Fields in org.codehaus.jackson.map.type declared as JavaType
protected  JavaType TypeBindings._contextType
          Context type used for resolving all types, if specified.
protected  JavaType[] SimpleType._typeParameters
          Generic type arguments for this type.
static JavaType TypeBindings.UNBOUND
          Marker to use for (temporarily) unbound references.
 

Fields in org.codehaus.jackson.map.type with type parameters of type JavaType
protected  Map<String,JavaType> TypeBindings._bindings
          Lazily-instantiated bindings of resolved type parameters
 

Methods in org.codehaus.jackson.map.type with type parameters of type JavaType
protected
<T extends JavaType>
T
TypeFactory._findParentType(Class<?> clz, Class<T> expType)
          Method that is to figure out actual type parameters that given class binds to generic types defined by given interface type.
 

Methods in org.codehaus.jackson.map.type that return JavaType
protected  JavaType TypeFactory._fromArrayType(GenericArrayType type, TypeBindings context)
           
protected  JavaType TypeFactory._fromClass(Class<?> clz, TypeBindings context)
           
protected  JavaType TypeFactory._fromParameterizedClass(Class<?> clz, List<JavaType> paramTypes)
          Method used by TypeParser when generics-aware version is constructed.
protected  JavaType TypeFactory._fromParamType(ParameterizedType type, TypeBindings context)
          This method deals with parameterized types, that is, first class generic classes.
 JavaType TypeFactory._fromType(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  JavaType TypeFactory._fromVariable(TypeVariable<?> type, TypeBindings context)
           
protected  JavaType TypeFactory._fromWildcard(WildcardType type, TypeBindings context)
           
protected  JavaType SimpleType._narrow(Class<?> subclass)
           
protected  JavaType MapType._narrow(Class<?> subclass)
           
protected  JavaType CollectionType._narrow(Class<?> subclass)
           
protected  JavaType ArrayType._narrow(Class<?> subclass)
          Handling of narrowing conversions for arrays is trickier: for now, it is not even allowed.
protected  JavaType TypeFactory._unknownType()
           
static JavaType TypeFactory.arrayType(Class<?> elementType)
          Convenience factory method for constructing JavaType that represent array that contains elements of specified type.
static JavaType TypeFactory.arrayType(JavaType elementType)
          Convenience factory method for constructing JavaType that represent array that contains elements of specified type.
static JavaType TypeFactory.collectionType(Class<? extends Collection> collectionType, Class<?> elementType)
          Convenience factory method for constructing JavaType that represent Collection of specified type and contains elements of specified type
static JavaType TypeFactory.collectionType(Class<? extends Collection> collectionType, JavaType elementType)
          Convenience factory method for constructing JavaType that represent Collection of specified type and contains elements of specified type
 JavaType SimpleType.containedType(int index)
           
 JavaType MapType.containedType(int index)
           
 JavaType CollectionType.containedType(int index)
           
 JavaType ArrayType.containedType(int index)
           
protected  JavaType TypeBase.copyHandlers(JavaType fromType)
           
 JavaType TypeBindings.findType(String name)
           
static JavaType TypeFactory.fromCanonical(String canonical)
          Factory method for constructing a JavaType out of its canonical representation (see toCanonical()).
static JavaType TypeFactory.fromClass(Class<?> clz)
          Deprecated. Use TypeFactory.type(Type) instead
static JavaType TypeFactory.fromType(Type type)
          Deprecated. Use TypeFactory.type(Type) instead
static JavaType TypeFactory.fromTypeReference(TypeReference<?> ref)
          Deprecated. Use TypeFactory.type(Type) instead
 JavaType MapType.getContentType()
           
 JavaType CollectionType.getContentType()
           
 JavaType ArrayType.getContentType()
           
 JavaType MapType.getKeyType()
           
static JavaType TypeFactory.mapType(Class<? extends Map> mapType, Class<?> keyType, Class<?> valueType)
          Convenience factory method for constructing JavaType that represent Map of specified type and contains elements of specified type
static JavaType TypeFactory.mapType(Class<? extends Map> mapType, JavaType keyType, JavaType valueType)
          Convenience factory method for constructing JavaType that represent Map of specified type and contains elements of specified type
 JavaType SimpleType.narrowContentsBy(Class<?> subclass)
           
 JavaType MapType.narrowContentsBy(Class<?> contentClass)
           
 JavaType CollectionType.narrowContentsBy(Class<?> contentClass)
           
 JavaType ArrayType.narrowContentsBy(Class<?> contentClass)
          For array types, both main type and content type can be modified; but ultimately they are interchangeable.
 JavaType MapType.narrowKey(Class<?> keySubclass)
           
static JavaType TypeFactory.parametricType(Class<?> parametrized, Class<?>... parameterClasses)
          Factory method for constructing JavaType that represents a parameterized type.
static JavaType TypeFactory.parametricType(Class<?> parametrized, JavaType... parameterTypes)
          Factory method for constructing JavaType that represents a parameterized type.
 JavaType TypeParser.parse(String canonical)
           
protected  JavaType TypeParser.parseType(org.codehaus.jackson.map.type.TypeParser.MyTokenizer tokens)
           
static JavaType TypeFactory.specialize(JavaType baseType, Class<?> subclass)
          Method that tries to create specialized type given base type, and a sub-class thereof (which is assumed to use same parametrization as supertype).
static JavaType TypeFactory.type(Type t)
          Factory method for constructing JavaType from given "raw" type; which may be anything from simple Class to full generic type.
static JavaType TypeFactory.type(Type type, Class<?> context)
          Factory method that can use given context to resolve named generic types.
static JavaType TypeFactory.type(TypeReference<?> ref)
          Factory method that can be used if the full generic type has been passed using TypeReference.
static JavaType TypeFactory.type(Type type, TypeBindings bindings)
           
 

Methods in org.codehaus.jackson.map.type that return types with arguments of type JavaType
protected  List<JavaType> TypeParser.parseTypes(org.codehaus.jackson.map.type.TypeParser.MyTokenizer tokens)
           
 

Methods in org.codehaus.jackson.map.type with parameters of type JavaType
protected static SimpleType TypeFactory._constructSimple(Class<?> rawType, JavaType[] parameterTypes)
           
static JavaType TypeFactory.arrayType(JavaType elementType)
          Convenience factory method for constructing JavaType that represent array that contains elements of specified type.
static JavaType TypeFactory.collectionType(Class<? extends Collection> collectionType, JavaType elementType)
          Convenience factory method for constructing JavaType that represent Collection of specified type and contains elements of specified type
static CollectionType CollectionType.construct(Class<?> rawType, JavaType elemT)
           
static MapType MapType.construct(Class<?> rawType, JavaType keyT, JavaType valueT)
           
static ArrayType ArrayType.construct(JavaType componentType)
           
protected  JavaType TypeBase.copyHandlers(JavaType fromType)
           
static JavaType TypeFactory.mapType(Class<? extends Map> mapType, JavaType keyType, JavaType valueType)
          Convenience factory method for constructing JavaType that represent Map of specified type and contains elements of specified type
static JavaType TypeFactory.parametricType(Class<?> parametrized, JavaType... parameterTypes)
          Factory method for constructing JavaType that represents a parameterized type.
static JavaType TypeFactory.specialize(JavaType baseType, Class<?> subclass)
          Method that tries to create specialized type given base type, and a sub-class thereof (which is assumed to use same parametrization as supertype).
 

Method parameters in org.codehaus.jackson.map.type with type arguments of type JavaType
protected  JavaType TypeFactory._fromParameterizedClass(Class<?> clz, List<JavaType> paramTypes)
          Method used by TypeParser when generics-aware version is constructed.
 

Constructors in org.codehaus.jackson.map.type with parameters of type JavaType
SimpleType(Class<?> cls, String[] typeNames, JavaType[] typeParams)
           
TypeBindings(JavaType type)
           
 

Uses of JavaType in org.codehaus.jackson.map.util
 

Fields in org.codehaus.jackson.map.util declared as JavaType
protected  JavaType JSONWrappedObject._serializationType
          Optional static type to use for serialization; if null, runtime type is used.
protected  JavaType JSONPObject._serializationType
          Optional static type to use for serialization; if null, runtime type is used.
 

Methods in org.codehaus.jackson.map.util that return JavaType
 JavaType JSONWrappedObject.getSerializationType()
           
 JavaType JSONPObject.getSerializationType()
           
 

Constructors in org.codehaus.jackson.map.util with parameters of type JavaType
JSONPObject(String function, Object value, JavaType asType)
           
JSONWrappedObject(String prefix, String suffix, Object value, JavaType asType)
           
 

Uses of JavaType in org.codehaus.jackson.type
 

Methods in org.codehaus.jackson.type that return JavaType
protected abstract  JavaType JavaType._narrow(Class<?> subclass)
           
protected  JavaType JavaType._widen(Class<?> superclass)
           Default implementation is just to call _narrow(java.lang.Class), since underlying type construction is usually identical
 JavaType JavaType.containedType(int index)
          Method for accessing definitions of contained ("child") types.
 JavaType JavaType.forcedNarrowBy(Class<?> subclass)
          More efficient version of narrowBy(java.lang.Class), called by internal framework in cases where compatibility checks are to be skipped.
 JavaType JavaType.getContentType()
          Method for accessing content type of this type, if type has such a thing: simple types do not, structured types do (like arrays, Collections and Maps)
 JavaType JavaType.getKeyType()
          Method for accessing key type for this type, assuming type has such a concept (only Map types do)
 JavaType JavaType.narrowBy(Class<?> subclass)
          Method that can be called to do a "narrowing" conversions; that is, to return a type with a raw class that is assignable to the raw class of this type.
abstract  JavaType JavaType.narrowContentsBy(Class<?> contentClass)
           
 JavaType JavaType.widenBy(Class<?> superclass)
          Method that can be called to do a "widening" conversions; that is, to return a type with a raw class that could be assigned from this type.
 

Uses of JavaType in org.codehaus.jackson.xc
 

Methods in org.codehaus.jackson.xc with parameters of type JavaType
protected  Class<?> JaxbAnnotationIntrospector._doFindDeserializationType(Annotated a, JavaType baseType, String propName)
           
 Class<?> JaxbAnnotationIntrospector.findDeserializationContentType(Annotated a, JavaType baseContentType, String propName)
           
 Class<?> JaxbAnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType baseKeyType, String propName)
           
 Class<?> JaxbAnnotationIntrospector.findDeserializationType(Annotated a, JavaType baseType, String propName)
          JAXB does allow specifying (more) concrete class for deserialization by using \@XmlElement annotation.
 TypeResolverBuilder<?> JaxbAnnotationIntrospector.findPropertyContentTypeResolver(AnnotatedMember am, JavaType containerType)
           
 TypeResolverBuilder<?> JaxbAnnotationIntrospector.findPropertyTypeResolver(AnnotatedMember am, JavaType baseType)
           
 TypeResolverBuilder<?> JaxbAnnotationIntrospector.findTypeResolver(AnnotatedClass ac, JavaType baseType)