|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
AbstractTypeResolver instance, to handle resolution of
abstract to concrete types (either by defaulting, or by materializing).
DeserializationProblemHandler
to be used for handling specific problems during deserialization.
ValueInjector instances, and add them to builder.
JsonToken.FIELD_NAME instead of String value).
JsonSerializer.handledType()
specifies (which MUST return a non-null class; and can NOT be Object, as a
sanity check).
TypeModifier instance, which can augment JavaType
instances constructed by TypeFactory.
ValueInstantiator to use when deserializing
instances of type beanType.
ValueInstantiators,
by adding ValueInstantiators object that gets called when
instantatiator is needed by a deserializer.
AnnotationMap).AnnotatedMethods, accessible by lookup.BeanPropertyWriter, but that will be used
for serializing JsonAnyGetter annotated
(Map) propertiesAnnotationIntrospector as the lowest
priority introspector, chained with existing introspector(s) and called
as fallback for cases not otherwise handled.
ArrayNode
Construction is done using registered JsonNodeFactory.
Collection
and array types.JsonTypeInfo.As.WRAPPER_ARRAY
inclusion mechanism.JsonTypeInfo.As.EXTERNAL_PROPERTY inclusion mechanism.JsonParser that can read contents
stored in this buffer.
JsonParser that can read contents
stored in this buffer.
JsonTypeInfo.As.PROPERTY
inclusion mechanism.JsonNode.isValueNode() returns true),
otherwise empty String.
JsonTypeInfo.As.WRAPPER_OBJECT
inclusion mechanism.JsonNode
implementations.BeanDescription implementation.Collection).Collection).ClassIntrospector to
help in constructing serializers and deserializers.BeanDeserializerBuilder.
BeanDeserializer.BeanDeserializerBuilder that
contains configuration.
JsonDeserializer for deserializing
intances.BeanDeserializerFactory
to participate in constructing BeanDeserializer instances.JsonFilter)
for filtering bean properties to serialize.SettableBeanProperty instances.BeanSerializer passing an instance of
"compatible enough" source serializer.
BeanSerializerBuilder to create an
instance
JsonSerializer for serializing
intances.Object.getClass() does not count);
as well as for "standard" JDK types.BeanSerializerFactory
to participate in constructing BeanSerializer instances.JsonNode.isBinary() returns true); or for Text Nodes
(ones for which JsonNode.textValue() returns non-null value),
to read decoded base64 data.
BinaryNode), let's add support for exposing
binary data here too.
BeanDeserializer, given all
information collected.
BeanSerializer instance with
all accumulated information.
Object[] (and subtypes, except for String).
List types that support efficient by-index access
BeanDeserializerBuilder.
Map types.
Calendar.PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy for details.
JsonNode.isNumber() would return true) AND its value fits
within Java's 32-bit signed integer type, int.
JsonNode.isNumber() would return true) AND its value fits
within Java's 64-bit signed integer type, long.
ValueInstantiator.createFromDouble(com.fasterxml.jackson.databind.DeserializationContext, double)).
ValueInstantiator.createFromDouble(com.fasterxml.jackson.databind.DeserializationContext, double)).
ValueInstantiator.createFromInt(com.fasterxml.jackson.databind.DeserializationContext, int)).
ValueInstantiator.createFromLong(com.fasterxml.jackson.databind.DeserializationContext, long)).
canCreateXxx method
returns true: that is, if there is any way that an instance could
be created.
BeanSerializerFactory with tentative set
of discovered properties.
JsonSerializers.TypeIdResolver implementation
that converts between fully-qualified
Java class names and (JSON) Strings.DeserializationProblemHandlers
instances from this mapper.
Collection instance, with typed contents.Collection;
but may or may not be instances of that interface.ObjectMapper class, as well
as convenience methods included in
JsonParsercom.fasterxml.jackson.databind).TypeResolverBuilder
and
TypeIdResolver.Modules
(which are registered using
ObjectMapper.registerModule(com.fasterxml.jackson.databind.Module).JsonNode implementations
Jackson uses for the Tree model.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).ObjectBuffer.completeAndClearBuffer(Object[], int), to allow
for constructing explicitly typed result array.
MapperConfig implementations must implement.JsonParser feature for
JsonFactory instance this object mapper uses.
JsonGenerator feature for
JsonFactory instance this object mapper uses.
BeanSerializerBase
with the initial information based on standard settings for the type
for which serializer is being built.
BeanSerializerBase
with the initial information based on standard settings for the type
for which serializer is being built.
SettableAnyProperty
for handling unknown bean properties, given a method that
has been designated as such setter.
ArrayType.
ArrayType.
BeanDeserializerBuilder
which is used to accumulate information needed to create deserializer
instance.
CollectionLikeType.
CollectionLikeType.
CollectionType.
CollectionType.
JavaType out of its canonical
representation (see ResolvedType.toCanonical()).
MapLikeType instance
MapLikeType instance
MapType instance
MapType instance
JavaType that
represents a parameterized type.
JavaType that
represents a parameterized type.
POJOPropertiesCollector instance
to use; override is needed if a custom sub-class is to be used.
JavaType for given
raw class.
JavaType for given
type reference
This is a simple short-cut for:
JavaType out of given
type (typically java.lang.Class), but without explicit
context.
JavaType for given JDK
type (usually Class)
EnumResolver.constructUsingToString(java.lang.Class)
if static type of enum is not known.
AnnotatedClass.construct(java.lang.Class, com.fasterxml.jackson.databind.AnnotationIntrospector, com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver), but that will NOT include
information from supertypes; only class itself and any direct
mix-ins it may have.
Collections (Lists, Sets
etc) and Maps and iterable things
(Iterators).JsonDeserializers can implement to get a callback
that can be used to create contextual (context-dependent) instances of
deserializer to use for handling properties of supported type.KeyDeserializers can implement to get a callback
that can be used to create contextual instances of key deserializer to use for
handling Map keys of supported type.JsonSerializers can implement to get a callback
that can be used to create contextual instances of serializer to use for
handling properties of supported type.DeserializerCaches call to create a new
deserializer for types other than Collections, Maps, arrays and
enums.
DeserializationContext
for deserializing a single root value.
DeserializationContext
for deserializing a single root value.
Enum types.
JsonToken.FIELD_NAME) for Map that has specified declared
key type, and is for specified property (or, if property is null, as root value)
Date values.Date, SQL version is easier
to deal with: mostly because it is more limited.Timestamp values.ObjectMapper
instances.
DeserializationContext implementation that adds
extended API for ObjectMapper (and ObjectReader)
to call, as well as implements certain parts that base class
has left abstract.DeserializerCache, given factory.
Map keys,
based on SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS
value (and if using textual representation, configured date format)
Map keys,
based on SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS
value (and if using textual representation, configured date format)
SerializationConfig settings to determine expected serialization
behavior.
SerializationConfig settings to determine expected serialization
behavior.
ObjectMapper:
adds methods only exposed to ObjectMapper,
as well as constructors.DeserializationConfig object owner by
ObjectMapper) to get calledn when a potentially
recoverable problem is encountered during deserialization
process.SettableBeanProperty.deserializeAndSet(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, java.lang.Object) implementations.
JsonDeserializer.deserialize(JsonParser, DeserializationContext)),
which takes in initialized value instance, to be
configured and/or populated by deserializer.
Map key from JSON property name.
ObjectMapper,
DeserializationContext)
and classes that construct deserializers
(DeserializerFactory).DeserializationContext
to construct actual
JsonDeserializer instances (which are then cached by
context and/or dedicated cache).DeserializerFactory.Deserializers implementation that implements all methods but provides
no deserializers.SettableBeanProperty.deserializeAndSet(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, java.lang.Object) that returns
either return value of setter method called (if one is),
or null to indicate that no return value is available.
DeserializationConfig features.
DeserializationConfig features.
DeserializationConfig features.
DeserializationConfig features.
DeserializationConfig features.
JsonTypeInfo) will have
additional embedded type information.
MapperConfig features.
DeserializationConfig features.
DeserializationConfig features.
DeserializationConfig feature.
DeserializationConfig features.
JsonTypeInfo).
JsonTypeInfo) --
using "As.PROPERTY" inclusion mechanism and specified property name
to use for inclusion (default being "@class" since default type information
always uses class name as type identifier)
EnumMap values.EnumMaps.Enum types.EnumSets.JsonTypeInfo.As.EXTERNAL_PROPERTY).JsonGenerationException if its FailingSerializer.serialize(java.lang.Object, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider)
gets invoked.BeanPropertyWriter that will filter out properties
that are not to be included in currently active JsonView.BeanPropertyFilter
that match given ids.JsonAnyGetter.
JsonAnySetter.
BeanDeserializer to resolve back reference
part of managed references.
BeanDeserializerFactory to properly link
managed- and back-reference pairs.
BeanSerializer for
given class.
Collection (List, Set etc) type.
Collection but does not implement it).
Collection,
but does not implement it).
Collection type.
Collection, array or
Map property.
Collection, array or Map property.
Enum type.
EnumSet, without having
access to its declaration.
EnumSet, without having
access to its declaration.
BeanPropertyFilter that has specified id.
valueId to
inject as value of specified property during deserialization, passing
POJO instance in which value will be injected if it is available
(will be available when injected via field or setter; not available
when injected via constructor or factory method argument).
JsonValue annotation,
if any.
Map property.
Map.
Map property.
Map type.
Map but does not implement it).
Map,
but does not implement it).
Map type.
JsonNode.findValue(java.lang.String), but that will return a
"missing node" instead of null if no field is found.
JsonSerializable)
determines the serializer to use.
findSerializerByLookup).
BeanDeserializerFactory to see if there might be a standard
deserializer registered for given type.
ValueInstantiator to use for given
type (class): return value can either be an instance of
instantiator, or class of instantiator to create.
ValueInstantiator to use for creating
instances of specified type during deserialization.
JsonNode.findValues(java.lang.String), but will additionally convert
values into Strings, calling JsonNode.asText().
SerializerProvider.findValueSerializer(Class,BeanProperty), but takes
full generics-aware type instead of raw class.
AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject[], boolean) on
the underlying annotated element.
DeserializerCache.cachedDeserializersCount()).
JavaType.narrowBy(java.lang.Class), called by
internal framework in cases where compatibility checks
are to be skipped.
ObjectMapper and ObjectWriter
to generate JSON schema for
given type.
SerializerProvider using this as
the key.
SerializerProvider using this as
the key.
AnnotationIntrospector configured
to introspect annotation values used for configuration.
AnnotationIntrospector configured
to introspect annotation values used for configuration.
DeserializationConfig object
that defines configuration settings for deserialization.
ValueInstantiator.canCreateFromObjectWith() returns true).
JsonFactory that this
mapper uses if it needs to construct JsonParsers
and/or JsonGenerators.
toString will give external property
name.
Locale to use
for formatting, unless overridden by local annotations.
ObjectMapper
that implements this context.
JsonNodeFactory
that this mapper will use when directly constructing
root JsonNode instances for Trees.
JsonToken.VALUE_NULL).
ObjectMapper that provided this context.
BeanDeserializer have
been collected.
SerializationConfig
object that defines configuration settings for serialization.
TimeZone to use
for formatting, unless overridden by local annotations.
TypeFactory that is currently configured
by the context.
TypeFactory instance.
SerializerFactory
instances are able to construct a serializer.
JsonSerializers, JsonDeserializers, various type
handlers) of specific types.TokenBuffer
(as field entries, name and value).
DeserializationProblemHandlers
of an unrecognized property.
MappingIterator.next() but one that may throw checked
exceptions from Jackson due to invalid input.
Class (and/or various Type subtypes)
that is used as part of single-path extends/implements chain to express
specific relationship between one subtype and one supertype.LinkedList
that can not}.Lists that contains Strings and are random-accessible.InetAddress.AnnotationIntrospector as the highest
priority introspector (will be chained with existing introspector(s) which
will be used as fallbacks for cases this introspector does not handle)
ObjectNode, appending it at the end
of this array, and returning the newly created node
(note: NOT 'this' array)
BasicSerializerFactory, this factory is stateless, and
thus a single shared global (== singleton) instance can be used
without thread-safety issues.
JsonNode.isNumber() returns true).
JacksonAnnotationsInside
are considered bundles.
BeanUtil.isCglibGetCallbacks(com.fasterxml.jackson.databind.introspect.AnnotatedMethod), need to suppress
a cyclic reference to resolve [JACKSON-103]
int.
long.
Collection or just something that acts
like one.
Collection or just something that acts
like one.
JsonNode.elements(); implemented so that
convenience "for-each" loop can be used for looping over elements
of JSON Array constructs.
AnnotationIntrospector implementation that handles standard
Jackson annotations.JavaType values.JsonLocation, we should be able to just implement
ValueInstantiator (not that explicit one would be very
hard but...)TokenBuffer.ObjectMapper (and
other chained JsonDeserializers too) to deserialize Objects of
arbitrary types from JSON, using provided JsonParser.JsonNode from any
JSON content, using appropriate JsonNode type.JsonPOJOBuilder annotation instance.JsonGenerator
(and SerializerProvider if necessary).JsonSerialize.include() property
to define which properties
of Java Beans are to be included in serializationJsonSerialize.typing() property
to define whether type detection is based on dynamic runtime
type (DYNAMIC) or declared type (STATIC).ObjectMapper (and
other chained JsonSerializers too) to serialize Objects of
arbitrary types into JSON, using provided JsonGenerator.TypeIdResolver)
to be used by
TypeSerializers
and TypeDeserializers
for converting between java types and type id included in JSON content.ValueInstantiator to use
for creating instances of specified type.JsonValue annotation to
indicate that serialization should be done by calling the method
annotated, and serializing result it returns.Map instance, with typed contents.Map, but that do not have enough
introspection functionality to allow for some level of generic handling.ObjectMapper, and accessible (but not changeable)
via ObjectReader and ObjectWriter (as well as
through various convenience methods through context objects).ObjectMapper when binding sequence of
objects.JsonFactory that will create a proper
ObjectCodec to allow seamless conversions between
Json content and Java objects (POJOs).Methods and Constructors)
in Maps.BeanDeserializerFactory after constructing default
bean deserializer instance with properties collected and ordered earlier.
BeanSerializerFactory after constructing default
bean serializer instance with properties collected and ordered earlier.
ObjectMapper
to provide a well-defined set of extensions to default functionality; such as
support for new data types.Serializers array (which by definition
is stateless and reusable)
AnnotationIntrospector.Number.class, we can just rely on type
mappings that plain JsonParser.getNumberValue() returns.Doubles
(and primitive doubles)Integers
(and primitive ints)NumberSerializers.IntegerSerializer, but will not cast to Integer:
instead, cast is to Number, and conversion is
by calling Number.intValue().Numbers (custom types).JsonNode.isNumber()),
returns native type that node uses to store the numeric value;
otherwise returns null.
JsonNode.isNumber() returns true); otherwise
returns null
Object[]).JsonIdentityInfo annotation or its
custom alternativesSettableBeanProperty implementation used
for virtual property that represents Object Id that is used
for some POJO types (or properties).JsonFactory as necessary, use
SerializerProvider as its
SerializerProvider, and
BeanSerializerFactory as its
SerializerFactory.
JsonFactory
for constructing necessary JsonParsers and/or
JsonGenerators.
JsonFactory
for constructing necessary JsonParsers and/or
JsonGenerators, and uses given providers for accessing
serializers and deserializers.
TypeResolverBuilder that provides type resolver builders
used with so-called "default typing"
(see ObjectMapper.enableDefaultTyping() for details).ObjectMapper.enableDefaultTyping()
to specify what kind of types (classes) default typing should
be used for.ObjectNode
Construction is done using registered JsonNodeFactory.
ObjectMapper for initial instantiation
ObjectMapper for initial instantiation
BeanSerializerFactory with set of properties
to serialize, in default ordering (based on defaults as well as
possible type annotations).
MapperConfig.getDateFormat()).
JsonNode.get(String), except
that instead of returning null if no such value exists (due
to this node not being an object, or object not having value
for the specified field),
a "missing node" (node that returns true for
JsonNode.isMissingNode()) will be returned.
JsonNode.get(int), except
that instead of returning null if no such element exists (due
to index being out of range, or this node not being an array),
a "missing node" (node that returns true for
JsonNode.isMissingNode()) will be returned.
ObjectMapper).BeanDeserializerBase.creatorProperties()
BeanSerializerFactory that is used to
construct BeanPropertyWriter instances.PropertyNamingStrategy that translates typical camel case Java
property names to lower case JSON element names, separated by
underscores.PropertyValues.BasicDeserializerFactory
to register deserializers this class provides.
BasicSerializerFactory to access
all serializers this class provides.
ObjectReader with
default settings.
ObjectReader with
specified feature enabled (compared to settings that this
mapper instance has).
ObjectReader with
specified features enabled (compared to settings that this
mapper instance has).
ObjectReader that will
read or update instances of specified type
ObjectReader that will
read or update instances of specified type
ObjectReader that will
read or update instances of specified type
ObjectReader that will
use specified JsonNodeFactory for constructing JSON trees.
ObjectReader that will
pass specific schema object to JsonParser used for
reading content.
ObjectReader that will
use specified injectable values.
ObjectReader that will
update given Object (usually Bean, but can be a Collection or Map
as well, but NOT an array) with JSON data.
ObjectReader that will
deserialize objects using specified JSON View (filter).
JsonNode instances.
JsonNode instances.
JsonNode instances.
JsonNode instances.
JsonNode instances.
JsonNode instances.
JsonNode instances.
Boolean).
ObjectMapper.readValues(JsonParser, ResolvedType).
ObjectReader.readValue(JsonParser, ResolvedType).
ObjectMapper.readValues(JsonParser, ResolvedType).
ObjectReader.readValues(JsonParser, ResolvedType).
ObjectMapper
this is an alternative to using annotations in super type to indicate subtypes.
ObjectMapper
this is an alternative to using annotations in super type to indicate subtypes.
JsonIgnoreType annotation but
can be supplied by module-provided introspectors too.
SerializerProvider,
but before being used.SerializerProvider has registered
the serializer, but before it has returned it to the caller.
ResolvableSerializer to be able to
properly handle cyclic type references.
DeserializationContext.leaseObjectBuffer().
NameTransformer.transform(java.lang.String) of this object.
JsonMappingExceptionJsonSerializable.BeanPropertyWriter instances.
BeanPropertyWriter instances.
JsonGenerator.
BeanSerializer to let filter decide what to do with
given bean property value: the usual choices are to either filter out (i.e.
BeanPropertyFilter that needs to be called to determine
which properties are to be serialized (and possibly how)
SerializerProvider
to obtain actual
JsonSerializer instances from multiple distinct factories.SerializerFactory implementations.Class to instantiate (with default constructor),
or an uninitialized serializer instance.
ObjectMapper and
JsonSerializers to obtain serializers capable of serializing
instances of specific types; as well as the default implementation
of the functionality.Serializers implementation that implements all methods but provides
no serializers.ObjectMapper and ObjectWriter
for serializing given value, using serializers that
this provider has access to (via caching and/or creating new serializers
as need be).
ObjectMapper and ObjectWriter
for serializing given value (assumed to be of specified root type,
instead of runtime type of value),
using serializers that
this provider has access to (via caching and/or creating new serializers
as need be),
AnnotationIntrospector used by this
mapper instance for both serialization and deserialization
DateFormat to use when serializing time
values as Strings, and deserializing from JSON Strings.
HandlerInstantiator to use for creating
instances of handlers (such as serializers, deserializers, type and type
id resolvers), given a class.
InjectableValues which used to find
values to inject.
mixinClass
should be "mixed in" with annotations that targetType
has (as if they were directly included on it!).
JsonNodeFactory to use for
constructing root level tree nodes (via method
ObjectMapper.createObjectNode()
SerializerFactory to use
for constructing (bean) serializers.
SerializerProvider to use
for handling caching of JsonSerializer instances.
TypeFactory instance
used by this mapper.
ObjectMapper when module is registered.
VisibilityCheckers, to change details of what kinds of
properties are auto-detected.
AbstractTypeResolver implementation, which is
based on static mapping from abstract super types into
sub types (concrete or abstract), but retaining generic
parameterization.BeanPropertyDefinition implementation that can
be wrapped around a AnnotatedMember that is a simple
accessor (getter) or mutator (setter, constructor parameter)
(or both, for fields).BeanPropertyFilter implementation that only uses property name
to determine whether to serialize property as is, or to filter it out.Deserializers which allows registration of
deserializers based on raw (type erased class).FilterProvider implementation that just stores
direct id-to-filter mapping.KeyDeserializers which allows registration of
deserializers based on raw (type erased class).Module implementation that allows registration
of serializers and deserializers, and bean serializer
and deserializer modifiers.Version.unknownVersion().
Version.getArtifactId()
Serializers which allows registration of
serializers based on raw (type erased class).Date serialization, we do use String
representation here.Lists,
Maps and such.DateFormat implementation used by standard Date
serializers and deserializers.ToStringSerializer,
others explicit serializers.Maps to JSON
Objects.SubtypeResolver implementation.TypeResolverBuilder implementation.ValueInstantiator implementation, which supports
Creator methods that can be indicated by standard Jackson
annotations.String[] values.Collections
that contain String values; reason is that this is a very common
type and we can make use of the fact that Strings are final.Collections that contain Strings.Strings.BeanDeserializer but
override some aspects like instance construction.IllegalArgumentException if it
is a checked exception; otherwise (runtime exception or error) throw as is
IllegalArgumentException (and with
specified message) if it
is a checked exception; otherwise (runtime exception or error) throw as is
Exception or Error as is.
JsonToken
sequences, needed for temporary buffering.TokenBuffer;
and since it is part of core package, it can not implement
JsonSerializable
(which is only included in the mapper package)Object.toString() returns the desired JSON
value.ToStringSerializer.instance which is stateless and fully thread-safe.
JsonParser instance for
iterating over contents of the tree that this
node is root of.
JsonParser out of JSON tree
representation.
JsonNode that implements JsonParser to allow
accessing contents of JSON tree in alternate form (stream of tokens).TypeDeserializers.JavaType instances,
given various inputs.TypeIdResolver of
specified type.
JsonDeserializers or not.
JavaType instances constructed using TypeFactory.JavaType
representations and constructing type instances.JsonTypeInfo or JAXB annotations),
and produce type serializers and deserializers used for
handling type information embedded in JSON to allow for safe
polymorphic type handling.TypeIdResolver of
specified type.
java.lang.Object.
JsonMappingException sub-class specifically used
to indicate problems due to encountering a JSON property that could
not be mapped to an Object property (via getter, constructor argument
or field).Object
(either explicitly, or due to type erasure).IllegalArgumentException if it
is a checked exception; otherwise (runtime exception or error) throw as is
IllegalArgumentException if it
is a checked exception; otherwise (runtime exception or error) throw as is
BeanPropertyWriter which will handle unwrapping
of JSON Object (including of properties of Object within surrounding
JSON object, and not as sub-object).BeanSerializer
BeanDeserializerFactory when it has collected
basic information such as tentative list of properties to deserialize.
BeanSerializerFactory after collecting all information
regarding POJO to serialize and updating builder with it, but before constructing
serializer.
BeanDeserializerFactory when it has collected
initial list of BeanPropertyDefinitions, and done basic by-name
and by-type filtering, but before constructing builder or actual
property handlers; or arranging order.
ValueInstantiator instances.ObjectMapper.treeToValue(com.fasterxml.jackson.core.TreeNode, java.lang.Class) ; given a value (usually bean), will
construct equivalent JSON Tree representation.
AnnotationIntrospector to use (replacing old one).
ClassIntrospector
to use.
DateFormat
to use.
HandlerInstantiator
to use.
PropertyNamingStrategy
to use.
SubtypeResolver
to use.
TypeFactory
to use.
TypeResolverBuilder to use.
VisibilityChecker
to use.
Locale to use for formatting.
TimeZone to use for formatting of date values.
JsonNodeFactory
JsonAutoDetect.Visibility value to use for all property elements.
InjectableValues to provide injectable values.
JsonNodeFactory for constructing JsonNode
instances.
FormatSchema to JsonParser that
is constructed for parsing content.
SerializationFeature.WRITE_DATES_AS_TIMESTAMPS
(enable if format set as null; disable if non-null)
AbstractTypeResolver.
AbstractTypeResolver.
KeyDeserializers.
KeyDeserializers.
AnnotationIntrospector appended (as the lowest priority one)
Array value; or if no such property exists, to create,
add and return such Array node.
BeanDeserializerModifier.
BeanDeserializerModifier.
Annotated as fallback annotations
AnnotationIntrospector inserted (as the highest priority one)
Method.
BeanPropertyDefinition.getName() would return newName.
ObjectIdWriter.
ValueInstantiators.
ValueInstantiators.
TypeSerializer for decorating
contained values with additional type information.
JsonAutoDetect.Visibility value to use for specified property.
IOException, or an unchecked exception.
IOException, or an unchecked exception.
TypeIdResolver.
TypeIdResolver.
ObjectWriter
with default settings.
ObjectWriter with
specified feature enabled (compared to settings that this
mapper instance has).
ObjectWriter with
specified features enabled (compared to settings that this
mapper instance has).
ObjectWriter that will
serialize objects using specified DateFormat; or, if
null passed, using timestamp (64-bit number.
ObjectWriter that will
serialize objects using specified pretty printer for indentation
(or if null, no pretty printer)
ObjectWriter that will
serialize objects using specified filter provider.
ObjectWriter that will
pass specific schema object to JsonGenerator used for
writing content.
ObjectWriter that will
serialize objects using the default pretty printer for indentation
ObjectWriter that will
serialize objects using specified root type, instead of actual
runtime type of value.
ObjectWriter that will
serialize objects using specified root type, instead of actual
runtime type of value.
ObjectWriter that will
serialize objects using specified root type, instead of actual
runtime type of value.
ObjectWriter that will
serialize objects using specified JSON View (filter).
TypeSerializer.writeTypeSuffixForScalar(java.lang.Object, com.fasterxml.jackson.core.JsonGenerator).
TypeSerializer.writeTypePrefixForObject(java.lang.Object, com.fasterxml.jackson.core.JsonGenerator).
TypeSerializer.writeTypePrefixForScalar(java.lang.Object, com.fasterxml.jackson.core.JsonGenerator).
JsonGenerator.
JsonEncoding.UTF8).
JsonGenerator.
JsonEncoding.UTF8).
Class or
ParameterizedType.
JsonAnyGetter
annotated properties
MinimalClassNameIdResolver._basePackageName, but includes trailing dot.
JsonDeserializer caching.
ArrayList
to its supertypes.
HashMap
to its supertypes.
BeanDeserializerBase.resolve(com.fasterxml.jackson.databind.DeserializationContext)).
JsonParser should be closed
when we are done or not; generally only called when caller did not
pass JsonParser.
ValueInstantiator
using annotations (like @JsonCreator) and visibility rules
TypeResolverBuilder
implementation.
getGenericXxx methods
(usually for a return or argument type).
BeanPropertyWriter for
given member (field or method).
DateTimeSerializerBase._useTimestamp is true.
JsonSerialize.Inclusion.ALWAYS, we need to know the default
value of the bean, to know if property value equals default
one.
StdValueInstantiator.createUsingDefault(com.fasterxml.jackson.databind.DeserializationContext))
ObjectMapper, ObjectReader)
access it.
DeserializationFeatures that are enabled
TypeResolverBuilder
if given annotated element indicates one is needed.
TypeParser when generics-aware version
is constructed.
JsonGenerator.Features
are enabled.
MappingIterator.hasNextValue()
should value; reset when MappingIterator.nextValue() is called
Collection instance that contained
the reference; used if index is relevant and available.
ValueInjectors, if any injectable values are
expected by the bean; otherwise null.
JsonParser and JsonGenerator
instances as necessary.
JsonGenerators
JsonGenerators
MapDeserializer.resolve(com.fasterxml.jackson.databind.DeserializationContext) is called;
Locale used with serialization formats.
BeanDeserializer instances
are configured and constructed.
BeanSerializer instances
are configured and constructed.
TypeModifiers: objects that can change details
of JavaType instances factory constructs.
JsonNode instances.
Map having null key.
Strings, and there is no custom deserialized
specified.
SerializerProvider to use for serialization.
SerializerProvider to use for serialization.
String (or Object, for
which String is acceptable), and that the
default Jackson key deserializer would be used.
TimeZone used with serialization formats.
JavaType instances;
needed to allow modules to add more custom type handling
(mostly to support types of non-Java JVM languages)
JavaType instances;
needed to allow modules to add more custom type handling
(mostly to support types of non-Java JVM languages)
SimpleType._typeParameters
Object.class)
Object in some case)
JavaType._narrow(java.lang.Class), since
underlying type construction is usually identical
TypeSerializer, used when
addition type information is to be embedded.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||