All Classes and Interfaces

Class
Description
Class used to define specific details of which variant of Base64 encoding/decoding is to be used.
Defines how the Base64Variant deals with Padding while reading
Container for commonly used Base64 variants: Base64Variants.MIME Base64Variants.MIME_NO_LINEFEEDS Base64Variants.PEM Base64Variants.MODIFIED_FOR_URL See entries for full description of differences.
Helper class used to implement more optimized parsing of BigDecimal for REALLY big values (over 500 characters)
This is a small utility class, whose main functionality is to allow simple reuse of raw byte/char buffers.
Helper entity used to control access to simple buffer recyling scheme used for some encoding, decoding tasks.
Helper class that is similar to ByteArrayOutputStream in usage, but more geared to Jackson use cases internally.
NonBlockingInputFeeder implementation used when feeding data as byte arrays.
NonBlockingInputFeeder implementation used when feeding data as ByteBuffer contents.
Replacement for BytesToNameCanonicalizer which aims at more localized memory access due to flattening of name quad data.
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.
This class is a kind of specialized type-safe Map, from char array to String value.
 
Abstraction that encloses information about content being processed -- input source or output target, streaming or not -- for the purpose of including pertinent information in location (see JsonLocation) objections, most commonly to be printed out as part of Exception messages.
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.
Helper class to support use of DataOutput for output, directly, without caller having to provide for implementation.
Default linefeed-based indenter, used by DefaultPrettyPrinter (unless overridden).
Default PrettyPrinter implementation that uses 2-space indentation with platform-default linefeeds.
This is a very simple indenter that only adds a single space for indentation.
Interface that defines objects that can produce indentation used to separate object entries and array values.
Dummy implementation that adds no indentation whatsoever
This class exposes a method to render a double as a string.
Helper class used if JsonParser.Feature.STRICT_DUPLICATE_DETECTION is enabled.
Specialized JsonGeneratorDelegate that allows use of TokenFilter for outputting a subset of content that caller tries to generate.
Specialized JsonParserDelegate that allows use of TokenFilter for outputting a subset of content that is visible to caller
This class exposes a method to render a float as a string.
Marker interface that is to be implemented by data format - specific features.
Simple tag interface used to mark schema objects that are used by some JsonParser and JsonGenerator implementations to further specify structure of expected format.
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.
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.
Exception type for read-side problems that are not direct decoding ("parsing") problems (those would be reported as JsonParseExceptions), but rather result from failed attempts to convert specific Java value out of valid but incompatible input value.
Handler class that can be used to decorate input sources.
Add-on interface used to indicate things that may be "blueprint" objects which can not be used as is, but are used for creating usable per-process (serialization, deserialization) instances, using Instantiatable.createInstance() method.
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.
Base class for all Jackson-produced checked exceptions.
Basic API implemented by Enums used for simple Jackson "features": on/off settings and capabilities exposed as something that can be internally represented as bit sets.
Container similar to EnumSet meant for storing sets of JacksonFeatures (usually Enums): main difference being that these sets are immutable.
Enumeration that defines legal encodings that can be used for JSON content, based on list of allowed encodings from JSON specification.
Specialized JsonParseException that is thrown when end-of-input is reached unexpectedly, either within token being decoded, or during skipping of intervening white-space that is not between root-level tokens (that is, is within JSON Object or JSON Array construct).
The main factory class of Jackson package, used to configure and construct reader (aka parser, JsonParser) and writer (aka generator, JsonGenerator) instances.
Enumeration that defines all on/off features that can only be changed for JsonFactory.
TSFBuilder implementation for constructing vanilla JsonFactory instances for reading/writing JSON encoded content.
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.
 
Intermediate base class shared by JSON-backed generators like UTF8JsonGenerator and WriterBasedJsonGenerator.
Object that encapsulates Location information used for reporting parsing (or potentially generation) errors, as well as current location within input streams.
Exception type for parsing problems, used when non-well-formed content (content that does not conform to JSON syntax as per specification) is encountered.
Base class that defines public API for reading JSON content.
Enumeration that defines all on/off features for parsers.
Enumeration of possible "native" (optimal) types that can be used for numbers.
Helper class that implements delegation pattern for JsonParser, to allow for simple overridability of basic parsing functionality.
Helper class that can be used to sequence multiple physical JsonParsers to create a single logical sequence of tokens, as a single JsonParser.
Convenience CharacterEscapes implementation that escapes Unicode characters `0x2028` and `0x2029` (in addition to characters escaped otherwise), which are apparently considered linefeeds as per newer Javascript specifications, and consequently problematic when using JSONP (see https://en.wikipedia.org/wiki/JSONP).
Implementation of JSON Pointer specification.
Simple TokenFilter implementation that takes a single JsonPointer and matches a single value accordingly.
Intermediate base class for all problems encountered when processing (parsing, generating) JSON content that are not pure I/O problems.
Extension of JsonStreamContext, which implements core methods needed, and also exposes more complete API to parser implementation classes.
Token reader (parser) features specific to JSON backend.
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.
Enumeration for basic token types used for returning results of parsing JSON content.
Interface defined to contain ids accessible with JsonToken.id().
Extension of JsonStreamContext, which implements core methods needed, and also exposes more complete API to generator implementation classes.
Token writer features specific to JSON backend.
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.
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.
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.
Generic implementation of PName used for "long" names, where long means that its byte (UTF-8) representation is 13 bytes or more.
Non-blocking parser implementation for JSON content that takes its input via ByteBuffer instance(s) passed.
Interface used by non-blocking JsonParser implementations to feed input to parse.
Non-blocking parser implementation for JSON content that takes its input via byte[] passed.
Intermediate base class for non-blocking JSON parsers.
Non-blocking parser base implementation for JSON content.
Helper class for efficient parsing of various JSON numbers.
 
Abstract class that defines the interface that JsonParser and JsonGenerator use to serialize and deserialize regular Java objects (POJOs aka Beans).
Handler class that can be used to decorate output destinations.
Automatically generated from PackageVersion.java.in during packageVersion-generate execution of maven-replacer-plugin in pom.xml.
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.
Interface for objects that implement pretty printer functionality, such as indentation.
 
This is a concrete implementation of JsonParser, which is based on a Reader to handle low-level character conversion tasks.
Container object used to contain optional information on content being parsed, passed to JsonParseException in case of exception being thrown; this may be useful for caller to display information on failure.
Type abstraction that represents Java type that has been resolved (i.e.
Efficient alternative to StringWriter, based on using segmented internal buffer.
Value class used with some PrettyPrinter implements
Interface that defines how Jackson package can interact with efficient pre-serialized or lazily-serialized and reused String representations.
String token that can lazily serialize String contained and then reuse that serialization later on.
Exception type used to indicate violations of stream constraints (for example StreamReadConstraints) when reading or writing content.
Set of on/off capabilities that a JsonParser for given format (or in case of buffering, original format) has.
The constraints to use for streaming reads: used to guard against malicious input by preventing processing of "too big" input constructs (values, structures).
 
Intermediate base class for all read-side streaming processing problems, including parsing and input value coercion problems.
Token reader (parser) features not-specific to any particular format backend.
Set of on/off capabilities that a JsonGenerator for given format (or in case of buffering, original format) has.
Intermediate base class for all read-side streaming processing problems, including parsing and input value coercion problems.
Token writer (generator) features not-specific to any particular format backend.
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.
Strategy class that can be implemented to specify actual inclusion/exclusion criteria for filtering, used by FilteringGeneratorDelegate.
Enumeration that controls how TokenFilter return values are interpreted.
Alternative variant of JsonStreamContext, used when filtering content being read or written (based on TokenFilter).
Intermediate base class for actual format-specific factories for constructing parsers (reading) and generators (writing).
Interface that defines objects that can read and write TreeNode instances using Streaming API.
Marker interface used to denote JSON Tree nodes, as far as the core package knows them (which is very little): mostly needed to allow ObjectCodec to have some level of interoperability.
TSFBuilder<F extends JsonFactory,B extends TSFBuilder<F,B>>
Since 2.10, Builder class is offered for creating token stream factories with difference configurations: with 3.x they will be fully immutable.
This generic abstract class is used for obtaining full generics type information by sub-classing; it must be converted to ResolvedType implementation (implemented by JavaType from "databind" bundle) to be used.
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 DataInput as the input source.
 
This is a concrete implementation of JsonParser, which is based on a InputStream as the input source.
 
Object that encapsulates versioning information of a component.
Interface that those Jackson components that are explicitly versioned will implement.
Functionality for supporting exposing of component Versions.
This is a simple value class used between core streaming and higher level databinding to pass information about type ids to write.
Enumeration of values that matches enum `As` from annotation `JsonTypeInfo`: separate definition to avoid dependency between streaming core and annotations packages; also allows more flexibility in case new values needed at this level of internal API.
JsonGenerator that outputs JSON content using a Writer which handles character encoding.