All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class |
Description |
AbstractDeserializer |
Deserializer only used for abstract types used as placeholders during polymorphic
type handling deserialization.
|
AbstractTypeResolver |
Defines interface for resolvers that can resolve abstract types into concrete
ones; either by using static mappings, or possibly by materializing
implementations dynamically.
|
AccessorNamingStrategy |
API for handlers used to "mangle" names of "getter" and "setter" methods to
find implicit property names.
|
AccessorNamingStrategy.Base |
Helper class that implements all abstract methods with dummy implementations.
|
AccessorNamingStrategy.Provider |
Interface for provider (factory) for constructing AccessorNamingStrategy
for given type of deserialization target
|
AccessPattern |
Enumeration used to indicate required access pattern for providers:
this can sometimes be used to optimize out dynamic calls.
|
Annotated |
Shared base class used for anything on which annotations (included
within a AnnotationMap ).
|
AnnotatedClass |
|
AnnotatedClass.Creators |
|
AnnotatedClassResolver |
Helper class that contains logic for resolving annotations to construct
AnnotatedClass instances.
|
AnnotatedConstructor |
|
AnnotatedField |
Object that represents non-static (and usually non-transient/volatile)
fields of a class.
|
AnnotatedFieldCollector |
|
AnnotatedMember |
Intermediate base class for annotated entities that are members of
a class; fields, methods and constructors.
|
AnnotatedMethod |
|
AnnotatedMethodCollector |
|
AnnotatedMethodMap |
Simple helper class used to keep track of collection of
AnnotatedMethod s, accessible by lookup.
|
AnnotatedParameter |
Object that represents method parameters, mostly so that associated
annotations can be processed conveniently.
|
AnnotatedWithParams |
Intermediate base class that encapsulates features that
constructors and methods share.
|
AnnotationCollector |
|
AnnotationCollector.NoAnnotations |
Immutable implementation for case where no annotations are associated with
an annotatable entity.
|
AnnotationCollector.OneAnnotation |
|
AnnotationCollector.TwoAnnotations |
|
AnnotationIntrospector |
Abstract class that defines API used for introspecting annotation-based
configuration for serialization and deserialization.
|
AnnotationIntrospector.ReferenceProperty |
Value type used with managed and back references; contains type and
logic name, used to link related references
|
AnnotationIntrospector.ReferenceProperty.Type |
|
AnnotationIntrospectorPair |
Helper class that allows using 2 introspectors such that one
introspector acts as the primary one to use; and second one
as a fallback used if the primary does not provide conclusive
or useful result for a method.
|
AnnotationMap |
Simple helper class used to keep track of collection of
Jackson Annotations associated with annotatable things
(methods, constructors, classes).
|
Annotations |
Interface that defines interface for accessing contents of a
collection of annotations.
|
AnyGetterWriter |
Class similar to BeanPropertyWriter , but that will be used
for serializing JsonAnyGetter annotated
(Map) properties
|
ArrayBlockingQueueDeserializer |
We need a custom deserializer both because ArrayBlockingQueue has no
default constructor AND because it has size limit used for constructing
underlying storage automatically.
|
ArrayBuilders |
Helper class that contains set of distinct builders for different
arrays of primitive values.
|
ArrayBuilders.BooleanBuilder |
|
ArrayBuilders.ByteBuilder |
|
ArrayBuilders.DoubleBuilder |
|
ArrayBuilders.FloatBuilder |
|
ArrayBuilders.IntBuilder |
|
ArrayBuilders.LongBuilder |
|
ArrayBuilders.ShortBuilder |
|
ArrayIterator<T> |
Iterator implementation used to efficiently expose contents of an
Array as read-only iterator.
|
ArrayNode |
Node class that represents Arrays mapped from JSON content.
|
ArraySerializerBase<T> |
Intermediate base class for serializers used for various
Java arrays.
|
ArrayType |
Array types represent Java arrays, both primitive and object valued.
|
AsArraySerializerBase<T> |
Base class for serializers that will output contents as JSON
arrays; typically serializers used for Collection
and array types.
|
AsArrayTypeDeserializer |
Type deserializer used with JsonTypeInfo.As.WRAPPER_ARRAY
inclusion mechanism.
|
AsArrayTypeSerializer |
Type serializer that will embed type information in an array,
as the first element, and actual value as the second element.
|
AsDeductionTypeDeserializer |
A TypeDeserializer capable of deducing polymorphic types based on the
fields available.
|
AsExistingPropertyTypeSerializer |
Type serializer used with JsonTypeInfo.As.EXISTING_PROPERTY inclusion mechanism.
|
AsExternalTypeDeserializer |
Type deserializer used with JsonTypeInfo.As.EXTERNAL_PROPERTY inclusion mechanism.
|
AsExternalTypeSerializer |
Type serializer that preferably embeds type information as an "external"
type property; embedded in enclosing JSON object.
|
AsPropertyTypeDeserializer |
Type deserializer used with JsonTypeInfo.As.PROPERTY
inclusion mechanism.
|
AsPropertyTypeSerializer |
Type serializer that preferably embeds type information as an additional
JSON Object property, if possible (when resulting serialization would
use JSON Object).
|
AsWrapperTypeDeserializer |
Type deserializer used with JsonTypeInfo.As.WRAPPER_OBJECT
inclusion mechanism.
|
AsWrapperTypeSerializer |
Type wrapper that tries to use an extra JSON Object, with a single
entry that has type name as key, to serialize type information.
|
AtomicBooleanDeserializer |
|
AtomicIntegerDeserializer |
|
AtomicLongDeserializer |
|
AtomicReferenceDeserializer |
|
AtomicReferenceSerializer |
|
AttributePropertyWriter |
|
BaseJsonNode |
Abstract base class common to all standard JsonNode
implementations.
|
BaseSettings |
Immutable container class used to store simple configuration
settings for both serialization and deserialization.
|
BasicBeanDescription |
|
BasicClassIntrospector |
|
BasicDeserializerFactory |
Abstract factory base class that can provide deserializers for standard
JDK classes, including collection classes and simple heuristics for
"upcasting" common collection interface types
(such as Collection ).
|
BasicDeserializerFactory.ContainerDefaultMappings |
Helper class to contain default mappings for abstract JDK Collection
and Map types.
|
BasicDeserializerFactory.CreatorCollectionState |
Helper class to contain largish number of parameters that need to be passed
during Creator introspection.
|
BasicPolymorphicTypeValidator |
Standard BasicPolymorphicTypeValidator implementation that users may want
to use for constructing validators based on simple class hierarchy and/or name patterns
to allow and/or deny certain subtypes.
|
BasicPolymorphicTypeValidator.Builder |
|
BasicPolymorphicTypeValidator.NameMatcher |
General matcher interface (predicate) for validating unresolved
subclass class name.
|
BasicPolymorphicTypeValidator.TypeMatcher |
General matcher interface (predicate) for validating class values
(base type or resolved subtype)
|
BasicSerializerFactory |
Factory class that can provide serializers for standard JDK classes,
as well as custom classes that extend standard classes or implement
one of "well-known" interfaces (such as Collection ).
|
BeanAsArrayBuilderDeserializer |
|
BeanAsArrayDeserializer |
Variant of BeanDeserializer used for handling deserialization
of POJOs when serialized as JSON Arrays, instead of JSON Objects.
|
BeanAsArraySerializer |
Specialized POJO serializer that differs from
BeanSerializer
in that instead of producing a JSON Object it will output
a JSON Array, omitting field names, and serializing values in
specified serialization order.
|
BeanDescription |
Basic container for information gathered by ClassIntrospector to
help in constructing serializers and deserializers.
|
BeanDeserializer |
Deserializer class that can deserialize instances of
arbitrary bean objects, usually from JSON Object structs,
|
BeanDeserializerBase |
Base class for BeanDeserializer .
|
BeanDeserializerBuilder |
Builder class used for aggregating deserialization information about
a POJO, in order to build a JsonDeserializer for deserializing
instances.
|
BeanDeserializerFactory |
Concrete deserializer factory class that adds full Bean deserializer
construction logic using class introspection.
|
BeanDeserializerModifier |
|
BeanProperty |
Bean properties are logical entities that represent data
that Java objects (POJOs (Plain Old Java Objects), sometimes also called "beans")
contain; and that are accessed using accessors (methods like getters
and setters, fields, constructor parameters).
|
BeanProperty.Bogus |
Alternative "Null" implementation that can be used in cases where a non-null
BeanProperty is needed
|
BeanProperty.Std |
Simple stand-alone implementation, useful as a placeholder
or base class for more complex implementations.
|
BeanPropertyDefinition |
Simple value classes that contain definitions of properties,
used during introspection of properties to use for
serialization and deserialization purposes.
|
BeanPropertyFilter |
Deprecated.
|
BeanPropertyMap |
|
BeanPropertyWriter |
Base bean property handler class, which implements common parts of
reflection-based functionality for accessing a property value and serializing
it.
|
BeanSerializer |
Serializer class that can serialize Java objects that map
to JSON Object output.
|
BeanSerializerBase |
Base class both for the standard bean serializer, and couple
of variants that only differ in small details.
|
BeanSerializerBuilder |
Builder class used for aggregating deserialization information about
a POJO, in order to build a JsonSerializer for serializing
intances.
|
BeanSerializerFactory |
Factory class that can provide serializers for any regular Java beans
(as defined by "having at least one get method recognizable as bean
accessor" -- where Object.getClass() does not count);
as well as for "standard" JDK types.
|
BeanSerializerModifier |
|
BeanUtil |
Helper class that contains functionality needed by both serialization
and deserialization side.
|
BigIntegerNode |
Numeric node that contains simple 64-bit integer values.
|
BinaryNode |
Value node that contains Base64 encoded binary value, which will be
output and stored as Json String value.
|
BooleanNode |
This concrete value class is used to contain boolean (true / false)
values.
|
BooleanSerializer |
Serializer used for primitive boolean, as well as java.util.Boolean
wrapper type.
|
BuilderBasedDeserializer |
Class that handles deserialization using a separate
Builder class, which is used for data binding and
produces actual deserialized value at the end
of data binding.
|
ByteArraySerializer |
Unlike other integral number array serializers, we do not just print out byte values
as numbers.
|
ByteBufferBackedInputStream |
Simple InputStream implementation that exposes currently
available content of a ByteBuffer .
|
ByteBufferBackedOutputStream |
Simple OutputStream implementation that appends content
written in given ByteBuffer instance.
|
ByteBufferDeserializer |
|
ByteBufferSerializer |
|
CalendarSerializer |
Standard serializer for Calendar .
|
ClassIntrospector |
Helper class used to introspect features of POJO value classes
used with Jackson.
|
ClassIntrospector.MixInResolver |
Interface used for decoupling details of how mix-in annotation
definitions are accessed (via this interface), and how
they are stored (defined by classes that implement the interface)
|
ClassKey |
Key class, used as an efficient and accurate key
for locating per-class values, such as
JsonSerializer s.
|
ClassNameIdResolver |
TypeIdResolver implementation
that converts between fully-qualified
Java class names and (JSON) Strings.
|
ClassSerializer |
Also: default bean access will not do much good with Class.class.
|
ClassStack |
Simple helper class used to keep track of 'call stack' for classes being referenced
(as well as unbound variables)
|
ClassUtil |
|
ClassUtil.Ctor |
Value class used for caching Constructor declarations; used because
caching done by JDK appears to be somewhat inefficient for some use cases.
|
CoercionAction |
Set of possible actions for requested coercion from an
input shape CoercionInputShape
that does not directly or naturally match target type
( LogicalType ).
|
CoercionConfig |
|
CoercionConfigs |
|
CoercionInputShape |
Set of input types (which mostly match one of
JsonToken types) used for
configuring CoercionAction s to take when reading
input into target types (specific type or LogicalType ).
|
CollectionDeserializer |
Basic serializer that can take JSON "Array" structure and
construct a Collection instance, with typed contents.
|
CollectionDeserializer.CollectionReferringAccumulator |
Helper class for dealing with Object Id references for values contained in
collections being deserialized.
|
CollectionLikeType |
Type that represents things that act similar to Collection ;
but may or may not be instances of that interface.
|
CollectionSerializer |
Fallback serializer for cases where Collection is not known to be
of type for which more specializer serializer exists (such as
index-accessible List).
|
CollectionType |
Type that represents Java Collection types (Lists, Sets).
|
CompactStringObjectMap |
Specialized lookup class that implements functionality similar to
Map , but for special case of key always being
String and using more compact (and memory-access
friendly) hashing scheme.
|
ConcreteBeanPropertyBase |
Intermediate BeanProperty class shared by concrete readable- and
writable property implementations for sharing common functionality.
|
ConfigFeature |
Interface that actual SerializationFeature enumerations used by
MapperConfig implementations must implement.
|
ConfigOverride |
Configuration object that is accessed by databinding functionality
to find overrides to configuration of properties, based on declared
type of the property.
|
ConfigOverrides |
|
ConstructorDetector |
Configurable handler used to select aspects of selecting
constructor to use as "Creator" for POJOs.
|
ConstructorDetector.SingleArgConstructor |
Definition of alternate handling modes of single-argument constructors
that are annotated with JsonCreator
but without "mode" definition (or explicit name for the argument):
this is the case where two interpretations
are possible -- "properties" (in which case the argument is named parameter
of a JSON Object) and "delegating (in which case the argument maps to the
whole JSON value).
|
ContainerDeserializerBase<T> |
Intermediate base deserializer class that adds more shared accessor
so that other classes can access information about contained (value) types
|
ContainerNode<T extends ContainerNode<T>> |
This intermediate base class is used for all container nodes,
specifically, array and object nodes.
|
ContainerSerializer<T> |
Intermediate base class for serializers used for serializing
types that contain element(s) of other types, such as arrays,
Collection s (Lists , Sets
etc) and Map s and iterable things
(Iterator s).
|
ContextAttributes |
Helper class used for storing and accessing per-call attributes.
|
ContextAttributes.Impl |
|
ContextualDeserializer |
Add-on interface that JsonDeserializer s can implement to get a callback
that can be used to create contextual (context-dependent) instances of
deserializer to use for handling properties of supported type.
|
ContextualKeyDeserializer |
Add-on interface that KeyDeserializer s can implement to get a callback
that can be used to create contextual instances of key deserializer to use for
handling Map keys of supported type.
|
ContextualSerializer |
Add-on interface that JsonSerializer s can implement to get a callback
that can be used to create contextual instances of serializer to use for
handling properties of supported type.
|
Converter<IN,OUT> |
Helper interface for things that convert Objects of
one type to another.
|
Converter.None |
This marker class is only to be used with annotations, to
indicate that no converter is to be used.
|
CoreXMLDeserializers |
Container deserializers that handle "core" XML types: ones included in standard
JDK 1.5.
|
CoreXMLDeserializers.Std |
Combo-deserializer that supports deserialization of somewhat optional
javax.xml types QName , Duration and XMLGregorianCalendar .
|
CoreXMLSerializers |
Provider for serializers of XML types that are part of full JDK 1.5, but
that some alleged 1.5 platforms are missing (Android, GAE).
|
CoreXMLSerializers.XMLGregorianCalendarSerializer |
|
CreatorCandidate |
|
CreatorCandidate.Param |
|
CreatorCollector |
Container class for storing information on creators (based on annotations,
visibility), to be able to build actual ValueInstantiator later on.
|
CreatorProperty |
This concrete sub-class implements property that is passed
via Creator (constructor or static factory method).
|
DatabindContext |
|
DataFormatReaders |
Alternative to DataFormatDetector that needs to be used when
using data-binding.
|
DataFormatReaders.AccessorForReader |
We need sub-class here as well, to be able to access efficiently.
|
DataFormatReaders.Match |
Result class, similar to DataFormatMatcher
|
DateDeserializers |
Container class for core JDK date/time type deserializers.
|
DateDeserializers.CalendarDeserializer |
|
DateDeserializers.DateBasedDeserializer<T> |
|
DateDeserializers.DateDeserializer |
Simple deserializer for handling Date values.
|
DateDeserializers.SqlDateDeserializer |
Compared to plain old Date , SQL version is easier
to deal with: mostly because it is more limited.
|
DateDeserializers.TimestampDeserializer |
Simple deserializer for handling Timestamp values.
|
DateSerializer |
For efficiency, we will serialize Dates as longs, instead of
potentially more readable Strings.
|
DateTimeSerializerBase<T> |
|
DecimalNode |
Numeric node that contains values that do not fit in simple
integer (int, long) or floating point (double) values.
|
DefaultAccessorNamingStrategy |
|
DefaultAccessorNamingStrategy.BaseNameValidator |
Definition of a handler API to use for checking whether given base name
(remainder of accessor method name after removing prefix) is acceptable
based on various rules.
|
DefaultAccessorNamingStrategy.FirstCharBasedValidator |
|
DefaultAccessorNamingStrategy.Provider |
|
DefaultAccessorNamingStrategy.RecordNaming |
Implementation used for supporting "non-prefix" naming convention of
Java 14 java.lang.Record types, and in particular find default
accessors for declared record fields.
|
DefaultBaseTypeLimitingValidator |
|
DefaultDeserializationContext |
|
DefaultDeserializationContext.Impl |
Actual full concrete implementation
|
DefaultSerializerProvider |
|
DefaultSerializerProvider.Impl |
Concrete implementation that defines factory method(s),
defined as final.
|
DelegatingDeserializer |
Base class that simplifies implementations of JsonDeserializer s
that mostly delegate functionality to another deserializer implementation
(possibly forming a chaing of deserializers delegating functionality
in some cases)
|
DeserializationConfig |
Object that contains baseline configuration for deserialization
process.
|
DeserializationContext |
Context for the process of deserialization a single root-level value.
|
DeserializationFeature |
Enumeration that defines simple on/off features that affect
the way Java objects are deserialized from JSON
|
DeserializationProblemHandler |
This is the class that can be registered (via
DeserializationConfig object owner by
ObjectMapper ) to get called when a potentially
recoverable problem is encountered during deserialization
process.
|
DeserializerCache |
|
DeserializerFactory |
|
DeserializerFactoryConfig |
|
Deserializers |
Interface that defines API for simple extensions that can provide additional deserializers
for various types.
|
Deserializers.Base |
Basic Deserializers implementation that implements all methods but provides
no deserializers.
|
DOMDeserializer<T> |
Base for serializers that allows parsing DOM Documents from JSON Strings.
|
DOMDeserializer.DocumentDeserializer |
|
DOMDeserializer.NodeDeserializer |
|
DOMSerializer |
|
DoubleNode |
Numeric node that contains 64-bit ("double precision")
floating point values simple 32-bit integer values.
|
EnumDeserializer |
Deserializer class that can deserialize instances of
specified Enum class from Strings and Integers.
|
EnumMapDeserializer |
Deserializer for EnumMap values.
|
EnumResolver |
Helper class used to resolve String values (either JSON Object field
names or regular String values) into Java Enum instances.
|
EnumSerializer |
Standard serializer used for Enum types.
|
EnumSetDeserializer |
Standard deserializer for EnumSet s.
|
EnumSetSerializer |
|
EnumValues |
Helper class used for storing String serializations of Enum s,
to match to/from external representations.
|
ErrorThrowingDeserializer |
A deserializer that stores an Error caught during constructing
of the deserializer, which needs to be deferred and only during actual
attempt to deserialize a value of given type.
|
ExternalTypeHandler |
Helper class that is used to flatten JSON structure when using
"external type id" (see JsonTypeInfo.As.EXTERNAL_PROPERTY ).
|
ExternalTypeHandler.Builder |
|
FailingDeserializer |
|
FailingSerializer |
|
FieldProperty |
This concrete sub-class implements property that is set
directly assigning to a Field.
|
FileSerializer |
For now, File objects get serialized by just outputting
absolute (but not canonical) name as String value
|
FilteredBeanPropertyWriter |
Decorated BeanPropertyWriter that will filter out properties
that are not to be included in currently active JsonView.
|
FilterProvider |
Interface for objects that providers instances of PropertyFilter
that match given ids.
|
FloatNode |
JsonNode implementation for efficiently containing 32-bit
`float` values.
|
FromStringDeserializer<T> |
Base class for simple deserializers that serialize values from String
representation: this includes JSON Strings and other Scalar values that
can be coerced into text, like Numbers and Booleans).
|
FromStringDeserializer.Std |
"Chameleon" deserializer that works on simple types that are deserialized
from a simple String.
|
HandlerInstantiator |
Helper class used for handling details of creating handler instances (things
like JsonSerializer s, JsonDeserializer s, various type
handlers) of specific types.
|
IgnoredPropertyException |
Specialized JsonMappingException sub-class used to indicate
case where an explicitly ignored property is encountered, and mapper
is configured to consider this an error.
|
IgnorePropertiesUtil |
|
IgnorePropertiesUtil.Checker |
Helper class to encapsulate logic from static shouldIgnore method
of util class.
|
IndexedListSerializer |
This is an optimized serializer for Lists that can be efficiently
traversed by index (as opposed to others, such as LinkedList
that cannot}.
|
IndexedStringListSerializer |
Efficient implement for serializing List s that contains Strings and are random-accessible.
|
InetAddressSerializer |
Simple serializer for InetAddress .
|
InetSocketAddressSerializer |
Simple serializer for InetSocketAddress .
|
InjectableValues |
Abstract class that defines API for objects that provide value to
"inject" during deserialization.
|
InjectableValues.Std |
Simple standard implementation which uses a simple Map to
store values to inject, identified by simple String keys.
|
InnerClassProperty |
This sub-class is used to handle special case of value being a
non-static inner class.
|
IntNode |
Numeric node that contains simple 32-bit integer values.
|
InvalidDefinitionException |
Intermediate exception type used as the base class for all JsonMappingException s
that are due to problems with target type definition; usually a problem with
annotations used on a class or its properties.
|
InvalidFormatException |
Specialized sub-class of MismatchedInputException
that is used when the underlying problem appears to be that
of bad formatting of a value to deserialize.
|
InvalidNullException |
Exception thrown if a `null` value is being encountered for a property
designed as "fail on null" property (see JsonSetter ).
|
InvalidTypeIdException |
Exception thrown when resolution of a type id fails.
|
ISO8601DateFormat |
Deprecated.
|
ISO8601Utils |
Deprecated. |
IterableSerializer |
|
IteratorSerializer |
|
JacksonAnnotationIntrospector |
|
JacksonStdImpl |
Marker interface used to indicate implementation classes
(serializers, deserializers etc) that are standard ones Jackson
uses; not custom ones that application has added.
|
Java7Handlers |
To support Java7-incomplete platforms, we will offer support for JDK 7
datatype(s) (that is, Path through this class, loaded
dynamically; if loading fails, support will be missing.
|
Java7HandlersImpl |
|
Java7Support |
To support Java7-incomplete platforms, we will offer support for JDK 7
annotations through this class, loaded dynamically; if loading fails,
support will be missing.
|
Java7SupportImpl |
|
JavaType |
Base class for type token classes used both to contain information
and as keys for deserializers.
|
JavaUtilCollectionsDeserializers |
Helper class used to contain logic for deserializing "special" containers
from java.util.Collections and java.util.Arrays .
|
JDK14Util |
Helper class to support some of JDK 14 (and later) features
without Jackson itself being run on (or even built with) Java 14.
|
JdkDeserializers |
Container class that contains serializers for JDK types that
require special handling for some reason.
|
JDKValueInstantiators |
Container for a set of ValueInstantiator s used for certain critical
JDK value types, either as performance optimization for initialization time observed
by profiling, or due to difficulty in otherwise finding constructors.
|
JsonAnyFormatVisitor |
|
JsonAnyFormatVisitor.Base |
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
|
JsonAppend |
Annotation that may be used to add "virtual" properties to be written
after regular properties (although ordering may be changed using
both standard @JsonPropertyOrder annotation, and
properties of this annotation).
|
JsonAppend.Attr |
Definition of a single attribute-backed property.
|
JsonAppend.Prop |
Definition of a single general virtual property.
|
JsonArrayFormatVisitor |
|
JsonArrayFormatVisitor.Base |
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
|
JsonBooleanFormatVisitor |
|
JsonBooleanFormatVisitor.Base |
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
|
JsonDeserialize |
Annotation use for configuring deserialization aspects, by attaching
to "setter" methods or fields, or to value classes.
|
JsonDeserializer<T> |
Abstract class that defines API used by ObjectMapper (and
other chained JsonDeserializer s too) to deserialize Objects of
arbitrary types from JSON, using provided JsonParser .
|
JsonDeserializer.None |
This marker class is only to be used with annotations, to
indicate that no deserializer is configured.
|
JsonFormatTypes |
|
JsonFormatVisitable |
Interface JsonSerializer implements
to allow for visiting type hierarchy.
|
JsonFormatVisitorWithSerializerProvider |
|
JsonFormatVisitorWrapper |
Interface for visitor callbacks, when type in question can be any of
legal JSON types.
|
JsonFormatVisitorWrapper.Base |
|
JsonIntegerFormatVisitor |
|
JsonIntegerFormatVisitor.Base |
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
|
JsonLocationInstantiator |
For JsonLocation , we should be able to just implement
ValueInstantiator (not that explicit one would be very
hard but...)
|
JsonMapFormatVisitor |
|
JsonMapFormatVisitor.Base |
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
|
JsonMapper |
|
JsonMapper.Builder |
Base implementation for "Vanilla" ObjectMapper , used with
JSON dataformat backend.
|
JsonMappingException |
Checked exception used to signal fatal problems with mapping of
content, distinct from low-level I/O problems (signaled using
simple IOException s) or data encoding/decoding
problems (signaled with JsonParseException ,
JsonGenerationException ).
|
JsonMappingException.Reference |
Simple bean class used to contain references.
|
JsonNaming |
|
JsonNode |
Base class for all JSON nodes, which form the basis of JSON
Tree Model that Jackson implements.
|
JsonNodeCreator |
Interface that defines common "creator" functionality implemented
both by JsonNodeFactory and ContainerNode (that is,
JSON Object and Array nodes).
|
JsonNodeDeserializer |
Deserializer that can build instances of JsonNode from any
JSON content, using appropriate JsonNode type.
|
JsonNodeFactory |
Base class that specifies methods for getting access to
Node instances (newly constructed, or shared, depending
on type), as well as basic implementation of the methods.
|
JsonNodeType |
Enumeration of JSON types.
|
JsonNullFormatVisitor |
|
JsonNullFormatVisitor.Base |
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
|
JsonNumberFormatVisitor |
|
JsonNumberFormatVisitor.Base |
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
|
JsonObjectFormatVisitor |
Visitor called when properties of a type that maps to JSON Object
are being visited: this usually means POJOs, but sometimes other
types use it too (like EnumMap ).
|
JsonObjectFormatVisitor.Base |
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
|
JSONPObject |
Container class that can be used to wrap any Object instances (including
nulls), and will serialize embedded in
JSONP wrapping.
|
JsonPOJOBuilder |
Annotation used to configure details of a Builder class:
instances of which are used as Builders for deserialized
POJO values, instead of POJOs being instantiated using
constructors or factory methods.
|
JsonPOJOBuilder.Value |
Simple value container for containing values read from
JsonPOJOBuilder annotation instance.
|
JsonSchema |
Deprecated.
|
JsonSerializable |
Interface that can be implemented by objects that know how to
serialize themselves to JSON, using JsonGenerator
(and SerializerProvider if necessary).
|
JsonSerializable.Base |
Base class with minimal implementation, as well as couple of extension methods
that core Jackson databinding makes use of.
|
JsonSerializableSchema |
Annotation that can be used to define JSON Schema definition for
the annotated class.
|
JsonSerialize |
Annotation used for configuring serialization aspects, by attaching
to "getter" methods or fields, or to value classes.
|
JsonSerialize.Inclusion |
Deprecated. |
JsonSerialize.Typing |
Enumeration used with JsonSerialize.typing() property
to define whether type detection is based on dynamic runtime
type (DYNAMIC) or declared type (STATIC).
|
JsonSerializer<T> |
Abstract class that defines API used by ObjectMapper (and
other chained JsonSerializer s too) to serialize Objects of
arbitrary types into JSON, using provided JsonGenerator .
|
JsonSerializer.None |
This marker class is only to be used with annotations, to
indicate that no serializer is configured.
|
JsonStringFormatVisitor |
|
JsonStringFormatVisitor.Base |
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
|
JsonTypeIdResolver |
|
JsonTypeResolver |
Annotation that can be used to explicitly define custom resolver
used for handling serialization and deserialization of type information,
needed for handling of polymorphic types (or sometimes just for linking
abstract types to concrete types)
|
JsonValueFormat |
This enum represents the encoded format for a jsonSchema value type
|
JsonValueFormatVisitor |
|
JsonValueFormatVisitor.Base |
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
|
JsonValueInstantiator |
Annotation that can be used to indicate a ValueInstantiator to use
for creating instances of specified type.
|
JsonValueSerializer |
Serializer class that can serialize Object that have a
JsonValue annotation to
indicate that serialization should be done by calling the method
annotated, and serializing result it returns.
|
JSONWrappedObject |
General-purpose wrapper class that can be used to decorate serialized
value with arbitrary literal prefix and suffix.
|
KeyDeserializer |
Abstract class that defines API used for deserializing JSON content
field names into Java Map keys.
|
KeyDeserializer.None |
This marker class is only to be used with annotations, to
indicate that no deserializer is configured.
|
KeyDeserializers |
Interface that defines API for simple extensions that can provide additional deserializers
for deserializer Map keys of various types, from JSON property names.
|
LaissezFaireSubTypeValidator |
|
LinkedNode<T> |
Node of a forward-only linked list.
|
LogicalType |
Set of logical types (or type categories, classes of classes), used
for defining applicability of configuration like coercion configuration.
|
LongNode |
Numeric node that contains simple 64-bit integer values.
|
LookupCache<K,V> |
An interface describing the required API for the Jackson-databind Type cache.
|
LRUMap<K,V> |
Helper for simple bounded maps used for reusing lookup values.
|
ManagedReferenceProperty |
Wrapper property that is used to handle managed (forward) properties
Basically just needs to delegate first to actual forward property, and
then to back property.
|
MapDeserializer |
Basic deserializer that can take JSON "Object" structure and
construct a Map instance, with typed contents.
|
MapEntryDeserializer |
Basic serializer that can take JSON "Object" structure and
construct a Map instance, with typed contents.
|
MapEntrySerializer |
|
MapLikeType |
Type that represents Map-like types; things that consist of key/value pairs
but that do not necessarily implement Map , but that do not
have enough introspection functionality to allow for some level of generic
handling.
|
MapperBuilder<M extends ObjectMapper,B extends MapperBuilder<M,B>> |
Jackson 3 will introduce fully immutable, builder-based system for constructing
ObjectMapper s.
|
MapperConfig<T extends MapperConfig<T>> |
Interface that defines functionality accessible through both
serialization and deserialization configuration objects;
accessors to mode-independent configuration settings
and such.
|
MapperConfigBase<CFG extends ConfigFeature,T extends MapperConfigBase<CFG,T>> |
|
MapperFeature |
Enumeration that defines simple on/off features to set
for ObjectMapper , and accessible (but not changeable)
via ObjectReader and ObjectWriter (as well as
through various convenience methods through context objects).
|
MappingIterator<T> |
Iterator exposed by ObjectMapper when binding sequence of
objects.
|
MappingJsonFactory |
Sub-class of JsonFactory that will create a proper
ObjectCodec to allow seam-less conversions between
JSON content and Java objects (POJOs).
|
MapProperty |
Helper class needed to support flexible filtering of Map properties
with generic JSON Filter functionality.
|
MapSerializer |
Standard serializer implementation for serializing {link java.util.Map} types.
|
MapType |
Type that represents "true" Java Map types.
|
MemberKey |
Helper class needed to be able to efficiently access class
member functions (Method s and Constructor s)
in Map s.
|
MergingSettableBeanProperty |
|
MethodProperty |
This concrete sub-class implements property that is set
using regular "setter" method.
|
MinimalClassNameIdResolver |
|
MismatchedInputException |
General exception type used as the base class for all JsonMappingException s
that are due to input not mapping to target definition; these are typically
considered "client errors" since target type definition itself is not the root cause
but mismatching input.
|
MissingNode |
This singleton node class is generated to denote "missing nodes"
along paths that do not exist.
|
Module |
Simple interface for extensions that can be registered with ObjectMapper
to provide a well-defined set of extensions to default functionality; such as
support for new data types.
|
Module.SetupContext |
Interface Jackson exposes to modules for purpose of registering
extended functionality.
|
MutableCoercionConfig |
Mutable version of CoercionConfig (or rather, extended API)
exposed during configuration phase of ObjectMapper
construction (via Builder).
|
MutableConfigOverride |
Extension of ConfigOverride that allows changing of
contained configuration settings.
|
Named |
Simple tag interface mostly to allow sorting by name.
|
NamedType |
Simple container class for types with optional logical name, used
as external identifier
|
NameTransformer |
Helper class used to encapsulate details of name mangling, transforming
of names using different strategies (prefixes, suffixes).
|
NameTransformer.Chained |
|
NameTransformer.NopTransformer |
|
NioPathDeserializer |
|
NioPathSerializer |
|
NoClass |
Marker class used with annotations to indicate "no class".
|
NonTypedScalarSerializerBase<T> |
Deprecated. |
NopAnnotationIntrospector |
|
NullifyingDeserializer |
Bogus deserializer that will simply skip all content there is to map
and returns Java null reference.
|
NullNode |
This singleton value class is used to contain explicit JSON null
value.
|
NullsAsEmptyProvider |
|
NullsConstantProvider |
|
NullSerializer |
This is a simple dummy serializer that will just output literal
JSON null value whenever serialization is requested.
|
NullsFailProvider |
|
NullValueProvider |
Helper interface implemented by classes that are to be used as
null providers during deserialization.
|
NumberDeserializers |
Container class for deserializers that handle core JDK primitive
(and matching wrapper) types, as well as standard "big" numeric types.
|
NumberDeserializers.BigDecimalDeserializer |
|
NumberDeserializers.BigIntegerDeserializer |
This is bit trickier to implement efficiently, while avoiding
overflow problems.
|
NumberDeserializers.BooleanDeserializer |
|
NumberDeserializers.ByteDeserializer |
|
NumberDeserializers.CharacterDeserializer |
|
NumberDeserializers.DoubleDeserializer |
|
NumberDeserializers.FloatDeserializer |
|
NumberDeserializers.IntegerDeserializer |
|
NumberDeserializers.LongDeserializer |
|
NumberDeserializers.NumberDeserializer |
For type Number.class , we can just rely on type
mappings that plain JsonParser.getNumberValue() returns.
|
NumberDeserializers.PrimitiveOrWrapperDeserializer<T> |
|
NumberDeserializers.ShortDeserializer |
|
NumberSerializer |
As a fallback, we may need to use this serializer for other
types of Number s: both custom types and "big" numbers
like BigInteger and BigDecimal .
|
NumberSerializers |
Container class for serializers used for handling standard JDK-provided
primitve number types and their wrapper counterparts (like Integer ).
|
NumberSerializers.Base<T> |
Shared base class for actual primitive/wrapper number serializers.
|
NumberSerializers.DoubleSerializer |
This is the special serializer for regular Double s (and
primitive doubles)
|
NumberSerializers.FloatSerializer |
|
NumberSerializers.IntegerSerializer |
This is the special serializer for regular Integer s
(and primitive ints)
|
NumberSerializers.IntLikeSerializer |
|
NumberSerializers.LongSerializer |
|
NumberSerializers.ShortSerializer |
|
NumericNode |
Intermediate value node used for numeric nodes.
|
ObjectArrayDeserializer |
Basic serializer that can serialize non-primitive arrays.
|
ObjectArraySerializer |
Generic serializer for Object arrays (Object[] ).
|
ObjectBuffer |
Helper class to use for constructing Object arrays by appending entries
to create arrays of various lengths (length that is not known a priori).
|
ObjectIdInfo |
Container object that encapsulates information usually
derived from JsonIdentityInfo annotation or its
custom alternatives
|
ObjectIdReader |
Object that knows how to deserialize Object Ids.
|
ObjectIdReferenceProperty |
|
ObjectIdReferenceProperty.PropertyReferring |
|
ObjectIdValueProperty |
Specialized SettableBeanProperty implementation used
for virtual property that represents Object Id that is used
for some POJO types (or properties).
|
ObjectIdWriter |
Object that knows how to serialize Object Ids.
|
ObjectMapper |
ObjectMapper provides functionality for reading and writing JSON,
either to and from basic POJOs (Plain Old Java Objects), or to and from
a general-purpose JSON Tree Model ( JsonNode ), as well as
related functionality for performing conversions.
|
ObjectMapper.DefaultTypeResolverBuilder |
|
ObjectMapper.DefaultTyping |
|
ObjectNode |
Node that maps to JSON Object structures in JSON content.
|
ObjectReader |
Builder object that can be used for per-serialization configuration of
deserialization parameters, such as root type to use or object
to update (instead of constructing new instance).
|
ObjectWriter |
Builder object that can be used for per-serialization configuration of
serialization parameters, such as JSON View and root type to use.
|
ObjectWriter.GeneratorSettings |
Helper class used for containing settings specifically related
to (re)configuring JsonGenerator constructed for
writing output.
|
ObjectWriter.Prefetch |
As a minor optimization, we will make an effort to pre-fetch a serializer,
or at least relevant TypeSerializer , if given enough
information.
|
OptionalHandlerFactory |
Helper class used for isolating details of handling optional+external types
(javax.xml classes) from standard factories that offer them.
|
PackageVersion |
Automatically generated from PackageVersion.java.in during
packageVersion-generate execution of maven-replacer-plugin in
pom.xml.
|
PlaceholderForType |
Helper type used when introspecting bindings for already resolved types,
needed for specialization.
|
POJONode |
Value node that contains a wrapped POJO, to be serialized as
a JSON constructed through data mapping (usually done by
calling ObjectMapper ).
|
POJOPropertiesCollector |
Helper class used for aggregating information about all possible
properties of a POJO.
|
POJOPropertyBuilder |
Helper class used for aggregating information about a single
potential POJO property.
|
POJOPropertyBuilder.Linked<T> |
Node used for creating simple linked lists to efficiently store small sets
of things.
|
POJOPropertyBuilder.MemberIterator<T extends AnnotatedMember> |
|
PolymorphicTypeValidator |
Interface for classes that handle validation of class-name - based subtypes used
with Polymorphic Deserialization: both via "default typing" and explicit
@JsonTypeInfo when using Java Class name as Type Identifier.
|
PolymorphicTypeValidator.Base |
|
PolymorphicTypeValidator.Validity |
Definition of return values to indicate determination regarding validity.
|
PrimitiveArrayBuilder<T> |
Base class for specialized primitive array builders.
|
PrimitiveArrayDeserializers<T> |
Container for deserializers used for instantiating "primitive arrays",
arrays that contain non-object java primitive types.
|
PropertyBasedCreator |
Object that is used to collect arguments for non-default creator
(non-default-constructor, or argument-taking factory method)
before creator can be called.
|
PropertyBasedObjectIdGenerator |
|
PropertyBasedObjectIdGenerator |
|
PropertyBindingException |
Base class for JsonMappingException s that are specifically related
to problems related to binding an individual property.
|
PropertyBuilder |
|
PropertyFilter |
Interface that defines API for filter objects use (as configured
using JsonFilter )
for filtering bean properties to serialize.
|
PropertyMetadata |
Simple container class used for storing "additional" metadata about
properties.
|
PropertyMetadata.MergeInfo |
Helper class used for containing information about expected merge
information for this property, if merging is expected.
|
PropertyName |
Simple value class used for containing names of properties as defined
by annotations (and possibly other configuration sources).
|
PropertyNamingStrategies |
|
PropertyNamingStrategies.KebabCaseStrategy |
|
PropertyNamingStrategies.LowerCamelCaseStrategy |
"No-operation" strategy that is equivalent to not specifying any
strategy: will simply return suggested standard bean naming as-is.
|
PropertyNamingStrategies.LowerCaseStrategy |
Simple strategy where external name simply only uses lower-case characters,
and no separators.
|
PropertyNamingStrategies.LowerDotCaseStrategy |
|
PropertyNamingStrategies.NamingBase |
Intermediate base class for simple implementations
|
PropertyNamingStrategies.SnakeCaseStrategy |
A PropertyNamingStrategy that translates typical camel case Java
property names to lower case JSON element names, separated by
underscores.
|
PropertyNamingStrategies.UpperCamelCaseStrategy |
A PropertyNamingStrategy that translates typical camelCase Java
property names to PascalCase JSON element names (i.e., with a capital
first letter).
|
PropertyNamingStrategy |
Class that defines how names of JSON properties ("external names")
are derived from names of POJO methods and fields ("internal names"),
in cases where no explicit annotations exist for naming.
|
PropertyNamingStrategy.KebabCaseStrategy |
Deprecated.
|
PropertyNamingStrategy.LowerCaseStrategy |
Deprecated.
|
PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy |
Deprecated.
|
PropertyNamingStrategy.LowerDotCaseStrategy |
Deprecated.
|
PropertyNamingStrategy.PascalCaseStrategy |
Deprecated.
|
PropertyNamingStrategy.PropertyNamingStrategyBase |
Deprecated.
|
PropertyNamingStrategy.SnakeCaseStrategy |
Deprecated.
|
PropertyNamingStrategy.UpperCamelCaseStrategy |
Deprecated.
|
PropertySerializerMap |
Helper container used for resolving serializers for dynamic (possibly but not
necessarily polymorphic) properties: properties whose type is not forced
to use dynamic (declared) type and that are not final.
|
PropertySerializerMap.SerializerAndMapResult |
Value class used for returning tuple that has both serializer
that was retrieved and new map instance
|
PropertyValue |
Base class for property values that need to be buffered during
deserialization.
|
PropertyValueBuffer |
Simple container used for temporarily buffering a set of
PropertyValue s.
|
PropertyWriter |
Base class for writers used to output property values (name-value pairs)
as key/value pairs via streaming API.
|
RawSerializer<T> |
This is a simple dummy serializer that will just output raw values by calling
toString() on value to serialize.
|
RawValue |
Helper class used to encapsulate "raw values", pre-encoded textual content
that can be output as opaque value with no quoting/escaping, using
JsonGenerator.writeRawValue(String) .
|
ReadableObjectId |
Simple value container for containing information about single Object Id
during deserialization
|
ReadableObjectId.Referring |
|
ReadOnlyClassToSerializerMap |
Optimized lookup table for accessing two types of serializers; typed
and non-typed.
|
ReferenceType |
Specialized SimpleType for types that are referential types,
that is, values that can be dereferenced to another value (or null),
of different type.
|
ReferenceTypeDeserializer<T> |
Base deserializer implementation for properties ReferenceType values.
|
ReferenceTypeSerializer<T> |
|
ResolvableDeserializer |
Interface used to indicate deserializers that want to do post-processing
after construction but before being returned to caller (and possibly cached)
and used.
|
ResolvableSerializer |
Interface used to indicate serializers that want to do post-processing
after construction and being added to SerializerProvider ,
but before being used.
|
ResolvedRecursiveType |
Internal placeholder type used for self-references.
|
RootNameLookup |
Helper class for caching resolved root names.
|
RuntimeJsonMappingException |
|
SchemaAware |
Marker interface for schema-aware serializers.
|
SequenceWriter |
Writer class similar to ObjectWriter , except that it can be used
for writing sequences of values, not just a single value.
|
SerializableSerializer |
|
SerializationConfig |
Object that contains baseline configuration for serialization
process.
|
SerializationFeature |
Enumeration that defines simple on/off features that affect
the way Java objects are serialized.
|
SerializerCache |
Simple cache object that allows for doing 2-level lookups: first level is
by "local" read-only lookup Map (used without locking)
and second backup level is by a shared modifiable HashMap.
|
SerializerFactory |
|
SerializerFactoryConfig |
|
SerializerProvider |
Class that defines API used by ObjectMapper and
JsonSerializer s to obtain serializers capable of serializing
instances of specific types; as well as the default implementation
of the functionality.
|
Serializers |
Interface that defines API for simple extensions that can provide additional serializers
for various types.
|
Serializers.Base |
Basic Serializers implementation that implements all methods but provides
no serializers.
|
SettableAnyProperty |
Class that represents a "wildcard" set method which can be used
to generically set values of otherwise unmapped (aka "unknown")
properties read from Json content.
|
SettableBeanProperty |
Base class for deserializable properties of a bean: contains
both type and name definitions, and reflection-based set functionality.
|
SettableBeanProperty.Delegating |
Helper class that is designed to both make it easier to sub-class
delegating subtypes and to reduce likelihood of breakage when
new methods are added.
|
SetterlessProperty |
This concrete sub-class implements Collection or Map property that is
indirectly by getting the property value and directly modifying it.
|
ShortNode |
Numeric node that contains simple 16-bit integer values.
|
SimpleAbstractTypeResolver |
Simple AbstractTypeResolver implementation, which is
based on static mapping from abstract super types into
sub types (concrete or abstract), but retaining generic
parameterization.
|
SimpleBeanPropertyDefinition |
Simple immutable BeanPropertyDefinition implementation that can
be wrapped around a AnnotatedMember that is a simple
accessor (getter) or mutator (setter, constructor parameter)
(or both, for fields).
|
SimpleBeanPropertyFilter |
Simple PropertyFilter implementation that only uses property name
to determine whether to serialize property as is, or to filter it out.
|
SimpleBeanPropertyFilter.FilterExceptFilter |
Filter implementation which defaults to filtering out unknown
properties and only serializes ones explicitly listed.
|
SimpleBeanPropertyFilter.SerializeExceptFilter |
Filter implementation which defaults to serializing all
properties, except for ones explicitly listed to be filtered out.
|
SimpleDeserializers |
Simple implementation Deserializers which allows registration of
deserializers based on raw (type erased class).
|
SimpleFilterProvider |
Simple FilterProvider implementation that just stores
direct id-to-filter mapping.
|
SimpleKeyDeserializers |
Simple implementation KeyDeserializers which allows registration of
deserializers based on raw (type erased class).
|
SimpleMixInResolver |
|
SimpleModule |
Vanilla Module implementation that allows registration
of serializers and deserializers, bean serializer
and deserializer modifiers, registration of subtypes and mix-ins
as well as some other commonly
needed aspects (addition of custom AbstractTypeResolver s,
ValueInstantiator s).
|
SimpleSerializers |
Simple implementation Serializers which allows registration of
serializers based on raw (type erased class).
|
SimpleType |
Simple types are defined as anything other than one of recognized
container types (arrays, Collections, Maps).
|
SimpleValueInstantiators |
|
SqlBlobSerializer |
Serializer implementation for Blob to write as binary
(for JSON and other formats Base64-encoded String, for binary formats as
true binary).
|
SqlDateSerializer |
Compared to regular Date serialization, we do use String
representation here.
|
SqlTimeSerializer |
|
StackTraceElementDeserializer |
|
StaticListSerializerBase<T extends java.util.Collection<?>> |
Intermediate base class for Lists, Collections and Arrays
that contain static (non-dynamic) value types.
|
StdArraySerializers |
Dummy container class to group standard homogenous array serializer implementations
(primitive arrays and String array).
|
StdArraySerializers.BooleanArraySerializer |
|
StdArraySerializers.CharArraySerializer |
Character arrays are different from other integral number arrays in that
they are most likely to be textual data, and should be written as
Strings, not arrays of entries.
|
StdArraySerializers.DoubleArraySerializer |
|
StdArraySerializers.FloatArraySerializer |
|
StdArraySerializers.IntArraySerializer |
|
StdArraySerializers.LongArraySerializer |
|
StdArraySerializers.ShortArraySerializer |
|
StdArraySerializers.TypedPrimitiveArraySerializer<T> |
Intermediate base class used for cases where we may add
type information (excludes boolean/int/double arrays).
|
StdConverter<IN,OUT> |
Standard implementation of Converter that supports explicit
type access, instead of relying type detection of generic type
parameters.
|
StdDateFormat |
Default DateFormat implementation used by standard Date
serializers and deserializers.
|
StdDelegatingDeserializer<T> |
Deserializer implementation where given Java type is first deserialized
by a standard Jackson deserializer into a delegate type; and then
this delegate type is converted using a configured
Converter into desired target type.
|
StdDelegatingSerializer |
Serializer implementation where given Java type is first converted
to an intermediate "delegate type" (using a configured
Converter , and then this delegate value is serialized by Jackson.
|
StdDeserializer<T> |
Base class for common deserializers.
|
StdJdkSerializers |
Class that providers access to serializers user for non-structured JDK types that
are serializer as scalars; some using basic ToStringSerializer ,
others explicit serializers.
|
StdJdkSerializers.AtomicBooleanSerializer |
|
StdJdkSerializers.AtomicIntegerSerializer |
|
StdJdkSerializers.AtomicLongSerializer |
|
StdKeyDeserializer |
Default KeyDeserializer implementation used for most Map
types Jackson supports.
|
StdKeyDeserializers |
Helper class used to contain simple/well-known key deserializers.
|
StdKeySerializer |
Deprecated.
|
StdKeySerializers |
|
StdKeySerializers.Default |
This is a "chameleon" style multi-type key serializer for simple
standard JDK types.
|
StdKeySerializers.Dynamic |
Key serializer used when key type is not known statically, and actual key
serializer needs to be dynamically located.
|
StdKeySerializers.EnumKeySerializer |
Specialized instance to use for Enum keys, as per [databind#1322]
|
StdKeySerializers.StringKeySerializer |
Simple and fast key serializer when keys are Strings.
|
StdNodeBasedDeserializer<T> |
Convenience deserializer that may be used to deserialize values given an
intermediate tree representation ( JsonNode ).
|
StdScalarDeserializer<T> |
Base class for deserializers that handle types that are serialized
as JSON scalars (non-structured, i.e.
|
StdScalarSerializer<T> |
|
StdSerializer<T> |
Base class used by all standard serializers, and can also
be used for custom serializers (in fact, this is the recommended
base class to use).
|
StdSubtypeResolver |
|
StdTypeResolverBuilder |
|
StdValueInstantiator |
Default ValueInstantiator implementation, which supports
Creator methods that can be indicated by standard Jackson
annotations.
|
StringArrayDeserializer |
|
StringArraySerializer |
Standard serializer used for String[] values.
|
StringCollectionDeserializer |
Specifically optimized version for Collection s
that contain String values; reason is that this is a very common
type and we can make use of the fact that Strings are final.
|
StringCollectionSerializer |
Efficient implement for serializing Collection s that contain Strings.
|
StringDeserializer |
|
StringSerializer |
This is the special serializer for regular String s.
|
SubtypeResolver |
Helper object used for handling registration on resolving of super-types
to sub-types.
|
SubTypeValidator |
Helper class used to encapsulate rules that determine subtypes that
are invalid to use, even with default typing, mostly due to security
concerns.
|
TextNode |
Value node that contains a text value.
|
ThrowableDeserializer |
Deserializer that builds on basic BeanDeserializer but
override some aspects like instance construction.
|
TimeZoneSerializer |
|
TokenBuffer |
Utility class used for efficient storage of JsonToken
sequences, needed for temporary buffering.
|
TokenBuffer.Parser |
|
TokenBuffer.Segment |
Individual segment of TokenBuffer that can store up to 16 tokens
(limited by 4 bits per token type marker requirement).
|
TokenBufferDeserializer |
We also want to directly support deserialization of TokenBuffer .
|
TokenBufferReadContext |
Implementation of JsonStreamContext used by TokenBuffer
to link back to the original context to try to keep location information
consistent between source location and buffered content when it's re-read
from the buffer.
|
TokenBufferSerializer |
We also want to directly support serialization of TokenBuffer ;
and since it is part of core package, it cannot implement
JsonSerializable
(which is only included in the mapper package)
|
ToStringSerializer |
Simple general purpose serializer, useful for any
type for which Object.toString() returns the desired JSON
value.
|
ToStringSerializerBase |
Intermediate base class that serves as base for standard ToStringSerializer
as well as for custom subtypes that want to add processing for converting from
value to output into its String representation (whereas standard version
simply calls value object's toString() method).
|
TreeTraversingParser |
Facade over JsonNode that implements JsonParser to allow
accessing contents of JSON tree in alternate form (stream of tokens).
|
TypeBase |
|
TypeBindings |
Helper class used for resolving type parameters for given class
|
TypeDeserializer |
Interface for deserializing type information from JSON content, to
type-safely deserialize data into correct polymorphic instance
(when type inclusion has been enabled for type handled).
|
TypeDeserializerBase |
|
TypeFactory |
Class used for creating concrete JavaType instances,
given various inputs.
|
TypeIdResolver |
Interface that defines standard API for converting types
to type identifiers and vice versa.
|
TypeIdResolverBase |
Partial base implementation of TypeIdResolver : all custom implementations
are strongly recommended to extend this class, instead of directly
implementing TypeIdResolver .
|
TypeKey |
Key that offers two "modes"; one with raw class, as used for
cases were raw class type is available (for example, when using
runtime type); and one with full generics-including.
|
TypeModifier |
Class that defines API that can be used to modify details of
JavaType instances constructed using TypeFactory .
|
TypeNameIdResolver |
|
TypeParser |
Simple recursive-descent parser for parsing canonical JavaType
representations and constructing type instances.
|
TypeResolutionContext |
Interface that defines API used by members (like AnnotatedMethod )
to dynamically resolve types they have.
|
TypeResolutionContext.Basic |
|
TypeResolutionContext.Empty |
Dummy implementation for case where there are no bindings available
(for example, for static methods and fields)
|
TypeResolverBuilder<T extends TypeResolverBuilder<T>> |
Interface that defines builders that are configured based on
annotations (like JsonTypeInfo or JAXB annotations),
and produce type serializers and deserializers used for
handling type information embedded in JSON to allow for safe
polymorphic type handling.
|
TypeSerializer |
Interface for serializing type information regarding instances of specified
base type (super class), so that exact subtype can be properly deserialized
later on.
|
TypeSerializerBase |
|
TypeWrappedDeserializer |
Simple deserializer that will call configured type deserializer, passing
in configured data deserializer, and exposing it all as a simple
deserializer.
|
TypeWrappedSerializer |
Simple serializer that will call configured type serializer, passing
in configured data serializer, and exposing it all as a simple
serializer.
|
UnknownSerializer |
|
UnrecognizedPropertyException |
Specialized JsonMappingException sub-class specifically used
to indicate problems due to encountering a JSON property that could
not be mapped to an Object property (via getter, constructor argument
or field).
|
UnresolvedForwardReference |
Exception thrown during deserialization when there are object id that can't
be resolved.
|
UnresolvedId |
|
UnsupportedTypeDeserializer |
|
UnsupportedTypeSerializer |
|
UntypedObjectDeserializer |
Deserializer implementation that is used if it is necessary to bind content of
"unknown" type; something declared as basic Object
(either explicitly, or due to type erasure).
|
UntypedObjectDeserializer.Vanilla |
Streamlined version of UntypedObjectDeserializer that has fewer checks and
is only used when no custom deserializer overrides are applied.
|
UnwrappedPropertyHandler |
Object that is responsible for handling acrobatics related to
deserializing "unwrapped" values; sets of properties that are
embedded (inlined) as properties of parent JSON object.
|
UnwrappingBeanPropertyWriter |
Variant of BeanPropertyWriter which will handle unwrapping
of JSON Object (including of properties of Object within surrounding
JSON object, and not as sub-object).
|
UnwrappingBeanSerializer |
|
UUIDDeserializer |
|
UUIDSerializer |
|
ValueInjector |
Class that encapsulates details of value injection that occurs before
deserialization of a POJO.
|
ValueInstantiationException |
Exception type used for generic failures during processing by
ValueInstantiator :
commonly used to wrap exceptions thrown by constructor or factory
method.
|
ValueInstantiator |
Class that defines simple API implemented by objects that create value
instances.
|
ValueInstantiator.Base |
|
ValueInstantiator.Delegating |
Delegating ValueInstantiator implementation meant as a base type
that by default delegates methods to specified fallback instantiator.
|
ValueInstantiator.Gettable |
|
ValueInstantiators |
|
ValueInstantiators.Base |
Basic "NOP" implementation that can be used as the base class for custom implementations.
|
ValueNode |
This intermediate base class is used for all leaf nodes, that is,
all non-container (array or object) nodes, except for the
"missing node".
|
ViewMatcher |
Helper class used for checking whether a property is visible
in the active view
|
VirtualAnnotatedMember |
Placeholder used by virtual properties as placeholder for
underlying AnnotatedMember .
|
VirtualBeanPropertyWriter |
|
VisibilityChecker<T extends VisibilityChecker<T>> |
Interface for object used for determine which property elements
(methods, fields, constructors) can be auto-detected, with respect
to their visibility modifiers.
|
VisibilityChecker.Std |
Default standard implementation is purely based on visibility
modifier of given class members, and its configured minimum
levels.
|
WithMember<T> |
|
WritableObjectId |
Simple value container used to keep track of Object Ids during
serialization.
|