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 target
Enumeration 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) properties
We 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.
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.
Helper class to contain largish number of parameters that need to be passed during Creator introspection.
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 POJO, in order to build a JsonDeserializer for deserializing instances.
Concrete deserializer factory class that adds full Bean deserializer construction logic using class introspection.
Abstract class that defines API for objects that can be registered to participate in constructing JsonDeserializer instances (via DeserializerFactory).
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 needed
Simple 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.
Deprecated.
Since 2.3: use PropertyFilter instead.
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 JsonSerializer 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.
Abstract class that defines API for objects that can be registered (for BeanSerializerFactory to participate in constructing BeanSerializer instances.
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.
Standard serializer for Calendar.
Helper class used to introspect features of POJO value classes used with Jackson.
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)
Key class, used as an efficient and accurate key for locating per-class values, such as JsonSerializers.
TypeIdResolver implementation that converts between fully-qualified Java class names and (JSON) Strings.
Also: default bean access will not do much good with Class.class.
Simple helper class used to keep track of 'call stack' for classes being referenced (as well as unbound variables)
 
Value class used for caching Constructor declarations; used because caching done by JDK appears to be somewhat inefficient for some use cases.
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).
Specialized lookup class that implements functionality similar to Map, but for special case of key always being String and using more compact (and memory-access friendly) hashing scheme.
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.
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).
Helper class used for storing and accessing per-call attributes.
 
Add-on interface that 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.
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.
Add-on interface that 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.
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.
Provider for serializers of XML types that are part of full JDK 1.5, but that some alleged 1.5 platforms are missing (Android, GAE).
 
 
 
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 SerializerProvider, context objects passed through data-binding process.
Intermediate base class for all databind level processing problems, as distinct from stream-level problems or I/O issues below.
Alternative to DataFormatDetector that needs to be used when using data-binding.
We need sub-class here as well, to be able to access efficiently.
Result class, similar to DataFormatMatcher
Interface that defines interaction with data type specific configuration features.
Immutable value class that contains settings for multiple DatatypeFeature enumerations.
Container class for core JDK date/time type deserializers.
 
 
Simple deserializer for handling Date values.
Compared to plain old Date, SQL version is easier to deal with: mostly because it is more limited.
Simple deserializer for handling Timestamp values.
For efficiency, we will serialize Dates as longs, instead of potentially more readable Strings.
 
Numeric node that contains values that do not fit in simple integer (int, long) or 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.
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(com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.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.
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
Standard implementation used by ObjectMapper: adds methods only exposed to ObjectMapper, as well as constructors.
Concrete implementation that defines factory method(s), defined as final.
Base class that simplifies implementations of JsonDeserializers 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.
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 JsonDeserializer 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 serializers that allows parsing DOM Documents from JSON Strings.
 
 
 
Numeric node that contains 64-bit ("double precision") floating point values simple 32-bit integer values.
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 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.
This concrete sub-class implements property that is set directly assigning to a Field.
For now, File objects get serialized by just outputting absolute (but not canonical) name as String value
Decorated BeanPropertyWriter that will filter out properties that are not to be included in currently active JsonView.
Interface for objects that providers instances of PropertyFilter that match given ids.
JsonNode implementation for efficiently containing 32-bit `float` values.
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).
"Chameleon" deserializer that works on simple types that are deserialized from a simple String.
Helper class used for handling details of creating handler instances (things like JsonSerializers, JsonDeserializers, various type handlers) of specific types.
Specialized JsonMappingException 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.
Intermediate exception type used as the base class for all JsonMappingExceptions 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.
Deprecated.
Use StdDateFormat instead
Deprecated.
 
Specialized SimpleType for types that are allow iteration over Collection(-like) types: this includes types like Iterator.
 
AnnotationIntrospector implementation that handles standard Jackson annotations.
Marker interface used to indicate implementation classes (serializers, deserializers etc) that are standard ones Jackson uses; not custom ones that application has added.
Since v2.15, Java7HandlersImpl is no longer loaded via reflection.
Since v2.15, this is no longer loaded via reflection.
To support Java7-incomplete platforms, we will offer support for JDK 7 annotations through this class, loaded dynamically; if loading fails, support will be missing.
 
Base class for type token classes used both to contain information and as keys for deserializers.
Helper class used to contain logic for deserializing "special" containers from java.util.Collections and java.util.Arrays.
Helper class to support some of JDK 14 (and later) features without Jackson itself being run on (or even built with) Java 14.
Container class that contains serializers for JDK types that require special handling for some reason.
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.
Abstract class that defines API used by ObjectMapper (and other chained JsonDeserializers too) to deserialize Objects of arbitrary types from JSON, using provided JsonParser.
This marker class is only to be used with annotations, to indicate that no deserializer is configured.
 
Interface JsonSerializer 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.
For JsonLocation, we should be able to just implement ValueInstantiator (not that explicit one would be very hard but...)
 
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-format specific ObjectMapper implementation.
Base implementation for "Vanilla" ObjectMapper, used with JSON dataformat backend.
Checked exception used to signal fatal problems with mapping of content, distinct from low-level I/O problems (signaled using simple IOExceptions) or data encoding/decoding problems (signaled with StreamReadException, StreamWriteException).
Simple bean class used to contain references.
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).
Deserializer that can build instances of JsonNode from any JSON content, using appropriate JsonNode type.
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.
Deprecated.
Since 2.2, we recommend use of external JSON Schema generator module
Interface that can be implemented by objects that know how to serialize themselves to JSON, using JsonGenerator (and SerializerProvider if necessary).
Base class with minimal implementation, as well as couple of extension methods that core Jackson databinding makes use of.
Deprecated.
Since 2.15, we recommend use of external JSON Schema generator module
Annotation used for configuring serialization aspects, by attaching to "getter" methods or fields, or to value classes.
Deprecated.
Enumeration used with JsonSerialize.typing() property to define whether type detection is based on dynamic runtime type (DYNAMIC) or declared type (STATIC).
Abstract class that defines API used by ObjectMapper (and other chained JsonSerializers 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.
 
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.
Default PolymorphicTypeValidator used unless explicit one is constructed (and, in 2.11, MapperFeature.BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES not enabled).
Node of a forward-only linked list.
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.
An interface describing the required API for the Jackson-databind Type cache.
Helper for simple bounded maps used for reusing lookup values.
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.
Basic serializer that can take JSON "Object" structure and construct a Map 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.
Jackson 3 will introduce fully immutable, builder-based system for constructing ObjectMappers.
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.
Sub-class of JsonFactory that will create a proper ObjectCodec to allow seam-less conversions between JSON content and Java objects (POJOs).
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 JsonDeserializer.deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.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 JsonMappingExceptions 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.
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.
Mutable version of CoercionConfig (or rather, extended API) exposed during configuration phase of ObjectMapper construction (via JsonMapper.builder()).
Extension of ConfigOverride that allows changing of contained configuration settings.
Simple tag interface mostly to allow sorting by name.
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).
 
 
Utilities for graal native image support; mostly to improve error message handling in case of missing information for native image.
 
 
Marker class used with annotations to indicate "no class".
Deprecated.
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 JsonDeserializer 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 primitve number types and their wrapper counterparts (like Integer).
Shared base class for actual primitive/wrapper number 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 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 alternatives
Object 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.
Customized TypeResolverBuilder that provides type resolver builders used with so-called "default typing" (see ObjectMapper.activateDefaultTyping(PolymorphicTypeValidator) for details).
Enumeration used with ObjectMapper.activateDefaultTyping(PolymorphicTypeValidator) to specify what kind of types (classes) default typing should be used for.
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.
Helper class used for containing settings specifically related to (re)configuring JsonGenerator constructed for writing output.
As a minor optimization, we will make an effort to pre-fetch a serializer, or at least relevant TypeSerializer, if given enough information.
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.
Base class for specialized primitive array builders.
Container for deserializers used for instantiating "primitive arrays", arrays that contain non-object java primitive types.
A hash table supporting full concurrency of retrievals, adjustable expected concurrency for updates, and a maximum capacity to bound the map by.
A builder that creates PrivateMaxEntriesMap instances.
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 JsonMappingExceptions 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.
Deprecated.
Since 2.12 use PropertyNamingStrategies.KebabCaseStrategy instead (see databind#2715 for reason for deprecation)
Deprecated.
Since 2.12 use PropertyNamingStrategies.LowerCaseStrategy instead (see databind#2715 for reason for deprecation)
Deprecated.
Since 2.12 use PropertyNamingStrategies.LowerDotCaseStrategy instead (see databind#2715 for reason for deprecation)
Deprecated.
Since 2.12 deprecated.
Deprecated.
Since 2.12 use PropertyNamingStrategies.SnakeCaseStrategy instead (see databind#2715 for reason for deprecation)
Deprecated.
Since 2.12 use PropertyNamingStrategies.UpperCamelCaseStrategy instead (see databind#2715 for reason for deprecation)
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.
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.
Interface used to indicate deserializers that want to do post-processing after construction but before being returned to caller (and possibly cached) and used.
Interface used to indicate serializers that want to do post-processing after construction and being added to SerializerProvider, but before being used.
Internal placeholder type used for self-references.
Helper class for caching resolved root names.
Wrapper used when interface does not allow throwing a checked JsonMappingException
Deprecated.
Since 2.15, we recommend use of external JSON Schema generator module
Writer class similar to ObjectWriter, except that it can be used for writing sequences of values, not just a single value.
Generic handler for types that implement JsonSerializable.
Object that contains baseline configuration for serialization process.
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 SerializerProvider to obtain actual JsonSerializer instances from multiple distinct factories.
Configuration settings container class for SerializerFactory implementations.
Class that defines API used by ObjectMapper and JsonSerializers to obtain serializers capable of serializing instances of specific types; as well as the default implementation of the functionality.
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.
 
 
 
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).
Simple implementation of ClassIntrospector.MixInResolver that just uses a Map for containing mapping from target to mix-in classes.
Vanilla Module 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).
 
Serializer implementation for Blob to write as binary (for JSON and other formats Base64-encoded String, for binary formats as true binary).
Compared to regular Date serialization, we do use String representation here.
 
 
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.
Dummy container class to group standard homogenous 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).
Standard implementation of Converter that supports explicit type access, instead of relying type detection of generic type parameters.
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.
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.
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.
Class that providers access to serializers user for non-structured JDK types that are serializer as scalars; some using basic ToStringSerializer, others explicit serializers.
 
 
 
Default KeyDeserializer implementation used for most Map types Jackson supports.
Helper class used to contain simple/well-known key deserializers.
Deprecated.
Since 2.8, use StdKeySerializers.Default instead.
 
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.
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.
 
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.
 
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.
Value node that contains a text value.
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 JsonStreamContext 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 JsonSerializable (which is only included in the mapper package)
Simple general purpose serializer, useful for any type for which Object.toString() returns the desired JSON 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).
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.
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.
 
Specialized 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).
Exception thrown during deserialization when there are object id that can't be resolved.
Helper class for UnresolvedForwardReference, to contain information about unresolved ids.
Special bogus "serializer" that will throw MismatchedInputException if an attempt is made to deserialize a value.
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).
Deprecated.
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 JsonSerializer to output UUIDs.
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.
 
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".
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.
Default standard implementation is purely based on visibility modifier of given class members, and its configured minimum levels.
 
Simple value container used to keep track of Object Ids during serialization.