All Classes

Deserializer only used for abstract types used as placeholders during polymorphic type handling deserialization.

Shared base class used for anything on which annotations (included within a AnnotationMap).

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.

Intermediate base class that encapsulates features that constructors and methods share.

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.

Enumeration that defines standard annotation sets available for configuring data binding aspects.

Class similar to BeanPropertyWriter, but that will be used for serializing JsonAnyGetter annotated (Map) properties

Base class for serializers that will output contents as JSON arrays; typically serializers used for Collection and array types.

Type serializer that will embed type information in an array, as the first element, and actual value as the second element.

Type serializer that preferably embeds type information as an "external" type property; embedded in enclosing JSON object.

Type serializer that preferably embeds type information as an additional JSON Object property, if possible (when resulting serialization would use JSON Object).

Type wrapper that tries to use an extra JSON Object, with a single entry that has type name as key, to serialize type information.

Container for commonly used Base64 variants.

Default BeanDescription implementation.

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

Deserializer class that can deserialize instances of arbitrary bean objects, usually from JSON Object structs, but possibly also from simple types like String values.

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 (for BeanDeserializerFactory to participate in constructing BeanDeserializer instances.

Interface that defines API for filter objects use (as configured using JsonFilter) for filtering bean properties to serialize.

Base bean property handler class, which implements common parts of reflection-based functionality for accessing a property value and serializing it.

Base class both for the standard bean serializer, and couple of variants that only differ in small details.

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.

Numeric node that contains simple 64-bit integer values.

This concrete value class is used to contain boolean (true / false) values.

Helper class that is similar to ByteArrayOutputStream in usage, but more geared to Jackson use cases internally.

This class is basically a caching symbol table implementation used for canonicalizing Names, constructed directly from a byte-based input source.

Standard serializer for Calendar.

This class is a kind of specialized type-safe Map, from char array to String value.

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)

TypeIdResolver implementation that converts between fully-qualified Java class names and (JSON) Strings.

Type that represents things that act similar to Collection; but may or may not be instances of that interface.

Type that represents Java Collection types (Lists, Sets).

This intermediate base class is used for all container nodes, specifically, array and object nodes.

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.

Container deserializers that handle "core" XML types: ones included in standard JDK 1.5.

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 instantiator later on.

Simple helper class that allows data format (content type) auto-detection, given an ordered set of JsonFactory instances to use for actual low-level detection.

For efficiency, we will serialize Dates as longs, instead of potentially more readable Strings.

This is a very simple indenter that only every adds a single space for indentation.

Dummy implementation that adds no indentation whatsoever

Enumeration that defines togglable features that guide the serialization feature.

This is the class that can be registered (via DeserializationConfig object owner by ObjectMapper) to get calledn when a potentially recoverable problem is encountered during deserialization process.

Configuration settings container class for bean deserializer factory

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

Deserializer that uses a single-String static factory method for locating Enum values by String id.

Specialized serializer for EnumMaps.

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.

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 JsonGenerationException if its FailingSerializer.serialize(java.lang.Object, org.codehaus.jackson.JsonGenerator, org.codehaus.jackson.map.SerializerProvider) gets invoked.

Interface for objects that providers instances of BeanPropertyFilter that match given ids.

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.

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.

Value node that contains a text value.

We also want to directly support deserialization of TokenBuffer.

Simple general purpose serializer, useful for any type for which Object.toString() returns the desired JSON value.

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 that defines standard API for converting types to type identifiers and vice versa.

Class that defines API that can be used to modify details of JavaType instances constructed using TypeFactory.

Simple recursive-descent parser for parsing canonical JavaType representations and constructing type instances.

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.

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

Variant of BeanPropertyWriter which will handle unwrapping of JSON Object (including of properties of Object within surrounding JSON object, and not as sub-object).

Since JDK does not come with UTF-32/UCS-4, let's implement a simple decoder to use.

This is a concrete implementation of JsonParser, which is based on a InputStream as the input source.

Class that encapsulates details of value injection that occurs before deserialization of a POJO.

Interface for providers of ValueInstantiator instances.

This intermediate base class is used for all leaf nodes, that is, all non-container (array or object) nodes, except for the "missing node".

Interface that those Jackson components that are explicitly versioned will implement.

Interface for object used for determine which property elements (methods, fields, constructors) can be auto-detected, with respect to their visibility modifiers.

JsonGenerator that outputs JSON content using a Writer which handles character encoding.