All Classes and Interfaces
Class
Description
Tag interface (for now) for Array nodes
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.Internal Jackson Helper class used to implement more optimized parsing of
BigDecimal for REALLY big values (over 500 characters).Helper class used to implement more optimized parsing of
BigInteger for REALLY
big values (over 500 characters).Simplified static symbol table used instead of global quad-based canonicalizer
when we have smaller set of symbols (like properties of a POJO class).
Intermediate
TokenStreamFactory sub-class used as the base for
binary (non-textual) data formats.This is a small utility class, whose main functionality is to allow
simple reuse of raw byte/char buffers.
Tag-on interface to allow various other types to expose
BufferRecycler
they are constructed with.Deprecated.
Since 3.0
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
TokenStreamLocation)
objections, most commonly to be printed out as part of Exception
messages.Helper class to support use of
DataOutput for output, directly,
without caller having to provide for implementation.Intermediate base
TokenStreamFactory implementation that offers support for
streams that allow decoration of low-level input sources and output targets.Since factory instances are immutable, a Builder class is needed for creating
configurations for differently configured factory instances.
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
StreamReadFeature.STRICT_DUPLICATE_DETECTION
is enabled.Container for configuration values used when handling errorneous token inputs.
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 callerThis 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.
Intermediate base class for matchers that use hash-array based approach
with Strings.
Exception type for read-side problems that are not direct decoding ("parsing")
problems (those would be reported as basic
StreamReadExceptions),
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 cannot be used as is, but are used for creating usable per-process
(serialization, deserialization) instances, using
Instantiatable.createInstance() method.Internal Use Only.
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.
Simple bean class used to contain references.
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.Exception type used to wrap low-level I/O issues that are reported
(as
IOException) on reading and writing content using JDK streams
and other sources and targets.Enumeration that defines legal encodings that can be used
for JSON content, based on list of allowed encodings from
JSON specification.
JSON-backed
TokenStreamFactory implementation that will create
token readers ("parsers") and writers ("generators") for handling
JSON-encoded content.TSFBuilder
implementation for constructing JsonFactory
instances for reading/writing JSON encoded content.Base class that defines public API for writing JSON content.
Intermediate base class shared by JSON-backed generators
like
UTF8JsonGenerator and WriterBasedJsonGenerator.Simple interface to allow adding decorators around
JsonGenerators.Base class that defines public API for reading JSON content.
Enumeration of possible "native" (optimal) types that can be
used for numbers.
Enumeration of possible physical Floating-Point types that
underlying format uses.
Another intermediate base class, only used by actual JSON-backed parser
implementations.
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.Extension of
TokenStreamContext, which implements
core methods needed, and also exposes
more complete API to parser implementation classes.Token reader (parser) features specific to JSON backend.
Set of
RecyclerPool implementations to be used by the default
JSON-backed JsonFactory for recycling BufferRecycler
containers.RecyclerPool implementation that uses
a bounded queue (ArrayBlockingQueue for recycling instances.RecyclerPool implementation that uses
ConcurrentLinkedDeque for recycling instances.Dummy
RecyclerPool implementation that does not recycle
anything but simply creates new instances when asked to acquire items.ThreadLocal-based RecyclerPool implementation used for
recycling BufferRecycler instances:
see RecyclerPool.ThreadLocalPoolBase for full explanation
of functioning.Helper class used for efficient encoding of JSON String values (including
JSON property 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
TokenStreamContext, which implements
core methods needed, and also exposes
more complete API to generator implementation classes.Token writer features specific to JSON backend.
This class exposes package private utilities for other classes.
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.Simple tag interface used primarily to allow databind to pass entities with
name without needing to expose more details of implementation.
Non-blocking parser implementation for JSON content that takes its input
via
byte[] passed.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.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.
Defines API for accessing configuration and state exposed by
higher level databind
functionality during read (token stream to Object deserialization) process.
Default no-op implementation.
Tag interface (for now) for Object nodes
Defines API for accessing configuration and state exposed by
higher level databind
functionality during write (Object to token stream serialization) process.
Default no-op implementation.
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 many (but not 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.
Interface for implementations used for efficient matching of Object property names from
input stream (via parser) to higher-level abstractions like properties that
databind uses.
This is a concrete implementation of
JsonParser, which is
based on a Reader to handle low-level character
conversion tasks.API for object pools that control creation and possible reuse of
objects that are costly to create (often things like encoding/decoding buffers).
RecyclerPool implementation that uses
a bounded queue (ArrayBlockingQueue for recycling instances.RecyclerPool implementation that uses
ConcurrentLinkedDeque for recycling instances.RecyclerPool implementation that does not use
any pool but simply creates new instances when necessary.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.
Default
RecyclerPool implementation that uses
ThreadLocal for recycling instances.Simple add-on interface that poolable entities must implement.
Type abstraction that represents Java type that has been resolved
(i.e. has all generic information, if any, resolved to concrete
types).
Efficient alternative to
StringWriter, based on using segmented
internal buffer.Value class used with some
PrettyPrinter
implementsDefine the spacing around elements like commas and colons.
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.
Basic
PropertyNameMatcher that uses case-sensitive match and does
not require (or expect) that names passed as arguments have been
String.intern()ed.Basic implementation of
TokenStreamContext useful for most
format backend JsonParser implementations
(with notable exception of JSON that needs bit more advanced state).Basic implementation of
TokenStreamContext useful for most
format backend JsonGenerator implementations
(with notable exception of JSON that needs bit more advanced state).Interface that defines one method (see
Snapshottable.snapshot()) for ensuring that we get
an instance that does not allow modifying state of `this` instance.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.The constraints to use for streaming writes: used to guard against problematic
output by preventing processing of "too big" output constructs (values,
structures).
Intermediate base class for all write-side streaming processing problems,
mostly content generation issues.
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.Intermediate
TokenStreamFactory sub-class used as the base for
textual data formats.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
TokenStreamContext, used when filtering
content being read or written (based on TokenFilter).Shared base class for streaming processing contexts used during
reading and writing of token streams using Streaming API.
The main factory class of Jackson streaming package, used to configure and
construct token reader (aka parser,
JsonParser)
and token writer (aka generator, JsonGenerator)
instances.Enumeration that defines all on/off features that can only be
changed for
TokenStreamFactory.Object that encapsulates Location information used for reporting
parsing (or potentially generation) errors, as well as current location
within input streams.
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
ObjectReadContext and ObjectWriteContext
to have some level of interoperability.Since factory instances are immutable, a Builder class is needed for creating
configurations for differently configured factory instances.
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.Specialized
StreamReadException that is thrown when end-of-input
is reached unexpectedly, usually within token being decoded, but possibly
within intervening non-token content (for formats that have that, such
as whitespace for textual formats)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.