All Classes and Interfaces

Class
Description
Deserializer only used as placeholder for abstract types 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.
Shared base class used for anything on which annotations (included within a AnnotationMap).
 
 
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.
Abstract class that defines API used for introspecting annotation-based configuration for serialization and deserialization.
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.
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).
Enumeration that defines standard annotation sets available for configuring data binding aspects.
Interface that defines interface for collection of annotations.
Class similar to BeanPropertyWriter, but that will be used for serializing JsonAnyGetter annotated (Map) properties
Helper class that contains set of distinct builders for different arrays of primitive values.
 
 
 
 
 
 
 
Deprecated.
Since 1.9, use ObjectArrayDeserializer instead.
Deprecated.
Since 1.9, use PrimitiveArrayDeserializers instead.
Node class that represents Arrays mapped from Json content.
Deprecated.
Since 1.9 use StdArraySerializers
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.
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.
 
 
Abstract base class used to define specific details of which variant of Base64 encoding/decoding is to be used.
Container for commonly used Base64 variants.
Abstract base class common to all standard JsonNode implementations.
Default BeanDescription implementation.
 
Deprecated.
Since 1.9 just don't use
Deprecated.
Since 1.9 just don't use
Deprecated.
Since 1.9 just don't use
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).
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).
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, but possibly also from simple types like String values.
Builder class used for aggregating deserialization information about a POJO, in order to build a JsonDeserializer for deserializing intances.
Concrete deserializer factory class that adds full Bean deserializer construction logic using class introspection.
Standard configuration settings container class implementation.
Abstract class that defines API for objects that can be registered (for BeanDeserializerFactory to participate in constructing BeanDeserializer instances.
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.
Interface that defines API for filter objects use (as configured using JsonFilter) for filtering bean properties to serialize.
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 arbitrary bean objects
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 intances.
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.
Configuration settings container class for bean serializer factory
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.
This is a small utility class, whose main functionality is to allow simple reuse of raw byte/char buffers.
 
 
Helper class that is similar to ByteArrayOutputStream in usage, but more geared to Jackson use cases internally.
This class is used to determine the encoding of byte stream that is to contain JSON content.
A caching symbol table implementation used for canonicalizing JSON field names (as Names which are constructed directly from a byte-based input source).
 
Standard serializer for Calendar.
Abstract base class that defines interface for customizing character escaping aspects for String values, for formats that use escaping.
This class is a kind of specialized type-safe Map, from char array to String value.
 
 
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.
 
Deprecated.
Since 1.9, use ContainerDeserializerBase instead.
Basic serializer that can take JSON "Array" structure and construct a Collection instance, with typed contents.
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).
Helper class for constructing objects for comparing content values
Deprecated.
Since 1.9, use ContainerDeserializerBase instead.
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 types that contain element(s) of other types.
Deprecated.
Since 1.9 use StdContainerSerializers instead
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 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.
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.
This concrete sub-class implements property that is passed via Creator (constructor or static factory method).
Deprecated.
Starting with 1.7, functionality of this class has been implemented both in base SerializerFactory (see methods like SerializerFactory.withAdditionalSerializers(Serializers)) and through new Module API.
Serializer factory implementation that allows for configuring mapping between types (classes) and serializers to use, by using multiple types of overrides.
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.
Result object constructed by DataFormatDetector when requested to detect format of given input data.
 
 
Deprecated.
Since 1.9, use JsonNodeDeserializer instead.
Simple deserializer for handling Date 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.
Deprecated.
Moved to DefaultPrettyPrinter; will be removed in Jackson 2.0
Default PrettyPrinter implementation that uses 2-space indentation with platform-default linefeeds.
This is a very simple indenter that only every adds a single space for indentation.
Default linefeed-based indenter uses system-specific linefeeds and 2 spaces for indentation per level.
Dummy implementation that adds no indentation whatsoever
Object that contains baseline configuration for deserialization process.
Enumeration that defines togglable features that guide the serialization feature.
Context for deserialization process.
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.
Abstract class that defines API used by DeserializerProvider to obtain actual JsonDeserializer instances from multiple distinct factories.
Configuration settings container class for bean deserializer factory
Abstract class that defines API used by ObjectMapper and JsonDeserializers to obtain deserializers capable of re-constructing instances of handled type from JSON content.
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.
Deprecated.
As of 1.9, use Deserializers.Base instead
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.
Deprecated.
Since 1.9, use EnumDeserializer instead.
Deserializer class that can deserialize instances of specified Enum class from Strings and Integers.
Deserializer that uses a single-String static factory method for locating Enum values by String id.
Note: casting within this class is all messed up -- just could not figure out a way to properly deal with recursive definition of "EnumMapinvalid input: '<'K extends Enum, V>
Specialized serializer for EnumMaps.
Deprecated.
Since 1.9, use EnumResolver instead.
Helper class used to resolve String values (either JSON Object field names or regular String values) into Java Enum instances.
Deprecated.
Since 1.9 use EnumSerializer
Standard serializer used for Enum types.
Note: casting within this class is all messed up -- just could not figure out a way to properly deal with recursive definition of "EnumSetinvalid input: '<'K extends Enum, V>
 
Helper class used for storing String serializations of enumerations.
Helper class that is used to flatten JSON structure when using "external type id" (see JsonTypeInfo.As.EXTERNAL_PROPERTY).
 
Decorated BeanPropertyWriter that will filter out properties that are not to be included in currently active JsonView.
Interface for objects that providers instances of BeanPropertyFilter that match given ids.
Simple tag interface used to mark schema objects that are used by some JsonParser and JsonGenerator implementations to further specify structure of expected format.
Deprecated.
Since 1.9, use FromStringDeserializer instead.
Base class for simple deserializer which only accept JSON String values as the source.
 
 
As per [JACKSON-484], also need special handling for InetAddress...
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.
Simple replacement for Class (and/or various Type subtypes) that is used as part of single-path extends/implements chain to express specific relationship between one subtype and one supertype.
Interface that defines objects that can produce indentation used to separate object entries and array values.
Efficient implementation for serializing Lists that contains Strings and are random-accessible.
Simple serializer for InetAddress.
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.
Interface used to expose beginning of a data file to data format detection code.
Basic implementation that reads data from given InputStream and buffers it as necessary.
Handler class that can be used to decorate input sources.
Singleton class that adds a simple first-level cache in front of regular String.intern() functionality.
Numeric node that contains simple 32-bit integer values.
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.
Provide a fast thread-safe formatter/parser DateFormat for ISO8601 dates ONLY.
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.
AnnotationIntrospector implementation that handles standard Jackson annotations.
Jackson-specific annotation used for indicating that value of annotated property will be "injected", i.e.
JSON content type provider automatically configured to use both Jackson and JAXB annotations (in that order of priority).
Basic implementation of JAX-RS abstractions (MessageBodyReader, MessageBodyWriter) needed for binding JSON ("application/json") content to and from Java Objects ("POJO"s).
Marker interface used to indicate implementation classes (serializers, deserializers etc) that are standard ones Jackson uses; not custom ones that application has added.
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.
Deprecated.
Since 1.9 use StdJdkSerializers
Provider for deserializers that handle some basic data types for Joda date/time library.
 
Basic deserializer for
invalid reference
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.
Marker annotation that can be used to define a non-static, single-argument method, to be used as a "fallback" handler for all otherwise unrecognized properties found from Json content.
Class annotation that can be used to define which kinds of Methods are to be detected by auto-detection.
Enumeration for possible visibility thresholds (minimum visibility) that can be used to limit which methods (and fields) are auto-detected.
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 used to denote whether given instance (currently only used with JsonDeserializer) can be cached.
Marker annotation that can be used to define constructors and factory methods as one to use for instantiating new instances of the associated class.
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.
Enumeration that defines legal encodings that can be used for JSON content, based on list of allowed encodings from JSON specification.
The main factory class of Jackson package, used to configure and construct reader (aka parser, JsonParser) and writer (aka generator, JsonGenerator) instances.
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.
Exception type for exceptions during JSON writing, such as trying to output content in wrong context (non-matching end-array or end-object, for example).
Base class that defines public API for writing JSON content.
Enumeration that defines all togglable features for generators.
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.
 
Deprecated.
Use JsonProperty instead (deprecated since version 1.5)
Marker annotation that indicates that the annotated method or field is to be ignored by introspection-based serialization and deserialization functionality.
Annotation that can be used to either suppress serialization of properties (during serialization), or ignore processing of JSON properties read (during deserialization).
Marker annotation that indicates that all properties of annotated type are to be ignored during serialization and deserialization.
Object that encapsulates Location information used for reporting parsing (or potentially generation) errors, as well as current location within input streams.
Annotation used to indicate that annotated property is part of two-way linkage between fields; and that its role is "parent" (or "forward") link.
Checked exception used to signal fatal problems with mapping of content.
Simple bean class used to contain references.
Implementation if ExceptionMapper to send down a "400 Bad Request" response in the event that unmappable JSON is received.
Enumeration used to define kinds of methods that annotations like JsonAutoDetect apply to.
Base class for all JSON nodes, which form the basis of JSON Tree Model that Jackson implements.
Deprecated.
Since 1.9, use JsonNodeDeserializer instead.
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.
Deprecated.
Since 1.9.0: functionality demoted down to JsonParserBase
Exception type for parsing problems, used when non-well-formed content (content that does not conform to JSON syntax as per specification) is encountered.
Implementation of ExceptionMapper to send down a "400 Bad Request" in the event unparsable JSON is received.
Base class that defines public API for reading JSON content.
Enumeration that defines all togglable features for parsers.
Enumeration of possible "native" (optimal) types that can be used for numbers.
Intermediate base class used by all Jackson JsonParser implementations.
Helper class that implements delegation pattern for JsonParser, to allow for simple overridability of basic parsing functionality.
Intermediate base class used by all Jackson JsonParser implementations, but does not add any additional fields that depend on particular method of obtaining input.
Helper class that can be used to sequence multiple physical JsonParsers to create a single logical sequence of tokens, as a single JsonParser.
Container class that can be used to wrap any Object instances (including nulls), and will serialize embedded in JSONP wrapping.
Intermediate base class for all problems encountered when processing (parsing, generating) JSON content that are not pure I/O problems.
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.
Annotation that can be used to define ordering (possibly partial) to use when serializing object properties.
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.
Extension of JsonStreamContext, which implements core methods needed, and also exposes more complete API to parser implementation classes.
Annotation similar to XmlRootElement, used to indicate name to use for root-level wrapping, if wrapping is enabled.
A JsonNode that represents a JSON-Schema instance.
Deprecated.
Annotation that can be used to define JSON Schema definition for the annotated class.
Interface that is to replace JsonSerializable to allow for dynamic type information embedding.
Annotation used for configuring serialization aspects, by attaching to "getter" methods or fields, or to value classes.
Enumeration used with JsonSerialize.include() property to define which properties of Java Beans are to be included in serialization
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.
Specialized read-only map used for storing and accessing serializers by type.
Marker annotation that can be used to define a non-static, single-argument method to be used as a "setter" for a logical property as an alternative to recommended JsonProperty annotation (which was introduced in version 1.1).
Shared base class for streaming processing contexts used during reading and writing of Json content using Streaming API.
Helper class used for efficient encoding of JSON String values (including JSON field names) into Strings or UTF-8 byte arrays.
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).
Definition of a subtype, along with optional name.
Enumeration for basic token types used for returning results of parsing JSON content.
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 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 standard type inclusion mechanisms for type metadata.
Definition of different type identifiers that can be included in JSON during serialization, and used for deserialization.
This marker class that is only to be used with defaultImpl annotation property, to indicate that there is no default implementation specified.
Annotation used for binding logical name that the annotated class has.
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)
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.
Marker annotation similar to XmlValue that indicates that results of the annotated "getter" method (which means signature must be that of getters; non-void return type, no args) is to be used as the single value to serialize for the instance.
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.
Annotation used for indicating view(s) that the property that is defined by method or field annotated is part of.
General-purpose wrapper class that can be used to decorate serialized value with arbitrary literal prefix and suffix.
Extension of JsonStreamContext, which implements core methods needed, and also exposes more complete API to generator implementation classes.
Deprecated.
(since 1.6) Currently recommended annotation to use is JsonSerialize.include() (with values ALWAYS or NON_NULL)
Abstract class that defines API used for deserializing JSON content field names into Java Map keys.
This marker class is only to be used with annotations, to indicate that no deserializer is configured.
Interface that defines API for simple extensions that can provide additional deserializers for deserializer Map keys of various types, from JSON property names.
Node of a forward-only linked list.
Numeric node that contains simple 64-bit integer values.
Helper for simple bounded LRU maps used for reusing lookup values.
Deprecated.
Since 1.9, use MapDeserializer instead.
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.
Interface that defines functionality accessible through both serialization and deserialization configuration objects; accessors to mode-independent configuration settings and such.
Immutable container class used to store simple configuration settings.
Interface that actual Feature enumerations used by MapperConfig implementations must implement.
Helper class used to encapsulate details of configuring an ObjectMapper instance to be used for data binding, as well as accessing it.
Iterator exposed by ObjectMapper when binding sequence of objects.
Sub-class of JsonFactory that will create a proper ObjectCodec to allow seamless conversions between Json content and Java objects (POJOs).
Deprecated.
Since 1.9 use MapSerializer
Standard serializer implementation for serializing {link java.util.Map} types.
Type that represents "true" Java Map types.
Enumeration used to indicate strength of match between data format and piece of data (typically beginning of a data file).
Helper class needed to be able to efficiently access class member functions (Methods and Constructors) in Maps.
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.
Simple interface that defines API used to filter out irrelevant methods
 
PrettyPrinter implementation that adds no indentation, just implements everything necessary for value output to work as expected, and provide simpler extension points to allow for creating simple custom implementations that add specific decoration or overrides.
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.
Base class for tokenized names (key strings in objects) that have been tokenized from byte-based input sources (like InputStream.
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 5 to 8 bytes.
Specialized implementation of PName: can be used for short Strings that consists of 9 to 12 bytes.
Simple tag interface mostly to allow sorting by name
Simple container class for types with optional logical name, used as external identifier
Generic implementation of PName used for "long" names, where long means that its byte (UTF-8) representation is 13 bytes or more.
Marker class used with annotations to indicate "no class".
Intermediate base class for limited number of scalar types that should never include type information.
Dummy, "no-operation" implementation of AnnotationIntrospector.
This singleton value class is used to contain explicit JSON null value.
This is a simple dummy serializer that will just output literal JSON null value whenever serialization is requested.
 
 
Intermediate value node used for numeric nodes.
Basic 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).
Abstract class that defines the interface that JsonParser and JsonGenerator use to serialize and deserialize regular Java objects (POJOs aka Beans).
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.
Customized TypeResolverBuilder that provides type resolver builders used with so-called "default typing" (see ObjectMapper.enableDefaultTyping() for details).
Enumeration used with ObjectMapper.enableDefaultTyping() to specify what kind of types (classes) default typing should be used for.
Node that maps to JSON Object structures in JSON content.
For efficiency, let's share the "no fields" iterator...
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 isolating details of handling optional+external types (Joda datetime, javax.xml classes) from standard factories that offer them.
Handler class that can be used to decorate output destinations.
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.
Interface for objects that implement pretty printer functionality, such as indentation.
Base class for specialized primitive array builders.
Container for deserializers used for instantiating "primitive arrays", arrays that contain non-object java primitive types.
Object that is used to collect arguments for non-default creator (non-default-constructor, or argument-taking factory method) before creator can be called.
Helper class for BeanSerializerFactory that is used to construct BeanPropertyWriter instances.
Helper object used to check if given array object is null or empty
Helper object used to check if given Collection object is null or empty
Helper object used to check if given Map object is null or empty
Helper object used to check if given String object is null or empty
Class that defines how names of JSON properties ("external names") are derived from names of POJO methods and fields ("internal names"), in cases where they are not auto-detected and no explicit annotations exist for naming.
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.
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.
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 simple dummy serializer that will just output raw values by calling toString() on value to serialize.
This is a concrete implementation of JsonParser, which is based on a Reader to handle low-level character conversion tasks.
Deprecated.
Since 1.9 sub-classes should just include code from here as is.
Optimized lookup table for accessing two types of serializers; typed and non-typed.
Interface used to indicate deserializers that want to do post-processing after construction and being added to DeserializerProvider, but before being used.
Interface used to indicate serializers that want to do post-processing after construction and being added to SerializerProvider, but before being used.
Helper class for caching resolved root names.
Wrapper used when interface does not allow throwing a checked JsonMappingException
Deprecated.
Since 1.9 use SerializerBase instead.
 
Marker interface for schema-aware serializers.
Efficient alternative to StringWriter, based on using segmented internal buffer.
Generic handler for types that implement JsonSerializable.
Interface that defines how Jackson package can interact with efficient pre-serialized or lazily-serialized and reused String representations.
Generic handler for types that implement JsonSerializableWithType.
Object that contains baseline configuration for serialization process.
Enumeration that defines togglable features that guide the serialization feature.
String token that can lazily serialize String contained and then reuse that serialization later on.
Deprecated.
Since 1.9 use SerializerBase
Base class used by all standard serializers.
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.
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.
Abstract class that defines API used by SerializerProvider to obtain actual JsonSerializer instances from multiple distinct factories.
Configuration settings container class for bean serializer factory.
Abstract class that defines API used by ObjectMapper and JsonSerializers to obtain serializers capable of serializing instances of specific types.
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.
Deprecated.
As of 1.9, use Serializers.Base instead
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 settable properties of a bean: contains both type and name definitions, and reflection-based set functionality.
This concrete sub-class implements property that is set directly assigning to a Field.
This sub-class is used to handle special case of value being a non-static inner class.
Wrapper property that is used to handle managed (forward) properties (see [JACKSON-235] for more information).
This concrete sub-class implements property that is set using regular "setter" method.
To support [JACKSON-420] we need bit more indirection; this is used to produce artificial failure for primitives that don't accept JSON null as value.
This concrete sub-class implements Collection or Map property that is indirectly by getting the property value and directly modifying it.
Simple AbstractTypeResolver implementation, which is based on static mapping from abstract super types into sub types (concrete or abstract), but retaining generic parameterization.
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 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 Module implementation that allows registration of serializers and deserializers, and bean serializer and deserializer modifiers.
Simple implementation Serializers which allows registration of serializers based on raw (type erased class).
Simple types are defined as anything other than one of recognized container types (arrays, Collections, Maps).
 
Intermediate 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).
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.
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.
 
 
 
 
 
Standard serializer used for String[] values.
Dummy container class to group standard container serializers: serializers that can serialize things like Lists, Maps and such.
This is an optimized serializer for Lists that can be efficiently traversed by index (as opposed to others, such as LinkedList that can not}.
 
Default DateFormat implementation used by standard Date serializers and deserializers.
Default implementation of DeserializationContext.
Base class for common deserializers.
Deprecated.
Since 1.9, use StdDeserializer instead.
 
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.
 
 
Compared to plain old Date, SQL version is easier to deal with: mostly because it is more limited.
 
Deprecated.
Since 1.9 use StringDeserializer instead.
Default DeserializerProvider implementation.
Simple deserializer that will call configured type deserializer, passing in configured data deserializer, and exposing it all as a simple deserializer.
Class that providers access to serializers user for non-structured JDK types that are serializer as scalars; some using basic ToStringSerializer, others explicit serializers.
 
 
 
 
Also: default bean access will not do much good with Class.class.
For now, File objects get serialized by just outputting absolute (but not canonical) name as String value
Base class for simple key deserializers.
Deprecated.
Since 1.9, use StdKeyDeserializer instead.
Helper class used to contain simple/well-known key deserializers.
Specialized serializer that can be used as the generic key serializer, when serializing Maps to JSON Objects.
Deprecated.
Since 1.9 use StdKeySerializer instead
 
 
 
 
Base class for deserializers that handle types that are serialized as JSON scalars (non-structured, i.e.
Deprecated.
Since 1.9, use StdScalarDeserializer instead.
Default SerializerProvider implementation.
Container class for serializers used for handling standard JDK-provided types.
Serializer used for primitive boolean, as well as java.util.Boolean wrapper type.
Deprecated.
Since 1.9, use DateSerializer instead
This is the special serializer for regular Doubles (and primitive doubles)
 
This is the special serializer for regular Integers (and primitive ints)
Similar to StdSerializers.IntegerSerializer, but will not cast to Integer: instead, cast is to Number, and conversion is by calling Number.intValue().
 
As a fallback, we may need to use this serializer for other types of Numbers (custom types).
Deprecated.
Since 1.9, use DateSerializer instead
Deprecated.
Since 1.9, use DateSerializer instead
Compared to regular StdSerializers.UtilDateSerializer, we do use String representation here.
 
Deprecated.
Since 1.9, use StringSerializer instead
Deprecated.
Since 1.9, use DateSerializer instead
 
Default TypeResolverBuilder implementation.
Basic ValueInstantiator implementation, which only supports use of default constructor.
Deprecated.
Since 1.9, sub-classes should just embed code from here
 
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 supertypes to subtypes.
Helper class used to encapsulate rules that determine subtypes that are invalid to use, even with default typing, mostly due to security concerns.
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.
Value node that contains a text value.
Deserializer that builds on basic BeanDeserializer but override some aspects like instance construction.
Deprecated.
Since 1.9, use ThrowableDeserializer instead.
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 deserialization of TokenBuffer.
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)
Simple general purpose serializer, useful for any type for which Object.toString() returns the desired JSON value.
Deprecated.
Since 1.9 use ToStringSerializer
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).
 
Class used for creating concrete JavaType instances, given various inputs.
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.
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 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.
 
 
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).
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.
Since 1.9, use UntypedObjectDeserializer instead.
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).
 
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.
Class that defines simple API implemented by objects that create value instances.
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".
Object that encapsulates version information of a component, and is return by Versioned.version().
Interface that those Jackson components that are explicitly versioned will implement.
Functionality for supporting exposing of component Versions.
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.
JsonGenerator that outputs JSON content using a Writer which handles character encoding.