# All Classes and Interfaces

Class
Description
Base64Variant
Class used to define specific details of which variant of Base64 encoding/decoding is to be used.
Base64Variant.PaddingReadBehaviour
Defines how the Base64Variant deals with Padding while reading
Base64Variants
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.
BigDecimalParser
Internal Jackson Helper class used to implement more optimized parsing of `BigDecimal` for REALLY big values (over 500 characters).
BigIntegerParser
Helper class used to implement more optimized parsing of `BigInteger` for REALLY big values (over 500 characters).
BufferRecycler
This is a small utility class, whose main functionality is to allow simple reuse of raw byte/char buffers.
BufferRecyclers
Deprecated.
Since 2.16 recycling aspects are handled via `RecyclerPool`.
ByteArrayBuilder
Helper class that is similar to `ByteArrayOutputStream` in usage, but more geared to Jackson use cases internally.
ByteArrayFeeder
`NonBlockingInputFeeder` implementation used when feeding data as byte arrays.
ByteBufferFeeder
`NonBlockingInputFeeder` implementation used when feeding data as `ByteBuffer` contents.
ByteQuadsCanonicalizer
Replacement for `BytesToNameCanonicalizer` which aims at more localized memory access due to flattening of name quad data.
ByteSourceJsonBootstrapper
This class is used to determine the encoding of byte stream that is to contain JSON content.
CharacterEscapes
Abstract base class that defines interface for customizing character escaping aspects for String values, for formats that use escaping.
CharsToNameCanonicalizer
This class is a kind of specialized type-safe Map, from char array to String value.
CharTypes
ContentReference
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.
DataFormatDetector
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.
DataFormatMatcher
Result object constructed by `DataFormatDetector` when requested to detect format of given input data.
DataOutputAsStream
Helper class to support use of `DataOutput` for output, directly, without caller having to provide for implementation.
DefaultIndenter
Default linefeed-based indenter, used by `DefaultPrettyPrinter` (unless overridden).
DefaultPrettyPrinter
Default `PrettyPrinter` implementation that uses 2-space indentation with platform-default linefeeds.
DefaultPrettyPrinter.FixedSpaceIndenter
This is a very simple indenter that only adds a single space for indentation.
DefaultPrettyPrinter.Indenter
Interface that defines objects that can produce indentation used to separate object entries and array values.
DefaultPrettyPrinter.NopIndenter
Dummy implementation that adds no indentation whatsoever
DupDetector
Helper class used if `JsonParser.Feature.STRICT_DUPLICATE_DETECTION` is enabled.
ErrorReportConfiguration
Container for configuration values used when handling errorneous token inputs.
ErrorReportConfiguration.Builder
FilteringGeneratorDelegate
Specialized `JsonGeneratorDelegate` that allows use of `TokenFilter` for outputting a subset of content that caller tries to generate.
FilteringParserDelegate
Specialized `JsonParserDelegate` that allows use of `TokenFilter` for outputting a subset of content that is visible to caller
FormatFeature
Marker interface that is to be implemented by data format - specific features.
FormatSchema
Simple tag interface used to mark schema objects that are used by some `JsonParser` and `JsonGenerator` implementations to further specify structure of expected format.
GeneratorBase
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.
InputAccessor
Interface used to expose beginning of a data file to data format detection code.
InputAccessor.Std
Basic implementation that reads data from given `InputStream` and buffers it as necessary.
InputCoercionException
Exception type for read-side problems that are not direct decoding ("parsing") problems (those would be reported as `JsonParseException`s), but rather result from failed attempts to convert specific Java value out of valid but incompatible input value.
InputDecorator
Handler class that can be used to decorate input sources.
Instantiatable<T>
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.
InternCache
Singleton class that adds a simple first-level cache in front of regular String.intern() functionality.
IOContext
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.
JacksonException
Base class for all Jackson-produced checked exceptions.
JacksonFeature
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.
JacksonFeatureSet<F extends JacksonFeature>
Container similar to `EnumSet` meant for storing sets of `JacksonFeature`s (usually `Enum`s): main difference being that these sets are immutable.
JsonEncoding
Enumeration that defines legal encodings that can be used for JSON content, based on list of allowed encodings from JSON specification.
JsonEOFException
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).
JsonFactory
The main factory class of Jackson package, used to configure and construct reader (aka parser, `JsonParser`) and writer (aka generator, `JsonGenerator`) instances.
JsonFactory.Feature
Enumeration that defines all on/off features that can only be changed for `JsonFactory`.
JsonFactoryBuilder
`TSFBuilder` implementation for constructing vanilla `JsonFactory` instances for reading/writing JSON encoded content.
JsonGenerationException
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).
JsonGenerator
Base class that defines public API for writing JSON content.
JsonGenerator.Feature
Enumeration that defines all togglable features for generators.
JsonGeneratorDecorator
Simple interface to allow adding decorators around `JsonGenerator`s.
JsonGeneratorDelegate
JsonGeneratorImpl
Intermediate base class shared by JSON-backed generators like `UTF8JsonGenerator` and `WriterBasedJsonGenerator`.
JsonLocation
Object that encapsulates Location information used for reporting parsing (or potentially generation) errors, as well as current location within input streams.
JsonParseException
Exception type for parsing problems, used when non-well-formed content (content that does not conform to JSON syntax as per specification) is encountered.
JsonParser
Base class that defines public API for reading JSON content.
JsonParser.Feature
Enumeration that defines all on/off features for parsers.
JsonParser.NumberType
Enumeration of possible "native" (optimal) types that can be used for numbers.
JsonParserDelegate
Helper class that implements delegation pattern for `JsonParser`, to allow for simple overridability of basic parsing functionality.
JsonParserSequence
Helper class that can be used to sequence multiple physical `JsonParser`s to create a single logical sequence of tokens, as a single `JsonParser`.
JsonpCharacterEscapes
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).
JsonPointer
Implementation of JSON Pointer specification.
JsonPointerBasedFilter
Simple `TokenFilter` implementation that takes a single `JsonPointer` and matches a single value accordingly.
JsonProcessingException
Intermediate base class for all problems encountered when processing (parsing, generating) JSON content that are not pure I/O problems.
JsonReadContext
Extension of `JsonStreamContext`, which implements core methods needed, and also exposes more complete API to parser implementation classes.
JsonReadFeature
Token reader (parser) features specific to JSON backend.
JsonRecyclerPools
Set of `RecyclerPool` implementations to be used by the default JSON-backed `JsonFactory` for recycling `BufferRecycler` containers.
JsonRecyclerPools.BoundedPool
`RecyclerPool` implementation that uses a bounded queue (`ArrayBlockingQueue` for recycling instances.
JsonRecyclerPools.ConcurrentDequePool
`RecyclerPool` implementation that uses `ConcurrentLinkedDeque` for recycling instances.
JsonRecyclerPools.LockFreePool
`RecyclerPool` implementation that uses a lock free linked list for recycling instances.
JsonRecyclerPools.NonRecyclingPool
Dummy `RecyclerPool` implementation that does not recycle anything but simply creates new instances when asked to acquire items.
JsonRecyclerPools.ThreadLocalPool
`ThreadLocal`-based `RecyclerPool` implementation used for recycling `BufferRecycler` instances: see `RecyclerPool.ThreadLocalPoolBase` for full explanation of functioning.
JsonStreamContext
Shared base class for streaming processing contexts used during reading and writing of Json content using Streaming API.
JsonStringEncoder
Helper class used for efficient encoding of JSON String values (including JSON field names) into Strings or UTF-8 byte arrays.
JsonToken
Enumeration for basic token types used for returning results of parsing JSON content.
JsonTokenId
Interface defined to contain ids accessible with `JsonToken.id()`.
JsonWriteContext
Extension of `JsonStreamContext`, which implements core methods needed, and also exposes more complete API to generator implementation classes.
JsonWriteFeature
Token writer features specific to JSON backend.
MatchStrength
Enumeration used to indicate strength of match between data format and piece of data (typically beginning of a data file).
MergedStream
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.
MinimalPrettyPrinter
`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.
Name
Base class for tokenized names (key strings in objects) that have been tokenized from byte-based input sources (like `InputStream`.
Name1
Specialized implementation of PName: can be used for short Strings that consists of at most 4 bytes.
Name2
Specialized implementation of PName: can be used for short Strings that consists of 5 to 8 bytes.
Name3
Specialized implementation of PName: can be used for short Strings that consists of 9 to 12 bytes.
NameN
Generic implementation of PName used for "long" names, where long means that its byte (UTF-8) representation is 13 bytes or more.
NonBlockingByteBufferJsonParser
Non-blocking parser implementation for JSON content that takes its input via `ByteBuffer` instance(s) passed.
NonBlockingInputFeeder
Interface used by non-blocking `JsonParser` implementations to feed input to parse.
NonBlockingJsonParser
Non-blocking parser implementation for JSON content that takes its input via `byte[]` passed.
NonBlockingJsonParserBase
Intermediate base class for non-blocking JSON parsers.
NonBlockingUtf8JsonParserBase
Non-blocking parser base implementation for JSON content.
NumberInput
Helper class for efficient parsing of various JSON numbers.
NumberOutput
ObjectCodec
Abstract class that defines the interface that `JsonParser` and `JsonGenerator` use to serialize and deserialize regular Java objects (POJOs aka Beans).
OutputDecorator
Handler class that can be used to decorate output destinations.
PackageVersion
Automatically generated from PackageVersion.java.in during packageVersion-generate execution of maven-replacer-plugin in pom.xml.
ParserBase
Intermediate base class used by all Jackson `JsonParser` implementations.
ParserMinimalBase
Intermediate base class used by all Jackson `JsonParser` implementations, but does not add any additional fields that depend on particular method of obtaining input.
PrettyPrinter
Interface for objects that implement pretty printer functionality, such as indentation.
ReadConstrainedTextBuffer
ReaderBasedJsonParser
This is a concrete implementation of `JsonParser`, which is based on a `Reader` to handle low-level character conversion tasks.
RecyclerPool<P extends RecyclerPool.WithPool<P>>
API for object pools that control creation and possible reuse of objects that are costly to create (often things like encoding/decoding buffers).
RecyclerPool.BoundedPoolBase<P extends RecyclerPool.WithPool<P>>
`RecyclerPool` implementation that uses a bounded queue (`ArrayBlockingQueue` for recycling instances.
RecyclerPool.ConcurrentDequePoolBase<P extends RecyclerPool.WithPool<P>>
`RecyclerPool` implementation that uses `ConcurrentLinkedDeque` for recycling instances.
RecyclerPool.LockFreePoolBase<P extends RecyclerPool.WithPool<P>>
`RecyclerPool` implementation that uses a lock free linked list for recycling instances.
RecyclerPool.LockFreePoolBase.Node<P>
RecyclerPool.NonRecyclingPoolBase<P extends RecyclerPool.WithPool<P>>
`RecyclerPool` implementation that does not use any pool but simply creates new instances when necessary.
RecyclerPool.StatefulImplBase<P extends RecyclerPool.WithPool<P>>
Intermediate base class for instances that are stateful and require special handling with respect to JDK serialization, to retain "global" reference distinct from non-shared ones.
RecyclerPool.ThreadLocalPoolBase<P extends RecyclerPool.WithPool<P>>
Default `RecyclerPool` implementation that uses `ThreadLocal` for recycling instances.
RecyclerPool.WithPool<P extends RecyclerPool.WithPool<P>>
Simple add-on interface that poolable entities must implement.
RequestPayload
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.
ResolvedType
Type abstraction that represents Java type that has been resolved (i.e.
SegmentedStringWriter
Efficient alternative to `StringWriter`, based on using segmented internal buffer.
Separators
Value class used with some `PrettyPrinter` implements
Separators.Spacing
Define the spacing around elements like commas and colons.
SerializableString
Interface that defines how Jackson package can interact with efficient pre-serialized or lazily-serialized and reused String representations.
SerializedString
String token that can lazily serialize String contained and then reuse that serialization later on.
StreamConstraintsException
Exception type used to indicate violations of stream constraints (for example `StreamReadConstraints`) when reading or writing content.
StreamReadCapability
Set of on/off capabilities that a `JsonParser` for given format (or in case of buffering, original format) has.
StreamReadConstraints
The constraints to use for streaming reads: used to guard against malicious input by preventing processing of "too big" input constructs (values, structures).
StreamReadConstraints.Builder
StreamReadException
Intermediate base class for all read-side streaming processing problems, including parsing and input value coercion problems.
StreamReadFeature
Token reader (parser) features not-specific to any particular format backend.
StreamWriteCapability
Set of on/off capabilities that a `JsonGenerator` for given format (or in case of buffering, original format) has.
StreamWriteConstraints
The constraints to use for streaming writes: used to guard against problematic output by preventing processing of "too big" output constructs (values, structures).
StreamWriteConstraints.Builder
StreamWriteException
Intermediate base class for all read-side streaming processing problems, including parsing and input value coercion problems.
StreamWriteFeature
Token writer (generator) features not-specific to any particular format backend.
TextBuffer
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.
TokenFilter
Strategy class that can be implemented to specify actual inclusion/exclusion criteria for filtering, used by `FilteringGeneratorDelegate`.
TokenFilter.Inclusion
Enumeration that controls how TokenFilter return values are interpreted.
TokenFilterContext
Alternative variant of `JsonStreamContext`, used when filtering content being read or written (based on `TokenFilter`).
TokenStreamFactory
Intermediate base class for actual format-specific factories for constructing parsers (reading) and generators (writing).
TreeCodec
Interface that defines objects that can read and write `TreeNode` instances using Streaming API.
TreeNode
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.
TypeReference<T>
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.
UTF32Reader
Since JDK does not come with UTF-32/UCS-4, let's implement a simple decoder to use.
UTF8DataInputJsonParser
This is a concrete implementation of `JsonParser`, which is based on a `DataInput` as the input source.
UTF8JsonGenerator
UTF8StreamJsonParser
This is a concrete implementation of `JsonParser`, which is based on a `InputStream` as the input source.
UTF8Writer
Version
Object that encapsulates versioning information of a component.
Versioned
Interface that those Jackson components that are explicitly versioned will implement.
VersionUtil
Functionality for supporting exposing of component `Version`s.
WritableTypeId
This is a simple value class used between core streaming and higher level databinding to pass information about type ids to write.
WritableTypeId.Inclusion
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.
WriterBasedJsonGenerator
`JsonGenerator` that outputs JSON content using a `Writer` which handles character encoding.