All Classes

Defines interface for resolvers that can resolve abstract types into concrete ones; either by using static mappings, or possibly by materializing implementations dynamically.

Object that represents non-static (and usually non-transient/volatile) fields of a class.

Object that represents method parameters, mostly so that associated annotations can be processed conveniently.

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

Simple helper class used to keep track of collection of Jackson Annotations associated with annotatable things (methods, constructors, classes).

Interface that defines interface for collection of annotations.

Helper class that contains set of distinct builders for different arrays of primitive values.

Node class that represents Arrays mapped from Json content.

Array types represent Java arrays, both primitive and object valued.

Type deserializer used with JsonTypeInfo.As.WRAPPER_ARRAY inclusion mechanism.

Type deserializer used with JsonTypeInfo.As.EXTERNAL_PROPERTY inclusion mechanism.

Type deserializer used with JsonTypeInfo.As.PROPERTY inclusion mechanism.

Type deserializer used with JsonTypeInfo.As.WRAPPER_OBJECT inclusion mechanism.

Abstract base class used to define specific details of which variant of Base64 encoding/decoding is to be used.

Abstract base class common to all standard JsonNode implementations.

Abstract factory base class that can provide deserializers for standard JDK classes, including collection classes and simple heuristics for "upcasting" commmon collection interface types (such as Collection).

Basic container for information gathered by ClassIntrospector to help in constructing serializers and deserializers.

Builder class used for aggregating deserialization information about a POJO, in order to build a JsonDeserializer for deserializing intances.

Standard configuration settings container class implementation.

Bean properties are logical entities that represent data Java objects ("beans", although more accurately POJOs) contain; and that are accessed using some combination of methods (getter, setter), field and constructor parameter.

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.

Serializer class that can serialize arbitrary bean objects

Builder class used for aggregating deserialization information about a POJO, in order to build a JsonSerializer for serializing intances.

Configuration settings container class for bean serializer factory

Helper class that contains functionality needed by both serialization and deserialization side.

Value node that contains Base64 encoded binary value, which will be output and stored as Json String value.

This is a small utility class, whose main functionality is to allow simple reuse of raw byte/char buffers.

This class is used to determine the encoding of byte stream that is to contain JSON content.

Abstract base class that defines interface for customizing character escaping aspects for String values, for formats that use escaping.

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 JsonSerializers.

Basic serializer that can take JSON "Array" structure and construct a Collection instance, with typed contents.

Fallback serializer for cases where Collection is not known to be of type for which more specializer serializer exists (such as index-accessible List).

Helper class for constructing objects for comparing content values

Intermediate base deserializer class that adds more shared accessor so that other classes can access information about contained (value) types

Intermediate base class for types that contain element(s) of other types.

Add-on interface that JsonDeserializers can implement to get a callback that can be used to create contextual instances of deserializer to use for handling properties 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.

This concrete sub-class implements property that is passed via Creator (constructor or static factory method).

Serializer factory implementation that allows for configuring mapping between types (classes) and serializers to use, by using multiple types of overrides.

Result object constructed by DataFormatDetector when requested to detect format of given input data.

Simple deserializer for handling Date values.

Numeric node that contains values that do not fit in simple integer (int, long) or floating point (double) values.

Default PrettyPrinter implementation that uses 2-space indentation with platform-default linefeeds.

Default linefeed-based indenter uses system-specific linefeeds and 2 spaces for indentation per level.

Object that contains baseline configuration for deserialization process.

Context for deserialization process.

Abstract class that defines API used by DeserializerProvider to obtain actual JsonDeserializer instances from multiple distinct factories.

Abstract class that defines API used by ObjectMapper and JsonDeserializers to obtain deserializers capable of re-constructing instances of handled type from JSON content.

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.

Note: casting within this class is all messed up -- just could not figure out a way to properly deal with recursive definition of "EnumMap, V>

Note: casting within this class is all messed up -- just could not figure out a way to properly deal with recursive definition of "EnumSet, V>

Helper class used for storing String serializations of enumerations.

Decorated BeanPropertyWriter that will filter out properties that are not to be included in currently active JsonView.

Simple tag interface used to mark schema objects that are used by some JsonParser and JsonGenerator implementations to further specify structure of expected format.

Base class for simple deserializer which only accept JSON String values as the source.

Kept protected as it's not meant to be extensible at this point

As per [JACKSON-522], also need special handling for InetAddress...

Helper class used for handling details of creating handler instances (things like JsonSerializers, JsonDeserializers, various type handlers) of specific types.

Interface that defines objects that can produce indentation used to separate object entries and array values.

Simple serializer for InetAddress.

Simple standard implementation which uses a simple Map to store values to inject, identified by simple String keys.

Basic implementation that reads data from given InputStream and buffers it as necessary.

Singleton class that adds a simple first-level cache in front of regular String.intern() functionality.

To limit number of configuration and state objects to pass, all contextual objects that need to be passed by the factory to readers and writers are combined under this object.

Utilities methods for manipulating dates in iso8601 format.

Meta-annotation (annotations used on other annotations) used for marking all annotations that are part of Jackson package.

Jackson-specific annotation used for indicating that value of annotated property will be "injected", i.e.

Basic implementation of JAX-RS abstractions (MessageBodyReader, MessageBodyWriter) needed for binding JSON ("application/json") content to and from Java Objects ("POJO"s).

Base class for type token classes used both to contain information and as keys for deserializers.

Annotation introspector that leverages JAXB annotations where applicable to JSON mapping.

Provider for deserializers that handle some basic data types for Joda date/time library.

Basic deserializer for DateTime.

Provider for serializers that handle some basic data types for Joda date/time library.

Marker annotation that can be used to define a non-static, no-argument method or member field as something of a reverse of JsonAnySetter method; basically being used like a getter but such that contents of the returned Map (type must be Map) are serialized as if they were actual properties of the bean that contains method/field with this annotations.

Class annotation that can be used to define which kinds of Methods are to be detected by auto-detection.

Annotation used to indicate that associated property is part of two-way linkage between fields; and that its role is "child" (or "back") link.

Marker annotation that can be used to define constructors and factory methods as one to use for instantiating new instances of the associated class.

Abstract class that defines API used by ObjectMapper (and other chained JsonDeserializers too) to deserialize Objects of arbitrary types from JSON, using provided JsonParser.

Enumeration that defines legal encodings that can be used for JSON content, based on list of allowed encodings from JSON specification.

Annotation used to indicate which logical filter is to be used for filtering out properties of type (class) annotated; association made by this annotation declaring ids of filters, and ObjectMapper (or objects it delegates to) providing matching filters by id.

Base class that defines public API for writing JSON content.

This base class implements part of API that a JSON generator exposes to applications, adds shared internal methods that sub-classes can use and adds some abstract methods sub-classes must implement.

Annotation that can be used to either suppress serialization of properties (during serialization), or ignore processing of JSON properties read (during deserialization).

Object that encapsulates Location information used for reporting parsing (or potentially generation) errors, as well as current location within input streams.

Checked exception used to signal fatal problems with mapping of content.

Implementation if ExceptionMapper to send down a "400 Bad Request" response in the event that unmappable JSON is received.

Base class for all JSON nodes, which form the basis of JSON Tree Model that Jackson implements.

Deserializer that can build instances of JsonNode from any JSON content, using appropriate JsonNode type.

Implementation of ExceptionMapper to send down a "400 Bad Request" in the event unparsable JSON is received.

Enumeration that defines all togglable features for parsers.

Intermediate base class used by all Jackson JsonParser implementations.

Intermediate base class used by all Jackson JsonParser implementations, but does not add any additional fields that depend on particular method of obtaining input.

Container class that can be used to wrap any Object instances (including nulls), and will serialize embedded in JSONP wrapping.

Marker annotation that can be used to define a non-static method as a "setter" or "getter" for a logical property (depending on its signature), or non-static object field to be used (serialized, deserialized) as a logical property.

Marker annotation that indicates that the annotated method or field should be serialized by including literal String value of the property as is, without quoting of characters.

Annotation similar to XmlRootElement, used to indicate name to use for root-level wrapping, if wrapping is enabled.

Interface that is to replace JsonSerializable to allow for dynamic type information embedding.

Enumeration used with JsonSerialize.include() property to define which properties of Java Beans are to be included in serialization

Abstract class that defines API used by ObjectMapper (and other chained JsonSerializers too) to serialize Objects of arbitrary types into JSON, using provided JsonGenerator.

Specialized read-only map used for storing and accessing serializers by type.

Shared base class for streaming processing contexts used during reading and writing of Json content using Streaming API.

Annotation used with JsonTypeInfo to indicate sub types of serializable polymorphic types, and to associate logical names used within JSON content (which is more portable than using physical Java class names).

Enumeration for basic token types used for returning results of parsing JSON content.

Annotation used for configuring details of if and how type information is used with JSON serialization and deserialization, to preserve information about actual class of Object instances.

Definition of different type identifiers that can be included in JSON during serialization, and used for deserialization.

Annotation used for binding logical name that the annotated class has.

Annotation used to indicate that a property should be serialized "unwrapped"; that is, if it would be serialized as JSON Object, its properties are instead included as properties of its containing Object.

Annotation that can be used to indicate a ValueInstantiator to use for creating instances of specified type.

Annotation used for indicating view(s) that the property that is defined by method or field annotated is part of.

Extension of JsonStreamContext, which implements core methods needed, and also exposes more complete API to generator implementation classes.

Abstract class that defines API used for deserializing JSON content field names into Java Map keys.

Interface that defines API for simple extensions that can provide additional deserializers for deserializer Map keys of various types, from JSON property names.

Numeric node that contains simple 64-bit integer values.

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.

Immutable container class used to store simple configuration settings.

Helper class used to encapsulate details of configuring an ObjectMapper instance to be used for data binding, as well as accessing it.

Sub-class of JsonFactory that will create a proper ObjectCodec to allow seamless conversions between Json content and Java objects (POJOs).

Standard serializer implementation for serializing {link java.util.Map} types.

Enumeration used to indicate strength of match between data format and piece of data (typically beginning of a data file).

Simple InputStream implementation that is used to "unwind" some data previously read from an input stream; so that as long as some of that data remains, it's returned; but as long as it's read, we'll just use data from the underlying original stream.

This singleton node class is generated to denote "missing nodes" along paths that do not exist.

Interface Jackson exposes to modules for purpose of registering extended functionality.

Specialized implementation of PName: can be used for short Strings that consists of at most 4 bytes.

Specialized implementation of PName: can be used for short Strings that consists of 9 to 12 bytes.

Simple container class for types with optional logical name, used as external identifier

Marker class used with annotations to indicate "no class".

Dummy, "no-operation" implementation of AnnotationIntrospector.

This is a simple dummy serializer that will just output literal JSON null value whenever serialization is requested.

Basic serializer that can serialize non-primitive arrays.

Helper class to use for constructing Object arrays by appending entries to create arrays of various lengths (length that is not known a priori).

This mapper (or, data binder, or codec) provides functionality for converting between Java objects (instances of JDK provided core classes, beans), and matching JSON constructs.

Enumeration used with ObjectMapper.enableDefaultTyping() to specify what kind of types (classes) default typing should be used for.

For efficiency, let's share the "no fields" iterator...

Builder object that can be used for per-serialization configuration of serialization parameters, such as JSON View and root type to use.

Handler class that can be used to decorate output destinations.

Helper class used for aggregating information about all possible properties of a POJO.

Interface for objects that implement pretty printer functionality, such as indentation.

Container for deserializers used for instantiating "primitive arrays", arrays that contain non-object java primitive types.

Helper class for BeanSerializerFactory that is used to construct BeanPropertyWriter instances.

Helper object used to check if given Collection object is null or empty

Helper object used to check if given String object is null or empty

A PropertyNamingStrategy that translates typical camel case Java property names to lower case JSON element names, separated by underscores.

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.

Base class for property values that need to be buffered during deserialization.

Simple helper class used for decoupling instantiation of optionally loaded handlers, like deserializers and deserializers for libraries that are only present on some platforms.

This is a concrete implementation of JsonParser, which is based on a Reader to handle low-level character conversion tasks.

Optimized lookup table for accessing two types of serializers; typed and non-typed.

Interface used to indicate serializers that want to do post-processing after construction and being added to SerializerProvider, but before being used.

Wrapper used when interface does not allow throwing a checked JsonMappingException

Efficient alternative to StringWriter, based on using segmented internal buffer.

Interface that defines how Jackson package can interact with efficient pre-serialized or lazily-serialized and reused String representations.

Object that contains baseline configuration for serialization process.

String token that can lazily serialize String contained and then reuse that serialization later on.

Base class used by all standard serializers.

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.

Configuration settings container class for bean serializer factory.

Interface that defines API for simple extensions that can provide additional serializers for various types.

Base class for settable properties of a bean: contains both type and name definitions, and reflection-based set functionality.

This sub-class is used to handle special case of value being a non-static inner class.

This concrete sub-class implements property that is set using regular "setter" method.

This concrete sub-class implements Collection or Map property that is indirectly by getting the property value and directly modifying it.

Simple BeanPropertyFilter implementation that only uses property name to determine whether to serialize property as is, or to filter it out.

Filter implementation which defaults to serializing all properties, except for ones explicitly listed to be filtered out.

Simple FilterProvider implementation that just stores direct id-to-filter mapping.

Simple Module implementation that allows registration of serializers and deserializers, and bean serializer and deserializer modifiers.

Simple types are defined as anything other than one of recognized container types (arrays, Collections, Maps).

Intermediate base class for Lists, Collections and Arrays that contain static (non-dynamic) value types.

Base class for serializers that will output contents as JSON arrays.

Unlike other integral number array serializers, we do not just print out byte values as numbers.

Dummy container class to group standard container serializers: serializers that can serialize things like Lists, Maps and such.

Default implementation of DeserializationContext.

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.

Default DeserializerProvider implementation.

Class that providers access to serializers user for non-structured JDK types that are serializer as scalars; some using basic ToStringSerializer, others explicit serializers.

For now, File objects get serialized by just outputting absolute (but not canonical) name as String value

Specialized serializer that can be used as the generic key serializer, when serializing Maps to JSON Objects.

Base class for deserializers that handle types that are serialized as JSON scalars (non-structured, i.e.

Default SerializerProvider implementation.

Serializer used for primitive boolean, as well as java.util.Boolean wrapper type.

This is the special serializer for regular Doubles (and primitive doubles)

This is the special serializer for regular Integers (and primitive ints)

Compared to regular StdSerializers.UtilDateSerializer, we do use String representation here.

Basic ValueInstantiator implementation, which only supports use of default constructor.

Helper object used for handling registration on resolving of supertypes to subtypes.

TextBuffer is a class similar to StringBuffer, with following differences: TextBuffer uses segments character arrays, to avoid having to do additional array copies when array is not big enough.

Deserializer that builds on basic BeanDeserializer but override some aspects like instance construction.

Simple deserializer for handling Timestamp values.

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 serialization of TokenBuffer; and since it is part of core package, it can not implement JsonSerializable (which is only included in the mapper package)

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).

Class used for creating concrete JavaType instances, given various inputs.

This class is used to pass full generics type information, and avoid problems with type erasure (that basically removes most usable type references from runtime Class objects).

Interface for serializing type information regarding instances of specified base type (super class), so that exact subtype can be properly deserialized later on.

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.

Class that defines simple API implemented by objects that create value instances.

Basic "NOP" implementation that can be used as the base class for custom implementations.

Object that encapsulates version information of a component, and is return by Versioned.version().

Functionality for supporting exposing of component Versions.

Default standard implementation is purely based on visibility modifier of given class members, and its configured minimum levels.