Package | Description |
---|---|
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.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.deser.impl |
Contains those implementation classes of deserialization part of
data binding that are not considered part of public or semi-public
interfaces.
|
org.codehaus.jackson.map.deser.std |
Contains public standard implementations of abstraction that
Jackson uses.
|
org.codehaus.jackson.map.ext |
Contains extended support for "external" packages: things that
may or may not be present in runtime environment, but that are
commonly enough used so that explicit support can be added.
|
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
TypeIdResolver . |
org.codehaus.jackson.map.module |
Package that contains classes and interfaces to help implement
custom extension
Module s
(which are registered using
ObjectMapper.registerModule(org.codehaus.jackson.map.Module) . |
org.codehaus.jackson.map.ser |
Contains implementation classes of serialization part of
data binding.
|
org.codehaus.jackson.map.ser.impl |
Contains implementation classes of serialization part of
data binding.
|
org.codehaus.jackson.map.ser.std | |
org.codehaus.jackson.map.type | |
org.codehaus.jackson.map.util |
Utility classes for Mapper package.
|
org.codehaus.jackson.mrbean |
Package that implements "interface materializer" functionality, whereby
abstract classes and interfaces can be used as-is, and framework constructs
implementations as needed.
|
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, such
as handlers for JAXB annotations
|
Modifier and Type | Method and Description |
---|---|
abstract <T> T |
ObjectCodec.readValue(JsonParser jp,
JavaType valueType)
Method to deserialize JSON content as tree expressed
using set of
JsonNode instances. |
abstract <T> Iterator<T> |
ObjectCodec.readValues(JsonParser jp,
JavaType valueType)
Method for reading sequence of Objects from parser stream,
all with same specified value type.
|
Modifier and Type | Field and Description |
---|---|
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 |
MappingIterator._type |
protected JavaType |
BeanProperty.Std._type |
protected JavaType |
BeanDescription._type
Bean type information, including raw class and possible
* generics information
|
protected JavaType |
ObjectReader._valueType
Declared type of value to instantiate during deserialization.
|
protected static JavaType |
SerializerProvider.TYPE_OBJECT |
Modifier and Type | Field and Description |
---|---|
protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>> |
ObjectReader._rootDeserializers
Root-level cached deserializers
|
protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>> |
ObjectMapper._rootDeserializers
We will use a separate main-level Map for keeping track
of root-level deserializers.
|
Modifier and Type | Method and Description |
---|---|
JavaType |
SerializerProvider.constructSpecializedType(JavaType baseType,
Class<?> subclass) |
JavaType |
MapperConfig.constructSpecializedType(JavaType baseType,
Class<?> subclass) |
JavaType |
MapperConfig.constructType(Class<?> cls)
Helper method that will construct
JavaType for given
raw class. |
JavaType |
DeserializationContext.constructType(Class<?> cls) |
JavaType |
SerializerProvider.constructType(Type type) |
JavaType |
ObjectMapper.constructType(Type t)
Convenience method for constructing
JavaType out of given
type (typically java.lang.Class ), but without explicit
context. |
JavaType |
MapperConfig.constructType(TypeReference<?> valueTypeRef)
Helper method that will construct
JavaType for given
type reference
This is a simple short-cut for: |
JavaType |
AbstractTypeResolver.findTypeMapping(DeserializationConfig config,
JavaType type)
Try to locate a subtype for given abstract type, to either resolve
to a concrete type, or at least to a more-specific (and hopefully supported)
abstract type, one which may have registered deserializers.
|
JavaType |
BeanProperty.getType()
Method to get declared type of the property.
|
JavaType |
BeanProperty.Std.getType() |
JavaType |
BeanDescription.getType()
Method for accessing declared type of bean being introspected,
including full generic type information (from declaration)
|
abstract JavaType |
DeserializerProvider.mapAbstractType(DeserializationConfig config,
JavaType type)
Method that can be called to try to resolve an abstract type
(interface, abstract class) into a concrete type, or at least
something "more concrete" (abstract class instead of interface).
|
abstract JavaType |
DeserializerFactory.mapAbstractType(DeserializationConfig config,
JavaType type)
Method that can be called to try to resolve an abstract type
(interface, abstract class) into a concrete type, or at least
something "more concrete" (abstract class instead of interface).
|
JavaType |
AbstractTypeResolver.resolveAbstractType(DeserializationConfig config,
JavaType type)
Method called to try to resolve an abstract type into
concrete type (usually for purposes of deserializing),
when no concrete implementation was found.
|
abstract JavaType |
BeanDescription.resolveType(Type jdkType)
Method for resolving given JDK type, using this bean as the
generic type resolution context.
|
Modifier and Type | Method and Description |
---|---|
protected Object |
ObjectMapper._convert(Object fromValue,
JavaType toValueType) |
protected JsonDeserializer<Object> |
ObjectReader._findRootDeserializer(DeserializationConfig cfg,
JavaType valueType)
Method called to locate deserializer for the passed root-level value.
|
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.
|
protected Object |
ObjectReader._unwrapAndDeserialize(JsonParser jp,
DeserializationContext ctxt,
JavaType rootType,
JsonDeserializer<Object> deser) |
protected Object |
ObjectMapper._unwrapAndDeserialize(JsonParser jp,
JavaType rootType,
DeserializationContext ctxt,
JsonDeserializer<Object> deser) |
TypeDeserializer |
ObjectMapper.DefaultTypeResolverBuilder.buildTypeDeserializer(DeserializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes,
BeanProperty property) |
TypeSerializer |
ObjectMapper.DefaultTypeResolverBuilder.buildTypeSerializer(SerializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes,
BeanProperty property) |
boolean |
ObjectMapper.canDeserialize(JavaType type)
Method that can be called to check whether mapper thinks
it could deserialize an Object of given type.
|
JavaType |
SerializerProvider.constructSpecializedType(JavaType baseType,
Class<?> subclass) |
JavaType |
MapperConfig.constructSpecializedType(JavaType baseType,
Class<?> subclass) |
<T> T |
ObjectMapper.convertValue(Object fromValue,
JavaType toValueType) |
abstract JsonDeserializer<Object> |
DeserializerFactory.createBeanDeserializer(DeserializationConfig config,
DeserializerProvider p,
JavaType type,
BeanProperty property)
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.
|
abstract JsonDeserializer<?> |
DeserializerFactory.createEnumDeserializer(DeserializationConfig config,
DeserializerProvider p,
JavaType type,
BeanProperty property) |
KeyDeserializer |
DeserializerFactory.createKeyDeserializer(DeserializationConfig config,
JavaType type,
BeanProperty property)
Method called to find if factory knows how to create a key deserializer
for specified type; currently this means checking if a module has registered
possible deserializers.
|
abstract JsonSerializer<Object> |
SerializerFactory.createKeySerializer(SerializationConfig config,
JavaType baseType,
BeanProperty property)
Method called to create serializer to use for serializing JSON property names (which must
be output as
JsonToken.FIELD_NAME ) for Map that has specified declared
key type, and is for specified property (or, if property is null, as root value) |
JsonSerializer<Object> |
SerializerFactory.createSerializer(JavaType type,
SerializationConfig config)
Deprecated.
Since 1.7, call variant with more arguments
|
abstract JsonSerializer<Object> |
SerializerFactory.createSerializer(SerializationConfig config,
JavaType baseType,
BeanProperty property)
Method called to create (or, for immutable serializers, reuse) a serializer for given type.
|
abstract JsonDeserializer<?> |
DeserializerFactory.createTreeDeserializer(DeserializationConfig config,
DeserializerProvider p,
JavaType type,
BeanProperty property)
Method called to create and return a deserializer that can construct
JsonNode(s) from JSON content.
|
TypeSerializer |
SerializerFactory.createTypeSerializer(JavaType baseType,
SerializationConfig config)
Deprecated.
Since 1.7, call variant with more arguments
|
abstract TypeSerializer |
SerializerFactory.createTypeSerializer(SerializationConfig config,
JavaType baseType,
BeanProperty property)
Method called to create a type information serializer for given base type,
if one is needed.
|
JsonDeserializer<?> |
Deserializers.findBeanDeserializer(JavaType type,
DeserializationConfig config,
DeserializerProvider provider,
BeanDescription beanDesc,
BeanProperty property)
Method called to locate deserializer for specified value type which does not belong to any other
category (not an Enum, Collection, Map, Array or tree node)
|
JsonDeserializer<?> |
Deserializers.Base.findBeanDeserializer(JavaType type,
DeserializationConfig config,
DeserializerProvider provider,
BeanDescription beanDesc,
BeanProperty property) |
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 SerializedString |
DeserializerProvider.findExpectedRootName(DeserializationConfig config,
JavaType type)
Method that can be used to try find expected root name for given type
|
abstract KeyDeserializer |
DeserializerProvider.findKeyDeserializer(DeserializationConfig config,
JavaType keyType,
BeanProperty property)
Method called to get hold of a deserializer to use for deserializing
keys for
Map . |
KeyDeserializer |
KeyDeserializers.findKeyDeserializer(JavaType type,
DeserializationConfig config,
BeanDescription beanDesc,
BeanProperty property) |
abstract JsonSerializer<Object> |
SerializerProvider.findKeySerializer(JavaType keyType,
BeanProperty property)
Method called to get the serializer to use for serializing
non-null Map keys.
|
TypeResolverBuilder<?> |
AnnotationIntrospector.findPropertyContentTypeResolver(MapperConfig<?> config,
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(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType) |
TypeResolverBuilder<?> |
AnnotationIntrospector.findPropertyTypeResolver(MapperConfig<?> config,
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(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType) |
Class<?> |
AnnotationIntrospector.findSerializationContentType(Annotated am,
JavaType baseType)
Method for finding possible widening type definition that a property
value can have, to define less specific key type to use for serialization.
|
Class<?> |
AnnotationIntrospector.Pair.findSerializationContentType(Annotated am,
JavaType baseType) |
Class<?> |
AnnotationIntrospector.findSerializationKeyType(Annotated am,
JavaType baseType)
Method for finding possible widening type definition that a property
value can have, to define less specific key type to use for serialization.
|
Class<?> |
AnnotationIntrospector.Pair.findSerializationKeyType(Annotated am,
JavaType baseType) |
JsonSerializer<?> |
Serializers.findSerializer(SerializationConfig config,
JavaType type,
BeanDescription beanDesc,
BeanProperty property)
Method called by serialization framework first time a serializer is needed for
specified type, which is not of a container type (for which other methods are
called).
|
JsonSerializer<?> |
Serializers.Base.findSerializer(SerializationConfig config,
JavaType type,
BeanDescription beanDesc,
BeanProperty property) |
TypeDeserializer |
DeserializerFactory.findTypeDeserializer(DeserializationConfig config,
JavaType baseType,
BeanProperty property)
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,
BeanProperty property)
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.
|
JsonSerializer<Object> |
SerializerProvider.findTypedValueSerializer(JavaType valueType,
boolean cache)
Deprecated.
As of version 1.7, use version that exposes property object
instead of just its type (needed for contextual serializers)
|
abstract JsonSerializer<Object> |
SerializerProvider.findTypedValueSerializer(JavaType valueType,
boolean cache,
BeanProperty property)
Method called to locate regular serializer, matching type serializer,
and if both found, wrap them in a serializer that calls both in correct
sequence.
|
JavaType |
AbstractTypeResolver.findTypeMapping(DeserializationConfig config,
JavaType type)
Try to locate a subtype for given abstract type, to either resolve
to a concrete type, or at least to a more-specific (and hopefully supported)
abstract type, one which may have registered deserializers.
|
TypeResolverBuilder<?> |
AnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
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(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
abstract JsonDeserializer<Object> |
DeserializerProvider.findValueDeserializer(DeserializationConfig config,
JavaType propertyType,
BeanProperty property)
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).
|
JsonSerializer<Object> |
SerializerProvider.findValueSerializer(JavaType serializationType)
Deprecated.
As of version 1.7, use version that exposes property object
instead of just its type (needed for contextual serializers)
|
abstract JsonSerializer<Object> |
SerializerProvider.findValueSerializer(JavaType serializationType,
BeanProperty property)
Similar to
SerializerProvider.findValueSerializer(Class) , but takes full generics-aware
type instead of raw class. |
abstract T |
ClassIntrospector.forClassAnnotations(MapperConfig<?> cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that only has
information regarding annotations class itself (or its supertypes) has,
but nothing on methods or constructors.
|
abstract T |
ClassIntrospector.forCreation(DeserializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that has
information necessary for creating instances of given
class ("creator"), as well as class annotations, but
no information on member methods
|
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.
|
abstract T |
ClassIntrospector.forDirectClassAnnotations(MapperConfig<?> cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that only has
information regarding annotations class itself has (but NOT including
its supertypes), but nothing on methods or constructors.
|
abstract T |
ClassIntrospector.forSerialization(SerializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that has all
information needed for serialization purposes.
|
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).
|
JsonSerializer<Object> |
SerializerProvider.getKeySerializer(JavaType valueType,
BeanProperty property)
Deprecated.
As of version 1.8
|
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> |
SerializationConfig.introspect(JavaType type)
Method that will introspect full bean properties for the purpose
of building a bean serializer
|
<T extends BeanDescription> |
DeserializationConfig.introspect(JavaType type)
Method that will introspect full bean properties for the purpose
of building a bean deserializer
|
abstract <DESC extends BeanDescription> |
MapperConfig.introspectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains class
annotations: useful if no getter/setter/creator information is needed.
|
<T extends BeanDescription> |
SerializationConfig.introspectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains class
annotations: useful if no getter/setter/creator information is needed.
|
<T extends BeanDescription> |
DeserializationConfig.introspectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains class
annotations: useful if no getter/setter/creator information is needed.
|
abstract <DESC extends BeanDescription> |
MapperConfig.introspectDirectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains immediate class
annotations: ones from the class, and its direct mix-in, if any, but
not from super types.
|
<T extends BeanDescription> |
SerializationConfig.introspectDirectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains immediate class
annotations: ones from the class, and its direct mix-in, if any, but
not from super types.
|
<T extends BeanDescription> |
DeserializationConfig.introspectDirectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains immediate class
annotations: ones from the class, and its direct mix-in, if any, but
not from super types.
|
<T extends BeanDescription> |
DeserializationConfig.introspectForCreation(JavaType type)
Method that will introspect subset of bean properties needed to
construct bean instance.
|
abstract JavaType |
DeserializerProvider.mapAbstractType(DeserializationConfig config,
JavaType type)
Method that can be called to try to resolve an abstract type
(interface, abstract class) into a concrete type, or at least
something "more concrete" (abstract class instead of interface).
|
abstract JavaType |
DeserializerFactory.mapAbstractType(DeserializationConfig config,
JavaType type)
Method that can be called to try to resolve an abstract type
(interface, abstract class) into a concrete type, or at least
something "more concrete" (abstract class instead of interface).
|
ObjectReader |
ObjectMapper.reader(JavaType type)
Factory method for constructing
ObjectReader that will
read or update instances of specified type |
<T> T |
ObjectMapper.readValue(byte[] src,
int offset,
int len,
JavaType valueType) |
<T> T |
ObjectMapper.readValue(byte[] src,
JavaType valueType) |
<T> T |
ObjectMapper.readValue(File src,
JavaType valueType) |
<T> T |
ObjectMapper.readValue(InputStream src,
JavaType valueType) |
<T> T |
ObjectMapper.readValue(JsonNode root,
JavaType valueType)
Convenience method for converting results from given JSON tree into given
value type.
|
<T> T |
ObjectReader.readValue(JsonParser jp,
JavaType valueType)
Convenience method that binds content read using given parser, using
configuration of this reader, except that expected value type
is specified with the call (instead of currently configured root type).
|
<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) |
<T> Iterator<T> |
ObjectReader.readValues(JsonParser jp,
JavaType valueType)
Convenience method that is equivalent to:
|
<T> MappingIterator<T> |
ObjectMapper.readValues(JsonParser jp,
JavaType valueType)
Method for reading sequence of Objects from parser stream.
|
JavaType |
AbstractTypeResolver.resolveAbstractType(DeserializationConfig config,
JavaType type)
Method called to try to resolve an abstract type into
concrete type (usually for purposes of deserializing),
when no concrete implementation was found.
|
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)
Deprecated.
Since 1.9, use
ObjectMapper.writerWithType(JavaType) instead. |
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)
Method that will construct a new instance that uses specific type
as the root type for serialization, instead of runtime dynamic
type of the root object itself.
|
ObjectReader |
ObjectReader.withType(JavaType valueType)
Method for constructing a new reader instance that is configured
to data bind into specified type.
|
BeanProperty.Std |
BeanProperty.Std.withType(JavaType type) |
ObjectWriter |
ObjectMapper.writerWithType(JavaType rootType)
Factory method for constructing
ObjectWriter that will
serialize objects using specified root type, instead of actual
runtime type of value. |
Modifier and Type | Field and Description |
---|---|
protected JavaType |
AbstractDeserializer._baseType |
protected JavaType |
BeanDeserializer._beanType
Declared type of the bean this deserializer handles.
|
protected JavaType |
SettableBeanProperty._type
Base type for property; may be a supertype of actual value.
|
protected JavaType |
SettableAnyProperty._type |
Modifier and Type | Field and Description |
---|---|
protected static HashMap<JavaType,JsonDeserializer<Object>> |
BasicDeserializerFactory._arrayDeserializers
And finally, we have special array deserializers for primitive
array types
|
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.
|
Modifier and Type | Method and Description |
---|---|
protected <T extends JavaType> |
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.
|
Modifier and Type | Method and Description |
---|---|
protected JavaType |
BeanDeserializerFactory._mapAbstractType2(DeserializationConfig config,
JavaType type)
Method that will find abstract type mapping for specified type, doing a single
lookup through registered abstract type resolvers; will not do recursive lookups.
|
JavaType |
ValueInstantiator.getDelegateType()
Method that can be used to determine what is the type of delegate
type to use, if any; if no delegates are used, will return null.
|
JavaType |
SettableBeanProperty.getType() |
JavaType |
SettableAnyProperty.getType() |
JavaType |
BeanDeserializer.getValueType() |
JavaType |
StdDeserializerProvider.mapAbstractType(DeserializationConfig config,
JavaType type) |
JavaType |
BeanDeserializerFactory.mapAbstractType(DeserializationConfig config,
JavaType type)
Method that will find complete abstract type mapping for specified type, doing as
many resolution steps as necessary.
|
abstract JavaType |
BasicDeserializerFactory.mapAbstractType(DeserializationConfig config,
JavaType type) |
protected JavaType |
BeanDeserializerFactory.materializeAbstractType(DeserializationConfig config,
BasicBeanDescription beanDesc) |
protected JavaType |
BasicDeserializerFactory.resolveType(DeserializationConfig config,
BasicBeanDescription beanDesc,
JavaType type,
AnnotatedMember member,
BeanProperty property)
Helper method used to resolve method return types and field
types.
|
Modifier and Type | Method and Description |
---|---|
protected JsonDeserializer<Object> |
StdDeserializerProvider._createAndCache2(DeserializationConfig config,
JavaType type,
BeanProperty property)
Method that handles actual construction (via factory) and caching (both
intermediate and eventual)
|
protected JsonDeserializer<Object> |
StdDeserializerProvider._createAndCacheValueDeserializer(DeserializationConfig config,
JavaType type,
BeanProperty property)
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,
BeanProperty property) |
protected JsonDeserializer<Object> |
StdDeserializerProvider._findCachedDeserializer(JavaType type) |
protected JsonDeserializer<Object> |
BeanDeserializerFactory._findCustomBeanDeserializer(JavaType type,
DeserializationConfig config,
DeserializerProvider provider,
BasicBeanDescription beanDesc,
BeanProperty property) |
protected KeyDeserializer |
StdDeserializerProvider._handleUnknownKeyDeserializer(JavaType type) |
protected JsonDeserializer<Object> |
StdDeserializerProvider._handleUnknownValueDeserializer(JavaType type) |
protected JavaType |
BeanDeserializerFactory._mapAbstractType2(DeserializationConfig config,
JavaType type)
Method that will find abstract type mapping for specified type, doing a single
lookup through registered abstract type resolvers; will not do recursive lookups.
|
void |
BeanDeserializerBuilder.addInjectable(String propertyName,
JavaType propertyType,
Annotations contextAnnotations,
AnnotatedMember member,
Object valueId) |
JsonDeserializer<Object> |
BeanDeserializerFactory.buildBeanDeserializer(DeserializationConfig config,
JavaType type,
BasicBeanDescription beanDesc,
BeanProperty property)
Method that is to actually build a bean deserializer instance.
|
JsonDeserializer<Object> |
BeanDeserializerFactory.buildThrowableDeserializer(DeserializationConfig config,
JavaType type,
BasicBeanDescription beanDesc,
BeanProperty property) |
JsonDeserializer<Object> |
CustomDeserializerFactory.createBeanDeserializer(DeserializationConfig config,
DeserializerProvider p,
JavaType type,
BeanProperty property)
Deprecated.
|
JsonDeserializer<Object> |
BeanDeserializerFactory.createBeanDeserializer(DeserializationConfig config,
DeserializerProvider p,
JavaType type,
BeanProperty property)
Method that
DeserializerProvider s call to create a new
deserializer for types other than Collections, Maps, arrays and
enums. |
JsonDeserializer<?> |
CustomDeserializerFactory.createEnumDeserializer(DeserializationConfig config,
DeserializerProvider p,
JavaType enumType,
BeanProperty property)
Deprecated.
|
JsonDeserializer<?> |
BasicDeserializerFactory.createEnumDeserializer(DeserializationConfig config,
DeserializerProvider p,
JavaType type,
BeanProperty property)
Factory method for constructing serializers of
Enum types. |
KeyDeserializer |
BeanDeserializerFactory.createKeyDeserializer(DeserializationConfig config,
JavaType type,
BeanProperty property) |
JsonDeserializer<?> |
BasicDeserializerFactory.createTreeDeserializer(DeserializationConfig config,
DeserializerProvider p,
JavaType nodeType,
BeanProperty property) |
SerializedString |
StdDeserializerProvider.findExpectedRootName(DeserializationConfig config,
JavaType type) |
KeyDeserializer |
StdDeserializerProvider.findKeyDeserializer(DeserializationConfig config,
JavaType type,
BeanProperty property) |
TypeDeserializer |
BasicDeserializerFactory.findPropertyContentTypeDeserializer(DeserializationConfig config,
JavaType containerType,
AnnotatedMember propertyEntity,
BeanProperty property)
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 annotated,
BeanProperty property)
Method called to create a type information deserializer for values of
given non-container property, if one is needed.
|
protected JsonDeserializer<Object> |
BasicDeserializerFactory.findStdBeanDeserializer(DeserializationConfig config,
DeserializerProvider p,
JavaType type,
BeanProperty property)
Method called by
BeanDeserializerFactory to see if there might be a standard
deserializer registered for given type. |
TypeDeserializer |
BasicDeserializerFactory.findTypeDeserializer(DeserializationConfig config,
JavaType baseType,
BeanProperty property) |
JsonDeserializer<Object> |
StdDeserializerProvider.findTypedValueDeserializer(DeserializationConfig config,
JavaType type,
BeanProperty property) |
JsonDeserializer<Object> |
StdDeserializerProvider.findValueDeserializer(DeserializationConfig config,
JavaType propertyType,
BeanProperty property) |
boolean |
StdDeserializerProvider.hasValueDeserializerFor(DeserializationConfig config,
JavaType type)
Method that can be called to find out whether a deserializer can
be found for given type
|
JavaType |
StdDeserializerProvider.mapAbstractType(DeserializationConfig config,
JavaType type) |
JavaType |
BeanDeserializerFactory.mapAbstractType(DeserializationConfig config,
JavaType type)
Method that will find complete abstract type mapping for specified type, doing as
many resolution steps as necessary.
|
abstract JavaType |
BasicDeserializerFactory.mapAbstractType(DeserializationConfig config,
JavaType type) |
protected JavaType |
BasicDeserializerFactory.resolveType(DeserializationConfig config,
BasicBeanDescription beanDesc,
JavaType type,
AnnotatedMember member,
BeanProperty property)
Helper method used to resolve method return types and field
types.
|
JsonMappingException |
StdDeserializationContext.unknownTypeException(JavaType type,
String id) |
Constructor and Description |
---|
CreatorProperty(String name,
JavaType type,
TypeDeserializer typeDeser,
Annotations contextAnnotations,
AnnotatedParameter param,
int index,
Object injectableValueId) |
ValueInjector(String propertyName,
JavaType type,
Annotations contextAnnotations,
AnnotatedMember mutator,
Object valueId) |
Modifier and Type | Field and Description |
---|---|
protected JavaType |
ObjectArrayDeserializer._arrayType |
protected JavaType |
StringCollectionDeserializer._collectionType |
protected JavaType |
CollectionDeserializer._collectionType |
protected JavaType |
StdValueInstantiator._delegateType |
protected JavaType |
MapDeserializer._mapType |
protected JavaType |
AtomicReferenceDeserializer._referencedType
Type of value that we reference
|
Modifier and Type | Field and Description |
---|---|
protected HashMap<JavaType,KeyDeserializer> |
StdKeyDeserializers._keyDeserializers |
Modifier and Type | Method and Description |
---|---|
JavaType |
JavaTypeDeserializer.deserialize(JsonParser jp,
DeserializationContext ctxt) |
JavaType |
StringCollectionDeserializer.getContentType() |
JavaType |
ObjectArrayDeserializer.getContentType() |
JavaType |
MapDeserializer.getContentType() |
abstract JavaType |
ContainerDeserializerBase.getContentType()
Accessor for declared type of contained value elements; either exact
type, or one of its supertypes.
|
JavaType |
CollectionDeserializer.getContentType() |
JavaType |
StdValueInstantiator.getDelegateType() |
JavaType |
StdDeserializer.getValueType()
Exact structured type deserializer handles, if known.
|
JavaType |
MapDeserializer.getValueType() |
Modifier and Type | Method and Description |
---|---|
static HashMap<JavaType,KeyDeserializer> |
StdKeyDeserializers.constructAll() |
static HashMap<JavaType,JsonDeserializer<Object>> |
PrimitiveArrayDeserializers.getAll() |
Modifier and Type | Method and Description |
---|---|
void |
StdValueInstantiator.configureFromObjectSettings(AnnotatedWithParams defaultCreator,
AnnotatedWithParams delegateCreator,
JavaType delegateType,
AnnotatedWithParams withArgsCreator,
CreatorProperty[] constructorArgs)
Method for setting properties related to instantiating values
from JSON Object.
|
static KeyDeserializer |
StdKeyDeserializers.constructStringKeyDeserializer(DeserializationConfig config,
JavaType type) |
protected JsonDeserializer<Object> |
StdDeserializer.findDeserializer(DeserializationConfig config,
DeserializerProvider provider,
JavaType type,
BeanProperty property)
Helper method used to locate deserializers for properties the
type this deserializer handles contains (usually for properties of
bean types)
|
static KeyDeserializer |
StdKeyDeserializers.findStringBasedKeyDeserializer(DeserializationConfig config,
JavaType type) |
Modifier and Type | Method and Description |
---|---|
JsonDeserializer<?> |
OptionalHandlerFactory.findDeserializer(JavaType type,
DeserializationConfig config,
DeserializerProvider p) |
JsonSerializer<?> |
OptionalHandlerFactory.findSerializer(SerializationConfig config,
JavaType type) |
Modifier and Type | Field and Description |
---|---|
protected JavaType |
POJOPropertiesCollector._type
Type of POJO for which properties are being collected.
|
Modifier and Type | Method and Description |
---|---|
JavaType |
POJOPropertiesCollector.getType() |
JavaType |
AnnotatedMethod.getType(TypeBindings bindings)
As per [JACKSON-468], we need to also allow declaration of local
type bindings; mostly it will allow defining bounds.
|
JavaType |
AnnotatedConstructor.getType(TypeBindings bindings)
As per [JACKSON-468], we need to also allow declaration of local
type bindings; mostly it will allow defining bounds.
|
JavaType |
Annotated.getType(TypeBindings context)
Full generic type of the annotated element; definition
of what exactly this means depends on sub-class.
|
protected JavaType |
AnnotatedWithParams.getType(TypeBindings bindings,
TypeVariable<?>[] typeParams) |
JavaType |
AnnotatedWithParams.resolveParameterType(int index,
TypeBindings bindings)
Method called to fully resolve type of one of parameters, given
specified type variable bindings.
|
JavaType |
BasicBeanDescription.resolveType(Type jdkType) |
Modifier and Type | Method and Description |
---|---|
protected BasicBeanDescription |
BasicClassIntrospector._findCachedDesc(JavaType type)
Method called to see if type is one of core JDK types
that we have cached for efficiency.
|
protected TypeResolverBuilder<?> |
JacksonAnnotationIntrospector._findTypeResolver(MapperConfig<?> config,
Annotated ann,
JavaType baseType)
Helper method called to construct and initialize instance of
TypeResolverBuilder
if given annotated element indicates one is needed. |
AnnotatedClass |
BasicClassIntrospector.classWithCreators(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r) |
POJOPropertiesCollector |
BasicClassIntrospector.collectProperties(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r,
boolean forSerialization) |
protected POJOPropertiesCollector |
BasicClassIntrospector.constructPropertyCollector(MapperConfig<?> config,
AnnotatedClass ac,
JavaType type,
boolean forSerialization)
Overridable method called for creating
POJOPropertiesCollector instance
to use; override is needed if a custom sub-class is to be used. |
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<?> |
JacksonAnnotationIntrospector.findPropertyContentTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType containerType)
Since 1.7, it is possible to use
JsonTypeInfo from a property too. |
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findPropertyTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType)
Since 1.7, it is possible to use
JsonTypeInfo from a property too. |
Class<?> |
JacksonAnnotationIntrospector.findSerializationContentType(Annotated am,
JavaType baseType) |
Class<?> |
JacksonAnnotationIntrospector.findSerializationKeyType(Annotated am,
JavaType baseType) |
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
BasicBeanDescription |
BasicClassIntrospector.forClassAnnotations(MapperConfig<?> cfg,
JavaType type,
ClassIntrospector.MixInResolver r) |
BasicBeanDescription |
BasicClassIntrospector.forCreation(DeserializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r) |
BasicBeanDescription |
BasicClassIntrospector.forDeserialization(DeserializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r) |
BasicBeanDescription |
BasicClassIntrospector.forDirectClassAnnotations(MapperConfig<?> cfg,
JavaType type,
ClassIntrospector.MixInResolver r) |
static BasicBeanDescription |
BasicBeanDescription.forOtherUse(MapperConfig<?> config,
JavaType type,
AnnotatedClass ac)
Factory method to use for constructing an instance to use for purposes
other than building serializers or deserializers; will only have information
on class, not on properties.
|
BasicBeanDescription |
BasicClassIntrospector.forSerialization(SerializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r) |
Constructor and Description |
---|
BasicBeanDescription(MapperConfig<?> config,
JavaType type,
AnnotatedClass ac)
Deprecated.
Since 1.9, should use factory methods instead
|
BasicBeanDescription(MapperConfig<?> config,
JavaType type,
AnnotatedClass ac,
List<BeanPropertyDefinition> properties) |
POJOPropertiesCollector(MapperConfig<?> config,
boolean forSerialization,
JavaType type,
AnnotatedClass classDef) |
Modifier and Type | Method and Description |
---|---|
JavaType |
TypeIdResolver.typeFromId(String id)
Method called to resolve type from given type identifier.
|
Modifier and Type | Method and Description |
---|---|
TypeDeserializer |
TypeResolverBuilder.buildTypeDeserializer(DeserializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes,
BeanProperty property)
Method for building type deserializer based on current configuration
of this builder.
|
TypeSerializer |
TypeResolverBuilder.buildTypeSerializer(SerializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes,
BeanProperty property)
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.
|
Modifier and Type | Field and Description |
---|---|
protected JavaType |
TypeIdResolverBase._baseType
Common base type for all polymorphic instances handled.
|
protected JavaType |
TypeDeserializerBase._baseType |
protected JavaType |
TypeDeserializerBase._defaultImpl
Type to use as the default implementation, if type id is
missing or can not be resolved.
|
Modifier and Type | Field and Description |
---|---|
protected HashMap<String,JavaType> |
TypeNameIdResolver._idToType
Mappings from type id to JavaType, used for deserialization
|
Modifier and Type | Method and Description |
---|---|
JavaType |
TypeNameIdResolver.typeFromId(String id) |
JavaType |
MinimalClassNameIdResolver.typeFromId(String id) |
JavaType |
ClassNameIdResolver.typeFromId(String id) |
Modifier and Type | Method and Description |
---|---|
TypeDeserializer |
StdTypeResolverBuilder.buildTypeDeserializer(DeserializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes,
BeanProperty property) |
TypeSerializer |
StdTypeResolverBuilder.buildTypeSerializer(SerializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes,
BeanProperty property) |
static TypeNameIdResolver |
TypeNameIdResolver.construct(MapperConfig<?> config,
JavaType baseType,
Collection<NamedType> subtypes,
boolean forSer,
boolean forDeser) |
protected TypeIdResolver |
StdTypeResolverBuilder.idResolver(MapperConfig<?> config,
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) |
Constructor and Description |
---|
TypeNameIdResolver(MapperConfig<?> config,
JavaType baseType,
HashMap<String,String> typeToId,
HashMap<String,JavaType> idToType) |
Modifier and Type | Method and Description |
---|---|
JavaType |
SimpleAbstractTypeResolver.findTypeMapping(DeserializationConfig config,
JavaType type) |
JavaType |
SimpleAbstractTypeResolver.resolveAbstractType(DeserializationConfig config,
JavaType type) |
Modifier and Type | Method and Description |
---|---|
JsonDeserializer<?> |
SimpleDeserializers.findBeanDeserializer(JavaType type,
DeserializationConfig config,
DeserializerProvider provider,
BeanDescription beanDesc,
BeanProperty property) |
KeyDeserializer |
SimpleKeyDeserializers.findKeyDeserializer(JavaType type,
DeserializationConfig config,
BeanDescription beanDesc,
BeanProperty property) |
JsonSerializer<?> |
SimpleSerializers.findSerializer(SerializationConfig config,
JavaType type,
BeanDescription beanDesc,
BeanProperty property) |
JavaType |
SimpleAbstractTypeResolver.findTypeMapping(DeserializationConfig config,
JavaType type) |
JavaType |
SimpleAbstractTypeResolver.resolveAbstractType(DeserializationConfig config,
JavaType type) |
Modifier and Type | Field and Description |
---|---|
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 |
BeanPropertyWriter._declaredType
Type property is declared to have, either in class definition
or associated annotations.
|
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.
|
Modifier and Type | Method and Description |
---|---|
protected static <T extends JavaType> |
BasicSerializerFactory.modifySecondaryTypesByAnnotation(SerializationConfig config,
Annotated a,
T type) |
protected <T extends JavaType> |
BasicSerializerFactory.modifyTypeByAnnotation(SerializationConfig config,
Annotated a,
T type)
Helper method used to encapsulate details of annotation-based type
coercion
|
Modifier and Type | Method and Description |
---|---|
protected JavaType |
PropertyBuilder.findSerializationType(Annotated a,
boolean useStaticTyping,
JavaType declaredType)
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() |
JavaType |
BeanPropertyWriter.getType() |
Modifier and Type | Method and Description |
---|---|
protected JsonSerializer<Object> |
StdSerializerProvider._createAndCacheUntypedSerializer(JavaType type,
BeanProperty property) |
protected JsonSerializer<Object> |
StdSerializerProvider._createUntypedSerializer(JavaType type,
BeanProperty property) |
protected void |
StdSerializerProvider._reportIncompatibleRootType(Object value,
JavaType rootType) |
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.
|
JsonSerializer<?> |
BasicSerializerFactory.buildContainerSerializer(SerializationConfig config,
JavaType type,
BasicBeanDescription beanDesc,
BeanProperty property,
boolean staticTyping) |
protected JsonSerializer<?> |
BasicSerializerFactory.buildEnumMapSerializer(SerializationConfig config,
JavaType type,
BasicBeanDescription beanDesc,
BeanProperty property,
boolean staticTyping,
TypeSerializer elementTypeSerializer,
JsonSerializer<Object> elementValueSerializer)
Helper method that handles configuration details when constructing serializers for
EnumMap types. |
protected JsonSerializer<?> |
BasicSerializerFactory.buildEnumSetSerializer(SerializationConfig config,
JavaType type,
BasicBeanDescription beanDesc,
BeanProperty property,
boolean staticTyping,
TypeSerializer elementTypeSerializer,
JsonSerializer<Object> elementValueSerializer) |
protected JsonSerializer<?> |
BasicSerializerFactory.buildIterableSerializer(SerializationConfig config,
JavaType type,
BasicBeanDescription beanDesc,
BeanProperty property,
boolean staticTyping) |
protected JsonSerializer<?> |
BasicSerializerFactory.buildIteratorSerializer(SerializationConfig config,
JavaType type,
BasicBeanDescription beanDesc,
BeanProperty property,
boolean staticTyping) |
protected BeanPropertyWriter |
PropertyBuilder.buildWriter(String name,
JavaType declaredType,
JsonSerializer<Object> ser,
TypeSerializer typeSer,
TypeSerializer contentTypeSer,
AnnotatedMember am,
boolean defaultUseStaticTyping) |
JsonSerializer<Object> |
BeanSerializerFactory.createKeySerializer(SerializationConfig config,
JavaType type,
BeanProperty property) |
JsonSerializer<Object> |
CustomSerializerFactory.createSerializer(SerializationConfig config,
JavaType type,
BeanProperty property) |
JsonSerializer<Object> |
BeanSerializerFactory.createSerializer(SerializationConfig config,
JavaType origType,
BeanProperty property)
Main serializer constructor method.
|
abstract JsonSerializer<Object> |
BasicSerializerFactory.createSerializer(SerializationConfig config,
JavaType type,
BeanProperty property) |
TypeSerializer |
BasicSerializerFactory.createTypeSerializer(SerializationConfig config,
JavaType baseType,
BeanProperty property)
Method called to construct a type serializer for values with given declared
base type.
|
JsonSerializer<Object> |
BeanSerializerFactory.findBeanSerializer(SerializationConfig config,
JavaType type,
BasicBeanDescription beanDesc,
BeanProperty property)
Method that will try to construct a
BeanSerializer for
given class. |
JsonSerializer<Object> |
StdSerializerProvider.findKeySerializer(JavaType keyType,
BeanProperty property) |
TypeSerializer |
BeanSerializerFactory.findPropertyContentTypeSerializer(JavaType containerType,
SerializationConfig config,
AnnotatedMember accessor,
BeanProperty property)
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 accessor,
BeanProperty property)
Method called to create a type information serializer for values of given
non-container property
if one is needed.
|
protected JavaType |
PropertyBuilder.findSerializationType(Annotated a,
boolean useStaticTyping,
JavaType declaredType)
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).
|
JsonSerializer<?> |
BasicSerializerFactory.findSerializerByAddonType(SerializationConfig config,
JavaType javaType,
BasicBeanDescription beanDesc,
BeanProperty property,
boolean staticTyping)
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,
BeanProperty property,
boolean staticTyping)
Method that will use fast lookup (and identity comparison) methods to
see if we know serializer to use for given type.
|
JsonSerializer<?> |
BasicSerializerFactory.findSerializerByPrimaryType(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc,
BeanProperty property,
boolean staticTyping)
Method for checking if we can determine serializer to use based on set of
known primary types, checking for set of known base types (exact matches
having been compared against with
findSerializerByLookup ). |
JsonSerializer<Object> |
StdSerializerProvider.findTypedValueSerializer(JavaType valueType,
boolean cache,
BeanProperty property) |
JsonSerializer<Object> |
StdSerializerProvider.findValueSerializer(JavaType valueType,
BeanProperty property)
This variant was added in 1.5, to allow for efficient access using full
structured types, not just classes.
|
protected Object |
PropertyBuilder.getContainerValueChecker(String propertyName,
JavaType propertyType)
Helper method called to see if we need a comparator Object to check if values
of a container (Collection, array) property should be suppressed.
|
protected Object |
PropertyBuilder.getEmptyValueChecker(String propertyName,
JavaType propertyType)
Helper method called to see if we need a comparator Object to check if values
of specified type are consider empty.
|
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
|
Constructor and Description |
---|
BeanPropertyWriter(AnnotatedMember member,
Annotations contextAnnotations,
SerializedString name,
JavaType declaredType,
JsonSerializer<Object> ser,
TypeSerializer typeSer,
JavaType serType,
Method m,
Field f,
boolean suppressNulls,
Object suppressableValue) |
BeanPropertyWriter(AnnotatedMember member,
Annotations contextAnnotations,
String name,
JavaType declaredType,
JsonSerializer<Object> ser,
TypeSerializer typeSer,
JavaType serType,
Method m,
Field f,
boolean suppressNulls,
Object suppressableValue) |
BeanSerializer(JavaType type,
BeanPropertyWriter[] properties,
BeanPropertyWriter[] filteredProperties,
AnyGetterWriter anyGetterWriter,
Object filterId) |
MapSerializer(HashSet<String> ignoredEntries,
JavaType valueType,
boolean valueTypeIsStatic,
TypeSerializer vts)
Deprecated.
Use variant that takes Key type and property information
|
MapSerializer(HashSet<String> ignoredEntries,
JavaType keyType,
JavaType valueType,
boolean valueTypeIsStatic,
TypeSerializer vts,
JsonSerializer<Object> keySerializer,
BeanProperty property)
Deprecated.
As of 1.8, use version that takes valueSerializer
|
MapSerializer(HashSet<String> ignoredEntries,
JavaType keyType,
JavaType valueType,
boolean valueTypeIsStatic,
TypeSerializer vts,
JsonSerializer<Object> keySerializer,
JsonSerializer<Object> valueSerializer,
BeanProperty property)
Deprecated.
|
SerializerBase(JavaType type)
Deprecated.
|
Modifier and Type | Field and Description |
---|---|
protected JavaType |
SerializerCache.TypeKey._type |
Modifier and Type | Method and Description |
---|---|
void |
SerializerCache.addAndResolveNonTypedSerializer(JavaType type,
JsonSerializer<Object> ser,
SerializerProvider provider) |
void |
SerializerCache.addTypedSerializer(JavaType type,
JsonSerializer<Object> ser)
Method called if none of lookups succeeded, and caller had to construct
a serializer.
|
PropertySerializerMap.SerializerAndMapResult |
PropertySerializerMap.findAndAddSerializer(JavaType type,
SerializerProvider provider,
BeanProperty property) |
void |
SerializerCache.TypeKey.resetTyped(JavaType type) |
void |
SerializerCache.TypeKey.resetUntyped(JavaType type) |
JsonSerializer<Object> |
SerializerCache.typedValueSerializer(JavaType type) |
JsonSerializer<Object> |
ReadOnlyClassToSerializerMap.typedValueSerializer(JavaType type) |
JsonSerializer<Object> |
SerializerCache.untypedValueSerializer(JavaType type) |
JsonSerializer<Object> |
ReadOnlyClassToSerializerMap.untypedValueSerializer(JavaType type) |
Constructor and Description |
---|
SerializerCache.TypeKey(JavaType key,
boolean typed) |
Modifier and Type | Field and Description |
---|---|
protected JavaType |
ObjectArraySerializer._elementType
Declared type of element entries
|
protected JavaType |
AsArraySerializerBase._elementType |
protected JavaType |
MapSerializer._keyType
Declared type of keys
|
protected JavaType |
MapSerializer._valueType
Declared type of contained values
|
protected JavaType |
EnumMapSerializer._valueType |
protected static JavaType |
MapSerializer.UNSPECIFIED_TYPE |
Modifier and Type | Method and Description |
---|---|
protected JsonSerializer<Object> |
ObjectArraySerializer._findAndAddDynamic(PropertySerializerMap map,
JavaType type,
SerializerProvider provider) |
protected JsonSerializer<Object> |
MapSerializer._findAndAddDynamic(PropertySerializerMap map,
JavaType type,
SerializerProvider provider) |
protected JsonSerializer<Object> |
AsArraySerializerBase._findAndAddDynamic(PropertySerializerMap map,
JavaType type,
SerializerProvider provider) |
static ContainerSerializerBase<?> |
StdContainerSerializers.collectionSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> valueSerializer) |
static MapSerializer |
MapSerializer.construct(String[] ignoredList,
JavaType mapType,
boolean staticValueType,
TypeSerializer vts,
BeanProperty property)
Deprecated.
As of 1.8; use the variant with more arguments
|
static MapSerializer |
MapSerializer.construct(String[] ignoredList,
JavaType mapType,
boolean staticValueType,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> keySerializer,
JsonSerializer<Object> valueSerializer) |
static JsonSerializer<?> |
StdContainerSerializers.enumSetSerializer(JavaType enumType,
BeanProperty property) |
static JsonSerializer<Object> |
StdKeySerializers.getStdKeySerializer(JavaType keyType) |
static ContainerSerializerBase<?> |
StdContainerSerializers.indexedListSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> valueSerializer) |
protected boolean |
JsonValueSerializer.isNaturalTypeWithStdHandling(JavaType type,
JsonSerializer<?> ser) |
static ContainerSerializerBase<?> |
StdContainerSerializers.iterableSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property) |
static ContainerSerializerBase<?> |
StdContainerSerializers.iteratorSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property) |
Constructor and Description |
---|
AsArraySerializerBase(Class<?> cls,
JavaType et,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property)
Deprecated.
since 1.8
|
AsArraySerializerBase(Class<?> cls,
JavaType et,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> elementSerializer) |
BeanSerializerBase(JavaType type,
BeanPropertyWriter[] properties,
BeanPropertyWriter[] filteredProperties,
AnyGetterWriter anyGetterWriter,
Object filterId) |
CollectionSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> valueSerializer) |
EnumMapSerializer(JavaType valueType,
boolean staticTyping,
EnumValues keyEnums,
TypeSerializer vts,
BeanProperty property)
Deprecated.
Since 1.8, use variant that takes value serializer
|
EnumMapSerializer(JavaType valueType,
boolean staticTyping,
EnumValues keyEnums,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> valueSerializer) |
EnumSetSerializer(JavaType elemType,
BeanProperty property) |
IterableSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property) |
MapSerializer(HashSet<String> ignoredEntries,
JavaType keyType,
JavaType valueType,
boolean valueTypeIsStatic,
TypeSerializer vts,
JsonSerializer<Object> keySerializer,
JsonSerializer<Object> valueSerializer,
BeanProperty property) |
ObjectArraySerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property)
Deprecated.
since 1.8
|
ObjectArraySerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> elementSerializer) |
SerializerBase(JavaType type) |
StdContainerSerializers.IndexedListSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> valueSerializer) |
StdContainerSerializers.IteratorSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property) |
Modifier and Type | Class and Description |
---|---|
class |
ArrayType
Array types represent Java arrays, both primitive and object valued.
|
class |
CollectionLikeType
Type that represents things that act similar to
Collection ;
but may or may not be instances of that interface. |
class |
CollectionType
Type that represents Java Collection types (Lists, Sets).
|
class |
MapLikeType
Type that represents Map-like types; things that consist of key/value pairs but that
do not necessarily implement
Map , but that do not have enough
introspection functionality to allow for some level of generic handling. |
class |
MapType
Type that represents "true" Java Map types.
|
class |
SimpleType
Simple types are defined as anything other than one of recognized
container types (arrays, Collections, Maps).
|
class |
TypeBase |
Modifier and Type | Field and Description |
---|---|
protected JavaType |
ArrayType._componentType
Type of elements in the array.
|
protected JavaType |
TypeBindings._contextType
Context type used for resolving all types, if specified.
|
protected JavaType |
CollectionLikeType._elementType
Type of elements in collection
|
protected JavaType |
MapLikeType._keyType
Type of keys of Map.
|
protected JavaType[] |
SimpleType._typeParameters
Generic type arguments for this type.
|
protected JavaType |
MapLikeType._valueType
Type of values of Map.
|
static JavaType |
TypeBindings.UNBOUND
Marker to use for (temporarily) unbound references.
|
Modifier and Type | Field and Description |
---|---|
protected Map<String,JavaType> |
TypeBindings._bindings
Lazily-instantiated bindings of resolved type parameters
|
Modifier and Type | Method and Description |
---|---|
JavaType |
TypeFactory._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 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.
|
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 |
MapLikeType._narrow(Class<?> subclass) |
protected JavaType |
CollectionType._narrow(Class<?> subclass) |
protected JavaType |
CollectionLikeType._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._resolveVariableViaSubTypes(HierarchicType leafType,
String variableName,
TypeBindings bindings) |
protected JavaType |
TypeFactory._unknownType() |
static JavaType |
TypeFactory.arrayType(Class<?> elementType)
Deprecated.
|
static JavaType |
TypeFactory.arrayType(JavaType elementType)
Deprecated.
|
static JavaType |
TypeFactory.collectionType(Class<? extends Collection> collectionType,
Class<?> elementType)
Deprecated.
|
static JavaType |
TypeFactory.collectionType(Class<? extends Collection> collectionType,
JavaType elementType)
Deprecated.
|
JavaType |
TypeFactory.constructFromCanonical(String canonical)
Factory method for constructing a
JavaType out of its canonical
representation (see toCanonical() ). |
JavaType |
TypeFactory.constructParametricType(Class<?> parametrized,
Class<?>... parameterClasses)
Factory method for constructing
JavaType that
represents a parameterized type. |
JavaType |
TypeFactory.constructParametricType(Class<?> parametrized,
JavaType... parameterTypes)
Factory method for constructing
JavaType that
represents a parameterized type. |
JavaType |
TypeFactory.constructSimpleType(Class<?> rawType,
JavaType[] parameterTypes)
Method for constructing a type instance with specified parameterization.
|
JavaType |
TypeFactory.constructSpecializedType(JavaType baseType,
Class<?> subclass)
Factory method for creating a subtype of given base type, as defined
by specified subclass; but retaining generic type information if any.
|
JavaType |
TypeFactory.constructType(Type type) |
JavaType |
TypeFactory.constructType(Type type,
Class<?> context) |
JavaType |
TypeFactory.constructType(Type type,
JavaType context) |
JavaType |
TypeFactory.constructType(TypeReference<?> typeRef) |
JavaType |
TypeFactory.constructType(Type type,
TypeBindings bindings) |
JavaType |
SimpleType.containedType(int index) |
JavaType |
MapLikeType.containedType(int index) |
JavaType |
CollectionLikeType.containedType(int index) |
JavaType |
ArrayType.containedType(int index) |
static JavaType |
TypeFactory.fastSimpleType(Class<?> cls)
Deprecated.
|
static JavaType[] |
TypeFactory.findParameterTypes(Class<?> clz,
Class<?> expType)
Deprecated.
|
static JavaType[] |
TypeFactory.findParameterTypes(Class<?> clz,
Class<?> expType,
TypeBindings bindings)
Deprecated.
|
static JavaType[] |
TypeFactory.findParameterTypes(JavaType type,
Class<?> expType)
Deprecated.
|
JavaType |
TypeBindings.findType(String name) |
JavaType[] |
TypeFactory.findTypeParameters(Class<?> clz,
Class<?> expType) |
JavaType[] |
TypeFactory.findTypeParameters(Class<?> clz,
Class<?> expType,
TypeBindings bindings) |
JavaType[] |
TypeFactory.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 JavaType |
TypeFactory.fromCanonical(String canonical) |
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 |
MapLikeType.getContentType() |
JavaType |
CollectionLikeType.getContentType() |
JavaType |
ArrayType.getContentType() |
JavaType |
MapLikeType.getKeyType() |
static JavaType |
TypeFactory.mapType(Class<? extends Map> mapClass,
Class<?> keyType,
Class<?> valueType)
Deprecated.
|
static JavaType |
TypeFactory.mapType(Class<? extends Map> mapType,
JavaType keyType,
JavaType valueType)
Deprecated.
|
abstract JavaType |
TypeModifier.modifyType(JavaType type,
Type jdkType,
TypeBindings context,
TypeFactory typeFactory)
Method called to let modifier change constructed type definition.
|
JavaType |
SimpleType.narrowContentsBy(Class<?> subclass) |
JavaType |
MapType.narrowContentsBy(Class<?> contentClass) |
JavaType |
MapLikeType.narrowContentsBy(Class<?> contentClass) |
JavaType |
CollectionType.narrowContentsBy(Class<?> contentClass) |
JavaType |
CollectionLikeType.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) |
JavaType |
MapLikeType.narrowKey(Class<?> keySubclass) |
static JavaType |
TypeFactory.parametricType(Class<?> parametrized,
Class<?>... parameterClasses)
Deprecated.
|
static JavaType |
TypeFactory.parametricType(Class<?> parametrized,
JavaType... parameterTypes)
Deprecated.
|
JavaType |
TypeParser.parse(String canonical) |
protected JavaType |
TypeParser.parseType(org.codehaus.jackson.map.type.TypeParser.MyTokenizer tokens) |
JavaType |
TypeBindings.resolveType(Class<?> cls) |
JavaType |
TypeBindings.resolveType(Type type) |
static JavaType |
TypeFactory.specialize(JavaType baseType,
Class<?> subclass)
Deprecated.
|
static JavaType |
TypeFactory.type(Type t)
Deprecated.
|
static JavaType |
TypeFactory.type(Type type,
Class<?> context)
Deprecated.
|
static JavaType |
TypeFactory.type(Type type,
JavaType context)
Deprecated.
|
static JavaType |
TypeFactory.type(TypeReference<?> ref)
Deprecated.
|
static JavaType |
TypeFactory.type(Type type,
TypeBindings bindings)
Deprecated.
|
JavaType[] |
TypeBindings.typesAsArray() |
JavaType |
TypeFactory.uncheckedSimpleType(Class<?> cls)
Method that will force construction of a simple type, without trying to
check for more specialized types.
|
static JavaType |
TypeFactory.unknownType()
Method for constructing a marker type that indicates missing generic
type information, which is handled same as simple type for
java.lang.Object . |
JavaType |
SimpleType.widenContentsBy(Class<?> subclass) |
JavaType |
MapType.widenContentsBy(Class<?> contentClass) |
JavaType |
MapLikeType.widenContentsBy(Class<?> contentClass) |
JavaType |
CollectionType.widenContentsBy(Class<?> contentClass) |
JavaType |
CollectionLikeType.widenContentsBy(Class<?> contentClass) |
JavaType |
ArrayType.widenContentsBy(Class<?> contentClass) |
JavaType |
MapType.widenKey(Class<?> keySubclass) |
JavaType |
MapLikeType.widenKey(Class<?> keySubclass) |
JavaType |
SimpleType.withContentTypeHandler(Object h) |
Modifier and Type | Method and Description |
---|---|
protected List<JavaType> |
TypeParser.parseTypes(org.codehaus.jackson.map.type.TypeParser.MyTokenizer tokens) |
Modifier and Type | Method and Description |
---|---|
void |
TypeBindings.addBinding(String name,
JavaType type) |
static JavaType |
TypeFactory.arrayType(JavaType elementType)
Deprecated.
|
static JavaType |
TypeFactory.collectionType(Class<? extends Collection> collectionType,
JavaType elementType)
Deprecated.
|
static CollectionType |
CollectionType.construct(Class<?> rawType,
JavaType elemT) |
static CollectionLikeType |
CollectionLikeType.construct(Class<?> rawType,
JavaType elemT) |
static MapType |
MapType.construct(Class<?> rawType,
JavaType keyT,
JavaType valueT) |
static MapLikeType |
MapLikeType.construct(Class<?> rawType,
JavaType keyT,
JavaType valueT) |
static ArrayType |
ArrayType.construct(JavaType componentType)
Deprecated.
Since 1.9, if you must directly instantiate,
call method that takes handlers
|
static ArrayType |
ArrayType.construct(JavaType componentType,
Object valueHandler,
Object typeHandler) |
ArrayType |
TypeFactory.constructArrayType(JavaType elementType)
Method for constructing an
ArrayType . |
CollectionLikeType |
TypeFactory.constructCollectionLikeType(Class<?> collectionClass,
JavaType elementType)
Method for constructing a
CollectionLikeType . |
CollectionType |
TypeFactory.constructCollectionType(Class<? extends Collection> collectionClass,
JavaType elementType)
Method for constructing a
CollectionType . |
MapLikeType |
TypeFactory.constructMapLikeType(Class<?> mapClass,
JavaType keyType,
JavaType valueType)
Method for constructing a
MapLikeType instance |
MapType |
TypeFactory.constructMapType(Class<? extends Map> mapClass,
JavaType keyType,
JavaType valueType)
Method for constructing a
MapType instance |
JavaType |
TypeFactory.constructParametricType(Class<?> parametrized,
JavaType... parameterTypes)
Factory method for constructing
JavaType that
represents a parameterized type. |
JavaType |
TypeFactory.constructSimpleType(Class<?> rawType,
JavaType[] parameterTypes)
Method for constructing a type instance with specified parameterization.
|
JavaType |
TypeFactory.constructSpecializedType(JavaType baseType,
Class<?> subclass)
Factory method for creating a subtype of given base type, as defined
by specified subclass; but retaining generic type information if any.
|
JavaType |
TypeFactory.constructType(Type type,
JavaType context) |
static JavaType[] |
TypeFactory.findParameterTypes(JavaType type,
Class<?> expType)
Deprecated.
|
JavaType[] |
TypeFactory.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 JavaType |
TypeFactory.mapType(Class<? extends Map> mapType,
JavaType keyType,
JavaType valueType)
Deprecated.
|
abstract JavaType |
TypeModifier.modifyType(JavaType type,
Type jdkType,
TypeBindings context,
TypeFactory typeFactory)
Method called to let modifier change constructed type definition.
|
static JavaType |
TypeFactory.parametricType(Class<?> parametrized,
JavaType... parameterTypes)
Deprecated.
|
static JavaType |
TypeFactory.specialize(JavaType baseType,
Class<?> subclass)
Deprecated.
|
static JavaType |
TypeFactory.type(Type type,
JavaType context)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
protected JavaType |
TypeFactory._fromParameterizedClass(Class<?> clz,
List<JavaType> paramTypes)
Method used by
TypeParser when generics-aware version
is constructed. |
Constructor and Description |
---|
CollectionLikeType(Class<?> collT,
JavaType elemT)
Deprecated.
|
CollectionLikeType(Class<?> collT,
JavaType elemT,
Object valueHandler,
Object typeHandler) |
MapLikeType(Class<?> mapType,
JavaType keyT,
JavaType valueT)
Deprecated.
|
MapLikeType(Class<?> mapType,
JavaType keyT,
JavaType valueT,
Object valueHandler,
Object typeHandler) |
SimpleType(Class<?> cls,
String[] typeNames,
JavaType[] typeParams)
Deprecated.
|
SimpleType(Class<?> cls,
String[] typeNames,
JavaType[] typeParams,
Object valueHandler,
Object typeHandler) |
TypeBindings(TypeFactory typeFactory,
JavaType type) |
Modifier and Type | Field and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
JavaType |
JSONWrappedObject.getSerializationType() |
JavaType |
JSONPObject.getSerializationType() |
Modifier and Type | Method and Description |
---|---|
SerializedString |
RootNameLookup.findRootName(JavaType rootType,
MapperConfig<?> config) |
Constructor and Description |
---|
JSONPObject(String function,
Object value,
JavaType asType) |
JSONWrappedObject(String prefix,
String suffix,
Object value,
JavaType asType) |
Modifier and Type | Method and Description |
---|---|
JavaType |
AbstractTypeMaterializer.resolveAbstractType(DeserializationConfig config,
JavaType type) |
Modifier and Type | Method and Description |
---|---|
JavaType |
AbstractTypeMaterializer.resolveAbstractType(DeserializationConfig config,
JavaType type) |
Modifier and Type | Method and Description |
---|---|
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.
|
abstract JavaType |
JavaType.widenContentsBy(Class<?> contentClass) |
abstract JavaType |
JavaType.withContentTypeHandler(Object h)
"Copy method" that will construct a new instance that is identical to
this instance, except that its content type will have specified
type handler assigned.
|
JavaType |
JavaType.withContentValueHandler(Object h) |
abstract JavaType |
JavaType.withTypeHandler(Object h)
"Copy method" that will construct a new instance that is identical to
this instance, except that it will have specified type handler assigned.
|
JavaType |
JavaType.withValueHandler(Object h) |
Modifier and Type | Field and Description |
---|---|
protected JavaType |
XmlAdapterJsonDeserializer._valueType |
protected static JavaType |
XmlAdapterJsonDeserializer.ADAPTER_TYPE |
Modifier and Type | Method and Description |
---|---|
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(MapperConfig<?> config,
AnnotatedMember am,
JavaType containerType) |
TypeResolverBuilder<?> |
JaxbAnnotationIntrospector.findPropertyTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType) |
TypeResolverBuilder<?> |
JaxbAnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |