# Package com.fasterxml.jackson.core

package com.fasterxml.jackson.core
Main public API classes of the core streaming JSON processor: most importantly `JsonFactory` used for constructing JSON parser (`JsonParser`) and generator (`JsonGenerator`) instances.

Public API of the higher-level mapping interfaces ("Mapping API") is found from the "jackson-databind" bundle, except for following base interfaces that are defined here:

- `TreeNode` is included within Streaming API to support integration of the Tree Model (which is based on `JsonNode`) with the basic parsers and generators (iff using mapping-supporting factory: which is part of Mapping API, not core)
- `ObjectCodec` is included so that reference to the object capable of serializing/deserializing Objects to/from JSON (usually, `com.fasterxml.jackson.databind.ObjectMapper`) can be exposed, without adding direct dependency to implementation.

Related Packages
Package
Description
com.fasterxml.jackson.core.async
Package that contains abstractions needed to support optional non-blocking decoding (parsing) functionality.
com.fasterxml.jackson.core.base
Base classes used by concrete Parser and Generator implementations; contain functionality that is not specific to JSON or input abstraction (byte vs char).
com.fasterxml.jackson.core.exc
Package for some of `JsonProcessingException` subtypes contained by streaming API.
com.fasterxml.jackson.core.filter
com.fasterxml.jackson.core.format
Package that contains interfaces needed for dynamic, pluggable format (auto)detection; as well as basic utility classes for simple format detection functionality.
com.fasterxml.jackson.core.io
com.fasterxml.jackson.core.json
JSON-specific parser and generator implementation classes that Jackson defines and uses.
com.fasterxml.jackson.core.sym
Internal implementation classes for efficient handling of of symbols in JSON (field names in Objects)
com.fasterxml.jackson.core.type
Contains classes needed for type introspection, mostly used by data binding functionality.
com.fasterxml.jackson.core.util
Utility classes used by Jackson Core functionality.
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.
ErrorReportConfiguration
Container for configuration values used when handling errorneous token inputs.
ErrorReportConfiguration.Builder
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.
JacksonException
Base class for all Jackson-produced checked exceptions.
JsonEncoding
Enumeration that defines legal encodings that can be used for JSON content, based on list of allowed encodings from JSON specification.
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.
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.
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.
JsonProcessingException
Intermediate base class for all problems encountered when processing (parsing, generating) JSON content that are not pure I/O problems.
JsonStreamContext
Shared base class for streaming processing contexts used during reading and writing of Json content using Streaming API.
JsonToken
Enumeration for basic token types used for returning results of parsing JSON content.
JsonTokenId
Interface defined to contain ids accessible with `JsonToken.id()`.
ObjectCodec
Abstract class that defines the interface that `JsonParser` and `JsonGenerator` use to serialize and deserialize regular Java objects (POJOs aka Beans).
PrettyPrinter
Interface for objects that implement pretty printer functionality, such as indentation.
SerializableString
Interface that defines how Jackson package can interact with efficient pre-serialized or lazily-serialized and reused String representations.
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
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
StreamWriteFeature
Token writer (generator) features not-specific to any particular format backend.
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.
Version
Object that encapsulates versioning information of a component.
Versioned
Interface that those Jackson components that are explicitly versioned will implement.