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.Internal Jackson 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.
Deprecated.
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.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.
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
JsonParseException
s),
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
JacksonFeature
s (usually Enum
s): 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.
Simple interface to allow adding decorators around
JsonGenerator
s.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
JsonParser
s 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.
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.RecyclerPool
implementation that uses
a lock free linked list 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.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.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 uses
a lock free linked list 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.
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
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.
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 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.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
Version
s.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.
RecyclerPool
.