All Classes and Interfaces
Class
Description
Deserializer only used for abstract types used as placeholders during polymorphic
type handling deserialization.
Defines interface for resolvers that can resolve abstract types into concrete
ones; either by using static mappings, or possibly by materializing
implementations dynamically.
API for handlers used to "mangle" names of "getter" and "setter" methods to
find implicit property names.
Helper class that implements all abstract methods with dummy implementations.
Interface for provider (factory) for constructing
AccessorNamingStrategy
for given type of deserialization targetEnumeration used to indicate required access pattern for providers:
this can sometimes be used to optimize out dynamic calls.
Shared base class used for anything on which annotations (included
within a
AnnotationMap).Silly little "Pair" class needed for 2-element tuples (without
adding dependency to one of 3rd party packages that has one).
Helper class that contains logic for resolving annotations to construct
AnnotatedClass instances.Object that represents non-static (and usually non-transient/volatile)
fields of a class.
Intermediate base class for annotated entities that are members of
a class; fields, methods and constructors.
Simple helper class used to keep track of collection of
AnnotatedMethods, accessible by lookup.Object that represents method parameters, mostly so that associated
annotations can be processed conveniently.
Intermediate base class that encapsulates features that
constructors and methods share.
Helper class used to collect annotations to be stored as
Annotations (like AnnotationMap).Immutable implementation for case where no annotations are associated with
an annotatable entity.
Abstract class that defines API used for introspecting annotation-based
configuration for serialization and deserialization.
Value type used with managed and back references; contains type and
logic name, used to link related references
Add-on extension used for XML-specific configuration, needed to decouple
format module functionality from pluggable introspection functionality
(especially JAXB-annotation related one).
Helper class that allows using 2 introspectors such that one
introspector acts as the primary one to use; and second one
as a fallback used if the primary does not provide conclusive
or useful result for a method.
Simple helper class used to keep track of collection of
Jackson Annotations associated with annotatable things
(methods, constructors, classes).
Interface that defines interface for accessing contents of a
collection of annotations.
Class similar to
BeanPropertyWriter, but that will be used
for serializing JsonAnyGetter annotated
(Map) propertiesWe need a custom deserializer both because
ArrayBlockingQueue has no
default constructor AND because it has size limit used for constructing
underlying storage automatically.Helper class that contains set of distinct builders for different
arrays of primitive values.
Iterator implementation used to efficiently expose contents of an
Array as read-only iterator.
Node class that represents Arrays mapped from JSON content.
Intermediate base class for serializers used for various Java arrays.
Array types represent Java arrays, both primitive and object valued.
Base class for serializers that will output contents as JSON
arrays; typically serializers used for
Collection
and array types.Type deserializer used with
JsonTypeInfo.As.WRAPPER_ARRAY
inclusion mechanism.Type serializer that will embed type information in an array,
as the first element, and actual value as the second element.
A
TypeDeserializer capable of deducing polymorphic types based on the
fields available.Type serializer used with
JsonTypeInfo.As.EXISTING_PROPERTY inclusion mechanism.Type deserializer used with
JsonTypeInfo.As.EXTERNAL_PROPERTY inclusion mechanism.Type serializer that preferably embeds type information as an "external"
type property; embedded in enclosing JSON object.
Type deserializer used with
JsonTypeInfo.As.PROPERTY
inclusion mechanism.Type serializer that preferably embeds type information as an additional
JSON Object property, if possible (when resulting serialization would
use JSON Object).
Type deserializer used with
JsonTypeInfo.As.WRAPPER_OBJECT
inclusion mechanism.Type wrapper that tries to use an extra JSON Object, with a single
entry that has type name as key, to serialize type information.
VirtualBeanPropertyWriter implementation used for
JsonAppend,
to serialize properties backed-by dynamically assignable attribute
values.Abstract base class common to all standard
JsonNode
implementations.Base class for all actual
JsonNode deserializer implementations.Immutable container class used to store simple configuration
settings for both serialization and deserialization.
Default
BeanDescription implementation used by Jackson.Abstract factory base class that can provide deserializers for standard
JDK classes, including collection classes and simple heuristics for
"upcasting" common collection interface types
(such as
Collection).Helper class to contain default mappings for abstract JDK
Collection
and Map types.Standard
BasicPolymorphicTypeValidator implementation that users may want
to use for constructing validators based on simple class hierarchy and/or name patterns
to allow and/or deny certain subtypes.Builder class for configuring and constructing immutable
BasicPolymorphicTypeValidator instances.General matcher interface (predicate) for validating unresolved
subclass class name.
General matcher interface (predicate) for validating class values
(base type or resolved subtype)
Factory class that can provide serializers for standard JDK classes,
as well as custom classes that extend standard classes or implement
one of "well-known" interfaces (such as
Collection).Variant of
BeanDeserializer used for handling deserialization
of POJOs when serialized as JSON Arrays, instead of JSON Objects.Specialized POJO serializer that differs from
BeanSerializer
in that instead of producing a JSON Object it will output
a JSON Array, omitting field names, and serializing values in
specified serialization order.Basic container for information gathered by
ClassIntrospector to
help in constructing serializers and deserializers.Deserializer class that can deserialize instances of
arbitrary bean objects, usually from JSON Object structs,
Base class for
BeanDeserializer.Builder class used for aggregating deserialization information about
a property-based POJO, in order to build a
ValueDeserializer
for deserializing POJO instances.Concrete deserializer factory class that adds full Bean deserializer
construction logic using class introspection.
Bean properties are logical entities that represent data
that Java objects (POJOs (Plain Old Java Objects), sometimes also called "beans")
contain; and that are accessed using accessors (methods like getters
and setters, fields, constructor parameters).
Alternative "Null" implementation that can be used in cases where a non-null
BeanProperty is neededSimple stand-alone implementation, useful as a placeholder
or base class for more complex implementations.
Simple value classes that contain definitions of properties,
used during introspection of properties to use for
serialization and deserialization purposes.
Helper class used for storing mapping from property name to
SettableBeanProperty instances.Base bean property handler class, which implements common parts of
reflection-based functionality for accessing a property value and serializing
it.
Serializer class that can serialize Java objects that map
to JSON Object output.
Base class both for the standard bean serializer, and couple
of variants that only differ in small details.
Builder class used for aggregating deserialization information about
a POJO, in order to build a
ValueSerializer for serializing
instances.Factory class that can provide serializers for any regular Java beans
(as defined by "having at least one get method recognizable as bean
accessor" -- where
Object.getClass() does not count);
as well as for "standard" JDK types.Helper class that contains functionality needed by both serialization
and deserialization side.
Numeric node that contains simple 64-bit integer values.
Value node that contains Base64 encoded binary value, which will be
output and stored as Json String value.
This concrete value class is used to contain boolean (true / false)
values.
Serializer used for primitive boolean, as well as java.util.Boolean
wrapper type.
Class that handles deserialization using a separate
Builder class, which is used for data binding and
produces actual deserialized value at the end
of data binding.
Unlike other integral number array serializers, we do not just print out byte values
as numbers.
Simple
InputStream implementation that exposes currently
available content of a ByteBuffer.Simple
OutputStream implementation that appends content
written in given ByteBuffer instance.Interface that defines API Jackson uses for constructing various internal
caches.
Helper class used to introspect features of POJO value classes
used with Jackson.
Key class, used as an efficient and accurate key
for locating per-class values, such as
ValueSerializers.TypeIdResolver implementation
that converts between fully-qualified
Java class names and (JSON) Strings.Simple helper class used to keep track of 'call stack' for classes being referenced
(as well as unbound variables)
Value class used for containing information about discovered Constructors
Set of possible actions for requested coercion from an
input shape
CoercionInputShape
that does not directly or naturally match target type
(LogicalType).Set of input types (which mostly match one of
JsonToken types) used for
configuring CoercionActions to take when reading
input into target types (specific type or LogicalType).Basic serializer that can take JSON "Array" structure and
construct a
Collection instance, with typed contents.Helper class for dealing with Object Id references for values contained in
collections being deserialized.
Type that represents things that act similar to
Collection;
but may or may not be instances of that interface.Fallback serializer for cases where Collection is not known to be
of type for which more specializer serializer exists (such as
index-accessible List).
Type that represents Java Collection types (Lists, Sets).
Intermediate
BeanProperty class shared by concrete readable- and
writable property implementations for sharing common functionality.Interface that actual SerializationFeature enumerations used by
MapperConfig implementations must implement.Configuration object that is accessed by databinding functionality
to find overrides to configuration of properties, based on declared
type of the property.
Container for individual
ConfigOverride values.Configurable handler used to select aspects of selecting
constructor to use as "Creator" for POJOs.
Definition of alternate handling modes of single-argument constructors
that are annotated with
JsonCreator
but without "mode" definition (or explicit name for the argument):
this is the case where two interpretations
are possible -- "properties" (in which case the argument is named parameter
of a JSON Object) and "delegating (in which case the argument maps to the
whole JSON value).Intermediate base deserializer class that adds more shared accessor
so that other classes can access information about contained (value) types
This intermediate base class is used for all container nodes,
specifically, array and object nodes.
Helper class used for storing and accessing per-call attributes.
Add-on interface that
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.Helper interface for things that convert Objects of
one type to another.
This marker class is only to be used with annotations, to
indicate that no converter is to be used.
Container deserializers that handle "core" XML types: ones included in standard
JDK 1.5.
Combo-deserializer that supports deserialization of somewhat optional
javax.xml types
QName, Duration and XMLGregorianCalendar.Container class for storing information on creators (based on annotations,
visibility), to be able to build actual
ValueInstantiator later on.This concrete sub-class implements property that is passed
via Creator (constructor or static factory method).
Shared base class for
DeserializationContext and
SerializationContext, context objects passed through data-binding
process.Exception used to signal fatal problems with mapping of
content, distinct from low-level I/O problems (signaled using
simple
JacksonIOExceptions) or data encoding/decoding
problems (signaled with StreamReadException,
StreamWriteException).Interface that defines interaction with data type specific configuration
features.
Immutable value class that contains settings for multiple
DatatypeFeature enumerations.Configurable on/off features to configure Date/Time handling.
Numeric node that contains values that do not fit in simple
floating point (double) values.
Default
AccessorNamingStrategy used by Jackson: to be used either as-is,
or as base-class with overrides.Definition of a handler API to use for checking whether given base name
(remainder of accessor method name after removing prefix) is acceptable
based on various rules.
Simple implementation of
DefaultAccessorNamingStrategy.BaseNameValidator that checks the
first character and nothing else if (and only if!)Provider for
DefaultAccessorNamingStrategy.Implementation used for supporting "non-prefix" naming convention of
Java 14
java.lang.Record types, and in particular find default
accessors for declared record fields.PolymorphicTypeValidator that will only allow polymorphic handling if
the base type is NOT one of potential dangerous base types (see DefaultBaseTypeLimitingValidator.isUnsafeBaseType(tools.jackson.databind.DatabindContext, tools.jackson.databind.JavaType)
for specific list of such base types).The default implementation of
CacheProvider.Builder offering fluent factory methods to configure
DefaultCacheProvider, keeping it immutable.Customized
TypeResolverBuilder that provides type resolver builders
used with so-called "default typing"
(see MapperBuilder.activateDefaultTyping(PolymorphicTypeValidator)
for details).Enumeration used with
JsonMapper.defaultTyping() methods
to specify what kind of types (classes) default typing should
be used for.Base class that simplifies implementations of
ValueDeserializers
that mostly delegate functionality to another deserializer implementation
(possibly forming a chaining of deserializers delegating functionality
in some cases)Object that contains baseline configuration for deserialization
process.
Context for the process of deserialization a single root-level value.
Complete
DeserializationContext implementation that adds
extended API for ObjectMapper (and ObjectReader)
to call, as well as implements certain parts that base class
has left abstract.Actual full concrete implementation
Factory/builder class that replaces Jackson 2.x concept of "blueprint" instance
of
DeserializationContext.Enumeration that defines simple on/off features that affect
the way Java objects are deserialized from JSON
This is the class that can be registered (via
DeserializationConfig object owner by
ObjectMapper) to get called when a potentially
recoverable problem is encountered during deserialization
process.Class that defines caching layer between callers (like
ObjectMapper,
DeserializationContext)
and classes that construct deserializers
(DeserializerFactory).Abstract class that defines API used by
DeserializationContext
to construct actual
ValueDeserializer instances (which are then cached by
context and/or dedicated cache).Configuration settings container class for
DeserializerFactory.Interface that defines API for simple extensions that can provide additional deserializers
for various types.
Basic
Deserializers implementation that implements all methods but provides
no deserializers.Base for deserializers that allows parsing DOM Documents from JSON Strings.
Numeric node that contains 64-bit ("double precision")
floating point values simple 32-bit integer values.
DoubleStream serializerDeserializer for Java 8 temporal
Durations.Serializer for Java 8 temporal
Durations.Deserializer class that can deserialize instances of
specified Enum class from Strings and Integers.
New Datatype-specific configuration options related to handling of
Enum types.Deserializer for
EnumMap values.Annotation that can be used to indicate a
EnumNamingStrategy
to use for annotated class.A container class for implementations of the
EnumNamingStrategy interface.
An implementation of
EnumNamingStrategy that converts enum names in the typical upper
snake case format to upper camel case format.
An implementation of
EnumNamingStrategy that converts enum names in the typical upper
snake case format to lower camel case format.
An implementation of
EnumNamingStrategy that converts enum names in the typical upper
snake case format to upper camel case format.
An implementation of
EnumNamingStrategy that converts enum names in the typical upper
snake case format to lower dot case format.
An implementation of
EnumNamingStrategy that converts enum names in the typical upper
snake case format to upper camel case format.
An implementation of
EnumNamingStrategy that converts enum names in the typical upper
snake case format to upper camel case format.
An implementation of
EnumNamingStrategy that converts enum names in the typical upper
snake case format to upper camel case format.Defines how the string representation of an enum is converted into an external property name for mapping
during deserialization.
Helper class used for aggregating information about all possible
properties of a Enum.
Helper class used to resolve String values (either JSON Object field
names or regular String values) into Java Enum instances.
Standard serializer used for
Enum types.Standard deserializer for
EnumSets.Helper class used for storing String serializations of
Enums,
to match to/from external representations.A deserializer that stores an
Error caught during constructing
of the deserializer, which needs to be deferred and only during actual
attempt to deserialize a value of given type.Utility methods for dealing with exceptions/throwables
Helper class that is used to flatten JSON structure when using
"external type id" (see
JsonTypeInfo.As.EXTERNAL_PROPERTY).Special bogus "serializer" that will throw
MismatchedInputException if an attempt is made to deserialize
a value.Special bogus "serializer" that will throw
DatabindException if its FailingSerializer.serialize(java.lang.Object, tools.jackson.core.JsonGenerator, tools.jackson.databind.SerializationContext)
gets invoked.This concrete sub-class implements property that is set
directly assigning to a Field.
Decorated
BeanPropertyWriter that will filter out properties
that are not to be included in currently active JsonView.Interface for objects that provides instances of
PropertyFilter
that match given ids.JsonNode implementation for efficiently containing 32-bit
`float` values.Base class for building simple scalar value deserializers that accept
String values.
Extension over
Named to expose full name; most relevant
for formats like XML that use namespacing.Helper class used for containing settings specifically related
to (re)configuring
JsonGenerator constructed for
writing output.Helper class used for handling details of creating handler instances (things
like
ValueSerializers, ValueDeserializers, various type
handlers) of specific types.Specialized
DatabindException sub-class used to indicate
case where an explicitly ignored property is encountered, and mapper
is configured to consider this an error.Helper class to encapsulate logic from static
shouldIgnore method
of util class.This is an optimized serializer for Lists that can be efficiently
traversed by index (as opposed to others, such as
LinkedList
that cannot}.Efficient implement for serializing
Lists that contains Strings and are random-accessible.Simple serializer for
InetAddress.Simple serializer for
InetSocketAddress.Abstract class that defines API for objects that provide value to
"inject" during deserialization.
Simple standard implementation which uses a simple Map to
store values to inject, identified by simple String keys.
This sub-class is used to handle special case of value being a
non-static inner class.
Numeric node that contains simple 32-bit integer values.
IntStream serializerIntermediate exception type used as the base class for all
DatabindExceptions
that are due to problems with target type definition; usually a problem with
annotations used on a class or its properties.Specialized sub-class of
MismatchedInputException
that is used when the underlying problem appears to be that
of bad formatting of a value to deserialize.Exception thrown if a `null` value is being encountered for a property
designed as "fail on null" property (see
JsonSetter).Exception thrown when resolution of a type id fails.
Specialized
SimpleType for types that are allow iteration
over Collection(-like) types: this includes types like
Iterator.AnnotationIntrospector implementation that handles standard
Jackson annotations.Utility class that provides custom
Collector implementations to support Stream operations.Simple interface for extensions that can be registered with
ObjectMapper
to provide a well-defined set of extensions to default functionality; such as
support for new data types.Interface Jackson exposes to modules for purpose of registering
extended functionality.
Interface that can be implemented by objects that know how to
serialize themselves to JSON, using
JsonGenerator
(and SerializationContext if necessary).Base class with minimal implementation, as well as couple of extension methods
that core Jackson databinding makes use of.
Generic handler for types that implement
JacksonSerializable.Marker interface used to indicate implementation classes
(serializers, deserializers etc) that are standard ones Jackson
uses; not custom ones that application has added.
Serializer implementation for
Blob to write as binary
(for JSON and other formats Base64-encoded String, for binary formats as
true binary).Compared to plain old
Date, SQL version is easier
to deal with: mostly because it is more limited.Compared to regular
Date serialization, we do use String
representation here.
NOTE: name was
SqlTimeSerializer in Jackson 2.xSimple deserializer for handling
Timestamp values.Helper class used for isolating details of handling optional+external types
(java.sql classes) from standard factories that offer them.
Class that registers capability of deserializing and serializing (reading and writing)
java.time values with the Jackson core.Base class for type token classes used both to contain information
and as keys for deserializers.
Standard serializer for
Calendar.Helper class used to contain logic for deserializing "special" containers
from
java.util.Collections and java.util.Arrays.Simple deserializer for handling
Date values.For efficiency, we will serialize Dates as longs, instead of
potentially more readable Strings.
Common typed stream serializer
Dummy container class to group standard homogeneous array serializer implementations
(primitive arrays and String array).
Character arrays are different from other integral number arrays in that
they are most likely to be textual data, and should be written as
Strings, not arrays of entries.
Intermediate base class used for cases where we may add
type information (excludes boolean/int/double arrays).
Container class for core pre-Java8 JDK date/time type deserializers.
Base class for simple deserializers that serialize values from String
representation: this includes JSON Strings and other Scalar values that
can be coerced into text, like Numbers and Booleans).
Default
KeyDeserializer implementation used for most Map
key types Jackson supports.Helper class used to contain simple/well-known key deserializers.
This is a "chameleon" style multi-type key serializer for simple
standard JDK types.
Key serializer used when key type is not known statically, and actual key
serializer needs to be dynamically located.
Specialized instance to use for Enum keys, as per [databind#1322]
Simple and fast key serializer when keys are Strings.
Container class that contains serializers for miscellaneous JDK types
that require special handling and are not grouped along with a set of
other serializers (like date/time)
Class that providers access to serializers user for non-structured JDK types that
are serializer as scalars; some using basic
ToStringSerializer,
others explicit serializers."Combo" serializer used for JDK types that work almost like
ToStringSerializer.Container for a set of
ValueInstantiators used for certain critical
JDK value types, either as performance optimization for initialization time observed
by profiling, or due to difficulty in otherwise finding constructors.Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Annotation used to add "virtual" properties that will be written
after regular properties during serialization.
Definition of a single attribute-backed property.
Definition of a single general virtual property.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Annotation use for configuring deserialization aspects, by attaching
to "setter" methods or fields, or to value classes.
Interface
ValueSerializer implements
to allow for visiting type hierarchy.Interface for visitor callbacks, when type in question can be any of
legal JSON types.
Empty "no-op" implementation of
JsonFormatVisitorWrapper, suitable for
sub-classing.Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
JSON-specific
ObjectMapper implementation.Base implementation for "Vanilla"
ObjectMapper, used with
JSON dataformat backend.Annotation that can be used to indicate a
PropertyNamingStrategy
to use for annotated class.Base class for all JSON nodes, which form the basis of JSON
Tree Model that Jackson implements.
Configuration setting used with
JsonNode.withObject(JsonPointer)
method overrides, to indicate which overwrites are acceptable if the
path pointer indicates has incompatible nodes (for example, instead
of Object node a Null node is encountered).Interface that defines common "creator" functionality implemented
both by
JsonNodeFactory and ContainerNode (that is,
JSON Object and Array nodes).Base class that specifies methods for getting access to
Node instances (newly constructed, or shared, depending
on type), as well as basic implementation of the methods.
New Datatype-specific configuration options related to handling of
JsonNode types.Enumeration of JSON types.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Visitor called when properties of a type that maps to JSON Object
are being visited: this usually means POJOs, but sometimes other
types use it too (like
EnumMap).Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Container class that can be used to wrap any Object instances (including
nulls), and will serialize embedded in
JSONP wrapping.
Annotation used to configure details of a Builder class:
instances of which are used as Builders for deserialized
POJO values, instead of POJOs being instantiated using
constructors or factory methods.
Simple value container for containing values read from
JsonPOJOBuilder annotation instance.Annotation used for configuring serialization aspects, by attaching
to "getter" methods or fields, or to value classes.
Enumeration used with
JsonSerialize.typing() property
to define whether type detection is based on dynamic runtime
type (DYNAMIC) or declared type (STATIC).Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Annotation that can be used to plug a custom type identifier handler
(
TypeIdResolver)
to be used by
TypeSerializers
and TypeDeserializers
for converting between java types and type id included in JSON content.Annotation that can be used to explicitly define custom resolver
used for handling serialization and deserialization of type information,
needed for handling of polymorphic types (or sometimes just for linking
abstract types to concrete types)
This enum represents the encoded format for a jsonSchema value type
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Annotation that can be used to indicate a
ValueInstantiator to use
for creating instances of specified type.Serializer class that can serialize Object that have a
JsonValue annotation to
indicate that serialization should be done by calling the method
annotated, and serializing result it returns.General-purpose wrapper class that can be used to decorate serialized
value with arbitrary literal prefix and suffix.
Abstract class that defines API used for deserializing JSON content
field names into Java Map keys.
This marker class is only to be used with annotations, to
indicate that no deserializer is configured.
Interface that defines API for simple extensions that can provide additional deserializers
for deserializer Map keys of various types, from JSON property names.
Node of a forward-only linked list.
Deserializer for Java 8 temporal
LocalDates.Serializer for Java 8 temporal
LocalDates.Deserializer for Java 8 temporal
LocalDateTimes.Serializer for Java 8 temporal
LocalDateTimes.Deserializer for Java 8 temporal
LocalTimes.Serializer for Java 8 temporal
LocalTimes.Set of logical types (or type categories, classes of classes), used
for defining applicability of configuration like coercion configuration.
Numeric node that contains simple 64-bit integer values.
LongStream serializerAn interface describing the required API for the Jackson-Databind Type cache.
Wrapper property that is used to handle managed (forward) properties
Basically just needs to delegate first to actual forward property, and
then to back property.
Basic deserializer that can take JSON "Object" structure and
construct a
Map instance, with typed contents.Serializer used to serialize Map.Entry as POJOs: that is, as if
introspected as POJOs so that there's intermediate "key" and "value"
properties.
Basic serializer that can take JSON "Object" structure and
construct a
Map.Entry instance, with typed contents.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.Since
ObjectMapper instances are immutable in Jackson 3.x for full thread-safety,
we need means to construct configured instances.Interface for State object used for preserving initial state of a
MapperBuilder before modules are configured and resulting
ObjectMapper isn't constructed.Interface that defines functionality accessible through both
serialization and deserialization configuration objects;
accessors to mode-independent configuration settings
and such.
Enumeration that defines simple on/off features to set
for
ObjectMapper, and accessible (but not changeable)
via ObjectReader and ObjectWriter (as well as
through various convenience methods through context objects).Iterator exposed by
ObjectMapper when binding sequence of
objects.Helper class needed to support flexible filtering of Map properties
with generic JSON Filter functionality.
Standard serializer implementation for serializing {link java.util.Map} types.
Type that represents "true" Java Map types.
Helper class needed to be able to efficiently access class
member functions (
Methods and Constructors)
in Maps.SettableBeanProperty implementation that will try to access value of
the property first, and if non-null value found, pass that for update
(using ValueDeserializer.deserialize(tools.jackson.core.JsonParser, tools.jackson.databind.DeserializationContext, Object))
instead of constructing a new value.This concrete sub-class implements property that is set
using regular "setter" method.
Specialization of
ClassNameIdResolver that instead uses a
"minimal" derivation of Class name, using relative reference
from the base type (base class) that polymorphic value has.General exception type used as the base class for all
DatabindExceptions
that are due to input not mapping to target definition; these are typically
considered "client errors" since target type definition itself is not the root cause
but mismatching input.This singleton node class is generated to denote "missing nodes"
along paths that do not exist.
Basic
MixInResolver implementation that both allows simple "local"
override definitions (with simple Mix-in class over Target class mapping)
and allows optional custom overrides for lookup.Interface used for decoupling details of how mix-in annotation
definitions are accessed (via this interface), and how
they are stored (defined by classes that implement the interface)
Default implementation of
JacksonModule.SetupContext used by
ObjectMapper.Deserializer for Java 8 temporal
MonthDays.Serializer for Java 8 temporal
MonthDays.Mutable version of
CoercionConfig (or rather, extended API)
exposed during configuration phase of ObjectMapper
(via JsonMapper.builder()).Extension of
ConfigOverride that allows changing of
contained configuration settings.Simple container class for types with optional logical name, used
as external identifier
Helper class used to encapsulate details of name mangling, transforming
of names using different strategies (prefixes, suffixes).
Container for standard naming strategy implementations, specifically
used by property naming strategies (see
PropertyNamingStrategies)
and enum naming strategies (see EnumNamingStrategies).Utilities for graal native image support; mostly to improve error message handling
in case of missing information for native image.
Dummy, "no-operation" implementation of
AnnotationIntrospector.Bogus deserializer that will simply skip all content there is to map
and returns Java null reference.
This singleton value class is used to contain explicit JSON null
value.
Simple
NullValueProvider that will return "empty value"
specified by ValueDeserializer provider is constructed with.Simple
NullValueProvider that will simply return given
constant value when a null is encountered; or, with a specially
constructed instance (see NullsConstantProvider.skipper(), indicate the need
for special behavior of skipping property altogether (not setting
as anything OR throwing exception).This is a simple dummy serializer that will just output literal
JSON null value whenever serialization is requested.
Simple
NullValueProvider that will always throw a
InvalidNullException when a null is encountered.Helper interface implemented by classes that are to be used as
null providers during deserialization.
Container class for deserializers that handle core JDK primitive
(and matching wrapper) types, as well as standard "big" numeric types.
This is bit trickier to implement efficiently, while avoiding
overflow problems.
For type
Number.class, we can just rely on type
mappings that plain JsonParser.getNumberValue() returns.As a fallback, we may need to use this serializer for other
types of
Numbers: both custom types and "big" numbers
like BigInteger and BigDecimal.Container class for serializers used for handling standard JDK-provided
types.
Base class for actual primitive/wrapper value serializers.
This is the special serializer for regular
Doubles (and
primitive doubles)This is the special serializer for regular
Integers
(and primitive ints)Similar to
NumberSerializers.IntegerSerializer, but will not cast to Integer:
instead, cast is to Number, and conversion is by
calling Number.intValue().Intermediate node class used for numeric nodes that contain
floating-point values: provides partial implementation of common
methods.
Intermediate node class used for numeric nodes that contain
integral values: provides partial implementation of common
methods.
Intermediate value node used for numeric nodes.
Serializer that can serialize non-primitive arrays.
Generic serializer for Object arrays (
Object[]).Helper class to use for constructing Object arrays by appending entries
to create arrays of various lengths (length that is not known a priori).
Container object that encapsulates information usually
derived from
JsonIdentityInfo annotation or its
custom alternativesObject that knows how to deserialize Object Ids.
Specialized
SettableBeanProperty implementation used
for virtual property that represents Object Id that is used
for some POJO types (or properties).Object that knows how to serialize Object Ids.
ObjectMapper provides functionality for reading and writing JSON,
either to and from basic POJOs (Plain Old Java Objects), or to and from
a general-purpose JSON Tree Model (
JsonNode), as well as
related functionality for performing conversions.Node that maps to JSON Object structures in JSON content.
Builder object that can be used for per-serialization configuration of
deserialization parameters, such as root type to use or object
to update (instead of constructing new instance).
Builder object that can be used for per-serialization configuration of
serialization parameters, such as JSON View and root type to use.
As a minor optimization, we will make an effort to pre-fetch a serializer,
or at least relevant
TypeSerializer, if given enough
information.Deserializer for Java 8 temporal
OffsetTimes.Serializer for Java 8 temporal
OffsetTimes.Helper class used for isolating details of handling optional+external types
(javax.xml classes) from standard factories that offer them.
Automatically generated from PackageVersion.java.in during
packageVersion-generate execution of maven-replacer-plugin in
pom.xml.
Helper type used when introspecting bindings for already resolved types,
needed for specialization.
Value node that contains a wrapped POJO, to be serialized as
a JSON constructed through data mapping (usually done by
calling
ObjectMapper).Helper class used for aggregating information about all possible
properties of a POJO.
Helper class used for aggregating information about a single
potential POJO property.
Node used for creating simple linked lists to efficiently store small sets
of things.
Interface for classes that handle validation of class-name - based subtypes used
with Polymorphic Deserialization: both via "default typing" and explicit
@JsonTypeInfo when using Java Class name as Type Identifier.Shared base class with partial implementation (with all validation calls returning
PolymorphicTypeValidator.Validity.INDETERMINATE) and convenience methods for indicating failure reasons.Definition of return values to indicate determination regarding validity.
Information about a single Creator (constructor or factory method),
kept during property introspection.
Base class for specialized primitive array builders.
Container for deserializers used for instantiating "primitive arrays",
arrays that contain non-object java primitive types.
Object that is used to collect arguments for non-default creator
(non-default-constructor, or argument-taking factory method)
before creator can be called.
Base class for
MismatchedInputExceptions that are specifically related
to problems related to binding an individual property.Helper class for
BeanSerializerFactory that is used to
construct BeanPropertyWriter instances.Interface that defines API for filter objects use (as configured
using
JsonFilter)
for filtering bean properties to serialize.Simple container class used for storing "additional" metadata about
properties.
Helper class used for containing information about expected merge
information for this property, if merging is expected.
Simple value class used for containing names of properties as defined
by annotations (and possibly other configuration sources).
Container for standard
PropertyNamingStrategy implementations
and singleton instances.Naming strategy similar to
PropertyNamingStrategies.SnakeCaseStrategy,
but instead of underscores
as separators, uses hyphens."No-operation" strategy that is equivalent to not specifying any
strategy: will simply return suggested standard bean naming as-is.
Simple strategy where external name simply only uses lower-case characters,
and no separators.
Naming strategy similar to
PropertyNamingStrategies.KebabCaseStrategy,
but instead of hyphens
as separators, uses dots.Intermediate base class for simple implementations
A
PropertyNamingStrategy that translates typical camel case Java
property names to lower case JSON element names, separated by
underscores.A
PropertyNamingStrategy that translates typical camelCase Java
property names to PascalCase JSON element names (i.e., with a capital
first letter).A
PropertyNamingStrategy that translates an input to the equivalent upper case snake
case.Class that defines how names of JSON properties ("external names")
are derived from names of POJO methods and fields ("internal names"),
in cases where no explicit annotations exist for naming.
Helper container used for resolving serializers for dynamic (possibly but not
necessarily polymorphic) properties: properties whose type is not forced
to use dynamic (declared) type and that are not final.
Value class used for returning tuple that has both serializer
that was retrieved and new map instance
Base class for property values that need to be buffered during
deserialization.
Simple container used for temporarily buffering a set of
PropertyValues.Base class for writers used to output property values (name-value pairs)
as key/value pairs via streaming API.
This is a simple dummy serializer that will just output raw values by calling
toString() on value to serialize.
Helper class used to encapsulate "raw values", pre-encoded textual content
that can be output as opaque value with no quoting/escaping, using
JsonGenerator.writeRawValue(String).Simple value container for containing information about single Object Id
during deserialization
Optimized lookup table for accessing two types of serializers; typed
and non-typed.
Helper class for finding so-called canonical constructor
of Record types.
Specialized
SimpleType for types that are referential types,
that is, values that can be dereferenced to another value (or null),
of different type.Base deserializer implementation for properties
ReferenceType values.Base implementation for values of
ReferenceType.Internal placeholder type used for self-references.
Helper class for caching resolved root names.
Writer class similar to
ObjectWriter, except that it can be used
for writing sequences of values, not just a single value.Object that contains baseline configuration for serialization
process.
Class that defines API used by
ObjectMapper and
ValueSerializers to obtain serializers capable of serializing
instances of specific types; as well as the default implementation
of the functionality.Extension over
SerializationContext that adds methods needed by
ObjectMapper (and ObjectWriter) but that are not to be exposed
as general context during serialization.Concrete implementation defined separately so it can be declared `final`.
Factory/builder class that replaces Jackson 2.x concept of "blueprint" instance
of
SerializationContext.Enumeration that defines simple on/off features that affect
the way Java objects are serialized.
Simple cache object that allows for doing 2-level lookups: first level is
by "local" read-only lookup Map (used without locking) and second backup
level is by a shared modifiable HashMap.
Abstract class that defines API used by
SerializationContext
to obtain actual
ValueSerializer instances from multiple distinct factories.Configuration settings container class for
SerializerFactory implementations.Interface that defines API for simple extensions that can provide additional serializers
for various types.
Basic
Serializers implementation that implements all methods but provides
no serializers.Class that represents a "wildcard" set method which can be used
to generically set values of otherwise unmapped (aka "unknown")
properties read from JSON content.
[databind#562] Allow @JsonAnySetter on Creator constructor
[databind#562] Allow @JsonAnySetter on Creator constructor
Base class for deserializable properties of a bean: contains
both type and name definitions, and reflection-based set functionality.
Helper class that is designed to both make it easier to sub-class
delegating subtypes and to reduce likelihood of breakage when
new methods are added.
This concrete sub-class implements Collection or Map property that is
indirectly by getting the property value and directly modifying it.
Numeric node that contains simple 16-bit integer values.
Simple
AbstractTypeResolver implementation, which is
based on static mapping from abstract super types into
sub types (concrete or abstract), but retaining generic
parameterization.Simple immutable
BeanPropertyDefinition implementation that can
be wrapped around a AnnotatedMember that is a simple
accessor (getter) or mutator (setter, constructor parameter)
(or both, for fields).Simple
PropertyFilter implementation that only uses property name
to determine whether to serialize property as is, or to filter it out.Filter implementation which defaults to filtering out unknown
properties and only serializes ones explicitly listed.
Filter implementation which defaults to serializing all
properties, except for ones explicitly listed to be filtered out.
Simple implementation
Deserializers which allows registration of
deserializers based on raw (type erased class).Simple
FilterProvider implementation that just stores
direct id-to-filter mapping.Simple implementation
KeyDeserializers which allows registration of
deserializers based on raw (type erased class).Synchronized cache with bounded size: used for reusing lookup values
and lazily instantiated reusable items.
Vanilla
JacksonModule implementation that allows registration
of serializers and deserializers, bean serializer
and deserializer modifiers, registration of subtypes and mix-ins
as well as some other commonly
needed aspects (addition of custom AbstractTypeResolvers,
ValueInstantiators).TypeIdResolver implementation
that converts using explicitly (annotation-) specified type names
and maps to implementation classes; or, in absence of annotated type name,
defaults to simple Class names (obtained with Class.getSimpleName().Simple implementation
Serializers which allows registration of
serializers based on raw (type erased class).Simple types are defined as anything other than one of recognized
container types (arrays, Collections, Maps).
Intermediate class used both for convenience of binding and
to support
PropertyNamingStrategy.Intermediate base class for Lists, Collections and Arrays
that contain static (non-dynamic) value types.
Intermediate base class for serializers used for serializing
types that contain element(s) of other types, such as arrays,
Collections (Lists, Sets
etc) and Maps and iterable things
(Iterators).Standard implementation of
Converter that supports explicit
type access, instead of relying type detection of generic type
parameters.Deserializer implementation where given Java type is first deserialized
by a standard Jackson deserializer into a delegate type; and then
this delegate type is converted using a configured
Converter into desired target type.Jackson's internal
DateFormat implementation used by standard Date
serializers and deserializers to implement default behavior: does NOT
fully implement all aspects expected by DateFormat and as a consequence
SHOULD NOT to be used by code outside core Jackson databind functionality.Serializer implementation where given Java type is first converted
to an intermediate "delegate type" (using a configured
Converter, and then this delegate value is serialized by Jackson.Base class for common deserializers.
Base class for standard serializers that are not (necessarily) container types
but that similarly handle content that may vary in ways to require dynamic lookups.
Convenience deserializer that may be used to deserialize values given an
intermediate tree representation (
JsonNode).Base class for deserializers that handle types that are serialized
as JSON scalars (non-structured, i.e. non-Object, non-Array, values).
Base class used by all standard serializers, and can also
be used for custom serializers (in fact, this is the recommended
base class to use).
Standard
SubtypeResolver implementation.Default
TypeResolverBuilder implementation.Default
ValueInstantiator implementation, which supports
Creator methods that can be indicated by standard Jackson
annotations.Separate implementation for serializing String arrays (instead of
using
ObjectArrayDeserializer.Standard serializer used for
String[] values.Specifically optimized version for
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.Efficient implement for serializing
Collections that contain Strings.Value node that contains a String value.
This is the special serializer for regular
Strings.Helper object used for handling registration on resolving of super-types
to sub-types.
Helper class used to encapsulate rules that determine subtypes that
are invalid to use, even with default typing, mostly due to security
concerns.
Deserializer for the
ThreadGroup class: due to limited access,
will only try to extract "name" property and ignores everything else.Deserializer that builds on basic
BeanDeserializer but
override some aspects like instance construction.Simple "bogus" serializer that will just serialize an empty
Object for any given value.
Utility class used for efficient storage of
JsonToken
sequences, needed for temporary buffering.Individual segment of TokenBuffer that can store up to 16 tokens
(limited by 4 bits per token type marker requirement).
We also want to directly support deserialization of
TokenBuffer.Implementation of
TokenStreamContext used by TokenBuffer
to link back to the original context to try to keep location information
consistent between source location and buffered content when it's re-read
from the buffer.We also want to directly support serialization of
TokenBuffer;
and since it is part of core package, it cannot implement
JacksonSerializable
(which is only included in the mapper package)For
TokenStreamLocation, we should be able to just implement
ValueInstantiator (not that explicit one would be very
hard but...)Simple general purpose serializer, useful for any
type for which
Object.toString() returns the desired String serialization value.Intermediate base class that serves as base for standard
ToStringSerializer
as well as for custom subtypes that want to add processing for converting from
value to output into its String representation (whereas standard version
simply calls value object's toString() method).Helper class used for creating
JsonNode values directly
as part of serialization.Facade over
JsonNode that implements JsonParser to allow
accessing contents of JSON tree in alternate form (stream of tokens).Helper class used for resolving type parameters for given class
Interface for deserializing type information from JSON content, to
type-safely deserialize data into correct polymorphic instance
(when type inclusion has been enabled for type handled).
Base class for all standard Jackson
TypeDeserializers.Class used for creating concrete
JavaType instances,
given various inputs.Interface that defines standard API for converting types
to type identifiers and vice versa.
Partial base implementation of
TypeIdResolver: all custom implementations
are strongly recommended to extend this class, instead of directly
implementing TypeIdResolver.Key that offers two "modes"; one with raw class, as used for
cases were raw class type is available (for example, when using
runtime type); and one with full generics-including.
Class that defines API that can be used to modify details of
JavaType instances constructed using TypeFactory.TypeIdResolver implementation
that converts using explicitly (annotation-) specified type names
and maps to implementation classes; or, in absence of annotated type name,
defaults to fully-qualified Class names (obtained with Class.getName()Simple recursive-descent parser for parsing canonical
JavaType
representations and constructing type instances.Interface that defines API used by members (like
AnnotatedMethod)
to dynamically resolve types they have.Dummy implementation for case where there are no bindings available
(for example, for static methods and fields)
Interface that defines builders that are configured based on
annotations (like
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.Abstraction used for allowing construction and registration of custom
TypeResolverBuilders, used in turn for actual construction of
TypeSerializers
and TypeDeserializers
for Polymorphic type handling.Interface for serializing type information regarding instances of specified
base type (super class), so that exact subtype can be properly deserialized
later on.
Simple deserializer that will call configured type deserializer, passing
in configured data deserializer, and exposing it all as a simple
deserializer.
Simple serializer that will call configured type serializer, passing
in configured data serializer, and exposing it all as a simple
serializer.
Simple identity value class that may be used as Serializable key
for entries that need to retain identity of some kind, but where
actual appearance of id itself does not matter.
Specialized
PropertyBindingException 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).Exception thrown during deserialization when there are object id that can't
be resolved.
Helper class for
UnresolvedForwardReference, to contain information about unresolved ids.Specialization of
BeanAsArraySerializer, optimized for handling
small number of properties where calls to property handlers can be
"unrolled" by eliminated looping.Special bogus "serializer" that will throw
MismatchedInputException
if an attempt is made to deserialize a value.Special bogus "serializer" that will throw
InvalidDefinitionException if its UnsupportedTypeSerializer.serialize(java.lang.Object, tools.jackson.core.JsonGenerator, tools.jackson.databind.SerializationContext)
gets invoked.Deserializer implementation that is used if it is necessary to bind content of
"unknown" type; something declared as basic
Object
(either explicitly, or due to type erasure).Object that is responsible for handling acrobatics related to
deserializing "unwrapped" values; sets of properties that are
embedded (inlined) as properties of parent JSON object.
Variant of
BeanPropertyWriter which will handle unwrapping
of JSON Object (including of properties of Object within surrounding
JSON object, and not as sub-object).Specialized
ValueSerializer to output UUIDs.Abstract class that defines API used by
ObjectMapper and ObjectReader
to deserialize Objects of arbitrary types from JSON, using
provided JsonParser (within current read context of DeserializationContext.This marker class is only to be used with annotations, to
indicate that no deserializer is configured.
Abstract class that defines API for objects that can be registered
(via
ObjectMapper configuration process,
using MapperBuilder)
to participate in constructing ValueDeserializer instances
(including but not limited to BeanDeserializers).Class that encapsulates details of value injection that occurs before
deserialization of a POJO.
Exception type used for generic failures during processing by
ValueInstantiator:
commonly used to wrap exceptions thrown by constructor or factory
method.Class that defines simple API implemented by objects that create value
instances.
Partial
ValueInstantiator implementation that is strongly recommended
to be used instead of directly extending ValueInstantiator itself.Delegating
ValueInstantiator implementation meant as a base type
that by default delegates methods to specified fallback instantiator.Tag-on interface to let deserializers indicate that they make use of
ValueInstantiators and there is access for instantiator assigned.Interface for providers of
ValueInstantiator instances.Basic "NOP" implementation that can be used as the base class for custom implementations.
This intermediate base class is used for all leaf nodes, that is,
all non-container (array or object) nodes, except for the
"missing node".
Abstract class that defines API used by
ObjectMapper (and
other chained ValueSerializers too) to serialize Objects of
arbitrary types into JSON, using provided JsonGenerator.This marker class is only to be used with annotations, to
indicate that no serializer is configured.
Abstract class that defines API for objects that can be registered
(via
ObjectMapper configuration process,
using MapperBuilder)
to participate in constructing ValueSerializer instances
(including but not limited to BeanSerializers).Helper class used for checking whether a property is visible
in the active view
Placeholder used by virtual properties as placeholder for
underlying
AnnotatedMember.BeanPropertyWriter implementation used with
JsonAppend
to add "virtual" properties in addition to regular ones.Interface for object used for determine which property elements
(methods, fields, constructors) can be auto-detected, with respect
to their visibility modifiers.
Simple value container used to keep track of Object Ids during
serialization.
Deserializer for Java 8 temporal
Years.Deserializer for Java 8 temporal
YearMonths.Serializer for Java 8 temporal
YearMonths.Serializer for Java 8 temporal
Years.