Class Index

B C D F G I J M N O P R S T U V W

B

Base64Variant Abstract base class used to define specific details of which variant of Base64 encoding/decoding is to be used. 
Base64Variants Container for commonly used Base64 variants. 
BaseTest  
BaseTest.FiveMinuteUser Sample class from Jackson tutorial ("JacksonInFiveMinutes")  
BaseTest.FiveMinuteUser.Gender  
BaseTest.FiveMinuteUser.Name  
BufferRecycler This is a small utility class, whose main functionality is to allow simple reuse of raw byte/char buffers. 
BufferRecycler.ByteBufferType  
BufferRecycler.CharBufferType  
ByteArrayBuilder Helper class that is similar to java.io.ByteArrayOutputStream in usage, but more geared to Jackson use cases internally. 
ByteSourceJsonBootstrapper This class is used to determine the encoding of byte stream that is to contain JSON content. 
BytesToNameCanonicalizer A caching symbol table implementation used for canonicalizing JSON field names (as Names which are constructed directly from a byte-based input source). 

C

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  
CollGenerator  
ConcurrencyReadTest Manual performance test to try out various synchronization methods for symbol tables. 
CoreVersion Helper class used for finding and caching version information for the core bundle. 

D

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. 
DefaultPrettyPrinter Default PrettyPrinter implementation that uses 2-space indentation with platform-default linefeeds. 
DefaultPrettyPrinter.FixedSpaceIndenter This is a very simple indenter that only every 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.Lf2SpacesIndenter Default linefeed-based indenter uses system-specific linefeeds and 2 spaces for indentation per level. 
DefaultPrettyPrinter.NopIndenter Dummy implementation that adds no indentation whatsoever  

F

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. 

G

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. 

I

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. 
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 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. 

J

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
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. 
JsonGeneratorDelegate  
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 JsonParsers to create a single logical sequence of tokens, as a single JsonParser
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. 
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. 
JsonWriteContext Extension of JsonStreamContext, which implements core methods needed, and also exposes more complete API to generator implementation classes. 

M

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. 

N

Name Base class for tokenized names (key strings in objects) that have been tokenized from byte-based input sources (like java.io.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. 
NumberInput  
NumberOutput  

O

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. 

P

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. 

R

ReaderBasedJsonParser This is a concrete implementation of JsonParser, which is based on a java.io.Reader to handle low-level character conversion tasks. 
ResolvedType Type abstraction that represents Java type that has been resolved (i.e. 

S

SegmentedStringWriter Efficient alternative to StringWriter, based on using segmented internal buffer. 
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. 

T

TestArrayParsing Set of additional unit for verifying array parsing, specifically edge cases. 
TestBase64Codec  
TestBase64Generation  
TestBase64Parsing  
TestByteBasedSymbols Unit test(s) to verify that handling of (byte-based) symbol tables is working. 
TestCharEscaping Set of basic unit tests for verifying that the basic parser functionality works as expected. 
TestCharTypes  
TestComments Unit tests for verifying that support for (non-standard) comments works as expected. 
TestCustomEscaping  
TestDecorators Unit tests to verify that input and output decorators work as expected 
TestDelegates  
TestGeneratorArray Set of basic unit tests for verifying that the Array write methods of JsonGenerator work as expected. 
TestGeneratorClosing Set of basic unit tests that verify aspect of closing a JsonGenerator instance. 
TestGeneratorCopy Set of basic unit tests for verifying that copy-through methods of JsonGenerator work as expected. 
TestGeneratorMisc Set of basic unit tests for verifying basic generator features. 
TestGeneratorObject Set of basic unit tests for verifying that the Object write methods of JsonGenerator work as expected. 
TestGeneratorWithSerializedString  
TestIOContext  
TestJsonFactory  
TestJsonFormatDetection  
TestJsonGenerator Set of basic unit tests for verifying that the basic generator functionality works as expected. 
TestJsonGeneratorFeatures Set of basic unit tests for verifying that the basic generator functionality works as expected. 
TestJsonParser Set of basic unit tests for verifying that the basic parser functionality works as expected. 
TestJsonParserBinary Tests for verifying that accessing base64 encoded content works ok. 
TestJsonParserSymbols Unit tests for verifying that JsonParser instances properly merge back symbols to the root symbol table  
TestJsonStringEncoder  
TestMergedStream  
TestNextXxx  
TestNumberParsing Set of basic unit tests for verifying that the low-level number handling methods work as expected. 
TestNumberPrinting Set of basic unit tests for verifying that the low-level number printingg methods work as expected. 
TestNumericValues Set of basic unit tests for verifying that the basic parser functionality works as expected. 
TestParserClosing Set of basic unit tests that verify that the closing (or not) of the underlying source occurs as expected and specified by documentation. 
TestParserFeatures Unit tests for verifying that additional JsonParser.Feature settings work as expected. 
TestParserLinefeeds Set of basic unit tests for verifying that the basic parser functionality works as expected. 
TestParserNonStandard  
TestParserOverrides  
TestParserWithObjects Unit tests for verifying that object mapping functionality can be accessed using JsonParser. 
TestPrettyPrinter Set of basic unit tests for verifying that indenting option of generator works correctly  
TestRawStringWriting  
TestScopeMatching Set of basic unit tests for verifying that Array/Object scopes are properly matched. 
TestSerializedString Simple unit tests to try to verify that the default SerializableString implementation works as expected. 
TestStringGeneration Set of basic unit tests for verifying that the string generation, including character escaping, works as expected. 
TestSymbolTables  
TestTextBuffer  
TestUnicode  
TestUtf8Generator  
TestUtf8Parser Set of basic unit tests for verifying that the basic parser functionality works as expected. 
TestUTF8Writer  
TestValueConversions  
TestVersions Tests to verify [JACKSON-278]  
TestVersionUtil  
TestWithTonsaSymbols Some unit tests to try to exercise part of parser code that deals with symbol (table) management. 
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. 
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. 
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. 

U

UTF32Reader Since JDK does not come with UTF-32/UCS-4, let's implement a simple decoder to use. 
UTF8JsonGenerator  
UTF8StreamJsonParser This is a concrete implementation of JsonParser, which is based on a java.io.InputStream as the input source. 
UTF8Writer  

V

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 Versions. 

W

WriterBasedJsonGenerator JsonGenerator that outputs JSON content using a java.io.Writer which handles character encoding.