|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
AbstractTypeResolver
instance, to handle resolution of
abstract to concrete types (either by defaulting, or by materializing).
JsonToken.FIELD_NAME
instead of String value).
classWithMixIns
contains into class
destinationClass
.
JsonSerializer.handledType()
specifies (which MUST return a non-null class; and can NOT be Object
, as a
sanity check).
TypeModifier
instance, which can augment JavaType
instances constructed by TypeFactory
.
AnnotationMap
).AnnotatedMethod
s, accessible by lookup.BeanPropertyWriter
, but that will be used
for serializing JsonAnyGetter
annotated
(Map) propertiesAnnotationIntrospector
as the lowest
priority introspector, chained with existing introspector(s) and called
as fallback for cases not otherwise handled.
AnnotationIntrospector
as the lowest
priority introspector, chained with existing introspector(s) and called
as fallback for cases not otherwise handled.
ArrayNode
Construction is done using registered JsonNodeFactory
.
String[]
values.JsonTypeInfo.As.WRAPPER_ARRAY
inclusion mechanism.JsonParser
that can read contents
stored in this buffer.
JsonParser
that can read contents
stored in this buffer.
JsonTypeInfo.As.PROPERTY
inclusion mechanism.JsonTypeInfo.As.WRAPPER_OBJECT
inclusion mechanism.JsonNode
implementations.BeanDescription
implementation.Collection
).Collection
).ClassIntrospector
to
help in constructing serializers and deserializers.JsonDeserializer
for deserializing
intances.BeanDeserializerFactory
to participate in constructing BeanDeserializer
instances.JsonFilter
)
for filtering bean properties to serialize.SettableBeanProperty
instances.JsonSerializer
for serializing
intances.Object.getClass()
does not count);
as well as for "standard" JDK types.BeanSerializerFactory
to participate in constructing BeanSerializer
instances.BeanSerializer
instance with
all accumulated information.
Object[]
(and subtypes, except for String).
List
types that support efficient by-index access
EnumMap
types.
Map
and
ones that do not (but that have been indicated to behave like Maps).
Map
types.
ByteArrayOutputStream
in usage, but more geared to Jackson use cases internally.Name
s, constructed directly from a byte-based
input source.JsonGenerator.setSchema(org.codehaus.jackson.FormatSchema)
).
JsonParser.setSchema(org.codehaus.jackson.FormatSchema)
).
BeanSerializerFactory
with tentative set
of discovered properties.
JacksonJsonProvider.isReadable(java.lang.Class>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType)
is called.
JacksonJsonProvider.isWriteable(java.lang.Class>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType)
is called.
JsonSerializer
s.JsonParser.hasCurrentToken()
returns false, and
JsonParser.getCurrentToken()
null).
JsonParser.Feature.AUTO_CLOSE_SOURCE
is enabled.
Collection
instance, with typed contents.Collection
;
but may or may not be instances of that interface.Comparable
) is to prevent constructing a
reference without type information.
ObjectBuffer.completeAndClearBuffer(Object[], int)
, to allow
for constructing explicitly typed result array.
JsonParser.Feature
for list of features)
JsonGenerator.Feature
for list of features)
JsonGenerator.Feature
for list of available features.
JsonParser.Feature
for list of features)
JsonParser
feature for
JsonFactory
instance this object mapper uses.
JsonGenerator
feature for
JsonFactory
instance this object mapper uses.
SmileParser.Feature
for list of features)
JsonGenerator.Feature
for list of features)
SettableAnyProperty
for handling unknown bean properties, given a method that
has been designated as such setter.
ArrayType
.
ArrayType
.
BeanDeserializerBuilder
which is used to accumulate information needed to create deserializer
instance.
CollectionLikeType
.
CollectionLikeType
.
CollectionType
.
CollectionType
.
JavaType
out of its canonical
representation (see JavaType.toCanonical()
).
MapLikeType
instance
MapLikeType
instance
MapType
instance
MapType
instance
JavaType
that
represents a parameterized type.
JavaType
that
represents a parameterized type.
JavaType
for given
raw class.
JavaType
out of given
type (typically java.lang.Class
), but without explicit
context.
EnumResolver.constructUsingToString(java.lang.Class)
if static type of enum is not known.
AnnotatedClass.construct(java.lang.Class>, org.codehaus.jackson.map.AnnotationIntrospector, org.codehaus.jackson.map.ClassIntrospector.MixInResolver)
, but that will NOT include
information from supertypes; only class itself and any direct
mix-ins it may have.
List
s,
Map
s and such.LinkedList
that can not}.BigDecimal
.
JsonDeserializer
s can implement to get a callback
that can be used to create contextual instances of deserializer to use for
handling properties of supported type.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.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.DeserializationConfig
object
that defines configuration settings for deserialization.
SerializationConfig
object
that defines configuration settings for serialization.
DeserializerProvider
s call to create a new
deserializer for types other than Collections, Maps, arrays and
enums.
Enum
types.
JsonToken.FIELD_NAME
) for Map that has specified declared
key type, and is for specified property (or, if property is null, as root value)
JsonParser
for
parsing content which is assumed to be in detected data format.
JsonFactory
instance.
SerializerFactory
(see methods
like SerializerFactory.withAdditionalSerializers(Serializers)
)
and through new Module API. As such, this class is not the best way
to add custom functionality, and will likely be removed from 2.0 releaseJsonFactory
instances to use for actual low-level
detection.DataFormatDetector
when requested
to detect format of given input data.Date
values.JsonFactory
instance when
creating parser given an InputStream
, when this decorator
has been registered.
JsonFactory
instance when
creating parser on given "raw" byte source.
JsonFactory
instance when
creating parser given an Reader
, when this decorator
has been registered.
JsonFactory
instance when
creating generator for given OutputStream
, when this decorator
has been registered.
JsonFactory
instance when
creating generator for given Writer
, when this decorator
has been registered.
DateFormat
used unless overridden by
custom implementation.
DefaultPrettyPrinter
; will be removed in Jackson 2.0PrettyPrinter
implementation that uses 2-space
indentation with platform-default linefeeds.ObjectWriter
that will
serialize objects using the default pretty printer for indentation
SerializationConfig
settings to determine expected serialization
behavior.
SerializationConfig
settings to determine expected serialization
behavior.
Class
or Method
.
DeserializationConfig
object owner by
ObjectMapper
) to get calledn when a potentially
recoverable problem is encountered during deserialization
process.SettableBeanProperty.deserializeAndSet(org.codehaus.jackson.JsonParser, org.codehaus.jackson.map.DeserializationContext, java.lang.Object)
implementations.
JsonDeserializer.deserialize(JsonParser, DeserializationContext)
),
which takes in initialized value instance, to be
configured and/or populated by deserializer.
DeserializerProvider
to obtain actual
JsonDeserializer
instances from multiple distinct factories.ObjectMapper
and
JsonDeserializer
s to obtain deserializers capable of
re-constructing instances of handled type from JSON content.Deserializers
implementation that implements all methods but provides
no deserializers.JsonParser.Feature
for list of features)
JsonGenerator.Feature
for list of features)
JsonGenerator.Feature
for list of features)
JsonParser.Feature
for list of features)
SmileParser.Feature
for list of features)
JsonGenerator.Feature
for list of features)
JsonTypeInfo
) will have
additional embedded type information.
JsonGenerator.disable(org.codehaus.jackson.JsonGenerator.Feature)
instead
JsonParser.disable(Feature)
instead
JsonFactory.disable(JsonGenerator.Feature)
instead
JsonFactory.disable(JsonParser.Feature)
instead
JsonParser.Feature
for list of features)
JsonGenerator.Feature
for list of features)
JsonGenerator.Feature
for list of available features.
JsonParser.Feature
for list of features)
SmileParser.Feature
for list of features)
JsonGenerator.Feature
for list of features)
JsonTypeInfo
).
JsonTypeInfo
) --
using "As.PROPERTY" inclusion mechanism and specified property name
to use for inclusion (default being "@class" since default type information
always uses class name as type identifier)
JsonGenerator.enable(org.codehaus.jackson.JsonGenerator.Feature)
instead
JsonParser.enable(Feature)
instead
JsonFactory.enable(JsonGenerator.Feature)
instead
JsonFactory.enable(JsonParser.Feature)
instead
EnumMap
s.Enum
types.CharacterEscapes.getEscapeSequence(int)
is needed to figure out exact escape
sequence to output.
JsonGenerationException
if its FailingSerializer.serialize(java.lang.Object, org.codehaus.jackson.JsonGenerator, org.codehaus.jackson.map.SerializerProvider)
gets invoeked.BeanPropertyWriter
that will filter out
properties that are not to be included in currently active
JsonView.ObjectWriter
that will
serialize objects using specified filter provider.
BeanPropertyFilter
that match given ids.XmlAccessType
annotation value
for given annotated entity, if it has one, or inherits one from
its ancestors (in JAXB sense, package etc).
JsonAnyGetter
.
JsonAnySetter
.
BeanDeserializerFactory
to properly link
managed- and back-reference pairs.
BeanSerializer
for
given class.
Collection
(List, Set etc) type.
Collection
but does not implement it).
Collection
, array
or
Map
property.
Collection
, array
or Map
property.
Enum
type.
EnumSet
, without having
access to its declaration.
EnumSet
, without having
access to its declaration.
BeanPropertyFilter
that has specified id.
InputStream
) given has, as per configuration of this detector
instance.
JsonValue
annotation,
if any.
Map
property.
Map
.
Map
property.
Map
type.
Map
but does not implement it).
JsonNode.findValue(java.lang.String)
, but that will return a
"missing node" instead of null if no field is found.
JsonTypeInfo
from a property too.
JsonTypeInfo
from a property too.
findSerializerByLookup
).
BeanDeserializerFactory
to see if there might be a standard
deserializer registered for given type.
JsonNode.findValues(java.lang.String)
, but will additionally convert
values into Strings, calling JsonNode.getValueAsText()
.
SerializerProvider.findValueSerializer(Class)
, but takes full generics-aware
type instead of raw class.
AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject[], boolean)
on
the underlying annotated element.
StdDeserializerProvider.cachedDeserializersCount()
).
DeserializerProvider.cachedDeserializersCount()
).
JavaType.narrowBy(java.lang.Class>)
, called by
internal framework in cases where compatibility checks
are to be skipped.
JsonFactory.getFormatName()
JsonParser
and JsonGenerator
implementations to further
specify structure of expected format.TypeFactory.type(Type)
instead
TypeFactory.type(Type)
instead
TypeFactory.type(Type)
instead
AnnotationIntrospector
configured
to introspect annotation values used for configuration.
AnnotationIntrospector
configured
to introspect annotation values used for configuration.
JsonToken.VALUE_NUMBER_INT
and
it can not be used as a Java long primitive type due to its
magnitude.
JsonNode.isBinary()
returns true); or for Text Nodes
(ones for which JsonNode.getTextValue()
returns non-null value),
to read decoded base64 data.
JsonParser.getBinaryValue(Base64Variant)
that defaults to using
Base64Variants.getDefaultVariant()
as the default encoding.
JsonToken.VALUE_TRUE
or
JsonToken.VALUE_FALSE
.
JsonToken.VALUE_NUMBER_INT
and
it can be expressed as a value of Java byte primitive type.
JsonGenerator
s
it creates.
JsonGenerator
s
it creates.
JsonGenerator
s
it creates.
JsonGenerator
s
it creates.
JsonGenerator.writeObject(java.lang.Object)
).
ObjectCodec
associated with this
parser, if any.
ObjectMapper
to use
JsonToken.FIELD_NAME
s it will
be the same as what JsonParser.getText()
returns;
for field values it will be preceding field name;
and for others (array values, root-level values) null.
JsonToken.VALUE_NUMBER_FLOAT
or
JsonToken.VALUE_NUMBER_INT
.
DeserializationConfig
object
that defines configuration settings for deserialization.
JsonToken.VALUE_NUMBER_FLOAT
and
it can be expressed as a Java double primitive type.
JsonNode.get(int)
instead.
JsonToken.VALUE_EMBEDDED_OBJECT
.
JsonNode.get(String)
instead.
JsonToken.VALUE_NUMBER_FLOAT
and
it can be expressed as a Java float primitive type.
InputStream
or Reader
, depending on what
parser was constructed with.
JsonNode.isNumber()
returns true).
JsonToken.VALUE_NUMBER_INT
and
it can be expressed as a value of Java int primitive type.
JsonFactory
that this
mapper uses if it needs to construct JsonParser
s
and/or JsonGenerator
s.
JsonParser.clearCurrentToken()
.
JsonToken.VALUE_NUMBER_INT
and
it can be expressed as a Java long primitive type.
ObjectMapper
that implements this context.
JsonFactory
that represents format that data matched.
MatchStrength.INCONCLUSIVE
.
JsonNodeFactory
that this mapper will use when directly constructing
root JsonNode
instances for Trees.
JsonToken.VALUE_NULL
).
JsonNode.isNumber()
),
returns native type that node uses to store the numeric
value.
JsonToken.VALUE_NUMBER_INT
or
JsonToken.VALUE_NUMBER_FLOAT
, returns
one of JsonParser.NumberType
constants; otherwise returns null.
JsonNode.isNumber()
returns true); otherwise
returns null
OutputStream
or Writer
, depending on what
generator was constructed with.
JsonNode.path(String)
instead
JsonNode.path(int)
instead
SettableBeanProperty.getName()
instead.
BeanDeserializer
have
been collected.
SerializationConfig
object that defines configuration settings for serialization.
JsonToken.VALUE_NUMBER_INT
and
it can be expressed as a value of Java short primitive type.
ReaderBasedParser.nextToken()
, or
after encountering end-of-input), returns null.
JsonParser.nextToken()
, or
after encountering end-of-input), returns null.
SmileParser.nextToken()
, or
after encountering end-of-input), returns null.
JsonParser.getText()
, but that will return
underlying (unmodifiable) character array that contains
textual value, instead of constructing a String object
to contain this information.
JsonParser.getTextCharacters()
, to know length
of String stored in returned buffer.
JsonParser.getTextCharacters()
, to know offset
of the first text content character within buffer.
TypeFactory
instance.
SerializerFactory
instances are able to construct a serializer.
JsonNode.isValueNode()
returns true), otherwise null.
JsonSerializer
s, JsonDeserializer
s, various type
handlers) of specific types.TokenBuffer
(as field entries, name and value).
DeserializationProblemHandler
s
of an unrecognized property.
DeserializationProblemHandler
s
of an unrecognized property.
ByteSourceBootstrapper
);
supports UTF-8, for example.
MappingIterator.next()
but one that may throw checked
exceptions from Jackson due to invalid input.
JsonParser.getTextCharacters()
would be the most efficient
way to access textual content for the event parser currently
points to.
Class
(and/or various Type subtypes)
that is used as part of single-path extends/implements chain to express
specific relationship between one subtype and one supertype.List
s that contains Strings and are random-accessible.InetAddress
.NumberInput.inLongRange(char[],int,int,boolean)
, but
with String argument
InputStream
and buffers it as necessary.AnnotationIntrospector
as the highest
priority introspector (will be chained with existing introspector(s) which
will be used as fallbacks for cases this introspector does not handle)
AnnotationIntrospector
as the highest
priority introspector (will be chained with existing introspector(s) which
will be used as fallbacks for cases this introspector does not handle)
JsonNodeDeserializer.getDeserializer(java.lang.Class>)
accessor instead
BasicSerializerFactory
, this factory is stateless, and
thus a single shared global (== singleton) instance can be used
without thread-safety issues.
JsonParser.Feature
is enabled.
JsonToken.START_ARRAY
) when start array is expected.
JsonGenerator.isEnabled(org.codehaus.jackson.JsonGenerator.Feature)
instead
JsonParser.isEnabled(Feature)
instead
JsonFactory.isEnabled(JsonGenerator.Feature)
instead
BasicBeanDescription.isCglibGetCallbacks(org.codehaus.jackson.map.introspect.AnnotatedMethod)
, need to suppress
a cyclic reference to resolve [JACKSON-103]
JsonFactory.isEnabled(JsonParser.Feature)
instead
Collection
or just something that acts
like one.
Collection
or just something that acts
like one.
JsonNode.getElements()
; implemented so that
convenience "for-each" loop can be used for looping over elements
of JSON Array constructs.
AnnotationIntrospector
implementation that handles standard
Jackson annotations.MessageBodyReader
,
MessageBodyWriter
) needed for binding
JSON ("application/json") content to and from Java Objects ("POJO"s).ToStringSerializer
,
others explicit serializers.DateTime
.JsonAnySetter
method; basically being used like a
getter but such that contents of the returned Map (type must be
Map
) are serialized as if they were actual properties
of the bean that contains method/field with this annotations.JsonDeserializer
)
can be cached.JsonDeserialize.as()
insteadJsonDeserialize.contentAs()
insteadObjectMapper
(and
other chained JsonDeserializer
s too) to deserialize Objects of
arbitrary types from JSON, using provided JsonParser
.JsonParser
)
and writer (aka generator, JsonGenerator
)
instances.ObjectMapper
(or objects
it delegates to) providing matching filters by id.JsonProperty
instead (deprecated since version 1.5)JsonDeserialize.keyAs()
insteadExceptionMapper
to send down a "400 Bad Request"
response in the event that unmappable JSON is received.JsonAutoDetect
apply to.JsonNode
from any
JSON content, using appropriate JsonNode
type.JsonParser
implementations.ExceptionMapper
to send down a "400 Bad Request"
in the event unparsable JSON is received.JsonParser
implementations.JsonParser
,
to allow for simple overridability of basic parsing functionality.JsonParser
implementations, but does not add any additional fields that depend
on particular method of obtaining input.JsonParser
s to create a single logical sequence of
tokens, as a single JsonParser
.JsonStreamContext
, which implements
core methods needed, and also exposes
more complete API to parser implementation classes.JsonNode
that represents a JSON-Schema instance.JsonSerializableWithType
insteadJsonSerializable
to
allow for dynamic type information embedding.JsonSerialize.include()
property
to define which properties
of Java Beans are to be included in serializationJsonSerialize.typing()
property
to define whether type detection is based on dynamic runtime
type (DYNAMIC) or declared type (STATIC).ObjectMapper
(and
other chained JsonSerializer
s too) to serialize Objects of
arbitrary types into JSON, using provided JsonGenerator
.JsonProperty
annotation (which was introduced in version 1.1).JsonTypeInfo
to indicate sub types of serializable
polymorphic types, and to associate logical names used within JSON content
(which is more portable than using physical Java class names).TypeIdResolver
)
to be used by
TypeSerializer
s
and TypeDeserializer
s
for converting between java types and type id included in JSON content.XmlValue
that indicates that results of the annotated "getter" method
(which means signature must be that of getters; non-void return
type, no args) is to be used as the single value to serialize
for the instance.JsonValue
annotation to
indicate that serialization should be done by calling the method
annotated, and serializing result it returns.JavaType
,
to ensure type has been properly resolved
JsonStreamContext
, which implements
core methods needed, and also exposes
more complete API to generator implementation classes.JsonSerialize.include()
(with values ALWAYS
or NON_NULL
)ObjectMapper
to use for serialization
and deserialization.
Map
instance, with typed contents.Map
, but that do not have enough
introspection functionality to allow for some level of generic handling.ObjectMapper
instance to be used for data binding, as
well as accessing it.ObjectMapper
when binding sequence of
objects.JsonFactory
that will create a proper
ObjectCodec
to allow seamless conversions between
Json content and Java objects (POJOs).Method
s and Constructor
s)
in Map
s.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.Base64Variants.MIME
which does not
use linefeeds (max line length set to infinite).
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.BeanDeserializerFactory
after constructing default
bean deserializer instance with properties collected and ordered earlier.
BeanSerializerFactory
after constructing default
bean serializer instance with properties collected and ordered earlier.
ObjectMapper
to provide a well-defined set of extensions to default functionality; such as
support for new data types.InputStream
.EOFException
.
Serializers
array (which by definition
is stateless and reusable)
AnnotationIntrospector
.Object[]
).JsonParser
and
JsonGenerator
use to serialize and deserialize regular
Java objects (POJOs aka Beans).JsonFactory
as necessary, use
StdSerializerProvider
as its
SerializerProvider
, and
BeanSerializerFactory
as its
SerializerFactory
.
JsonFactory
for constructing necessary JsonParser
s and/or
JsonGenerator
s.
ObjectMapper.setSerializerFactory(org.codehaus.jackson.map.SerializerFactory)
TypeResolverBuilder
that provides type resolver builders
used with so-called "default typing"
(see ObjectMapper.enableDefaultTyping()
for details).ObjectMapper.enableDefaultTyping()
to specify what kind of types (classes) default typing should
be used for.ObjectNode
Construction is done using registered JsonNodeFactory
.
ObjectMapper
for initial instantiation
ObjectMapper
for initial instantiation
BeanSerializerFactory
with set of properties
to serialize, in default ordering (based on defaults as well as
possible type annotations).
JsonFactory
used for constructing
JSON parser (JsonParser
)
and generator
(JsonParser
)
instances.ObjectMapper
class, as well
as convenience methods included in
JsonParser
TypeResolverBuilder
and
TypeIdResolver
.Module
s
(which are registered using
ObjectMapper.registerModule(org.codehaus.jackson.map.Module)
.JavaType
, as
well as the factory (TypeFactory
) for
constructing instances from various input data types
(like Class
, Type
)
and programmatically (for structured types, arrays,
List
s and Map
s).JsonNode
implementations
Jackson uses for the Tree model.MapperConfig.getDateFormat()
).
JsonNode.get(String)
, except
that instead of returning null if no such value exists (due
to this node not being an object, or object not having value
for the specified field),
a "missing node" (node that returns true for
JsonNode.isMissingNode()
) will be returned.
JsonNode.get(int)
, except
that instead of returning null if no such element exists (due
to index being out of range, or this node not being an array),
a "missing node" (node that returns true for
JsonNode.isMissingNode()
) will be returned.
Base64Variants.MIME
: it is otherwise
identical, except that it mandates shorter line length.
ObjectMapper
).ObjectWriter
that will
serialize objects using specified pretty printer for indentation
(or if null, no pretty printer)
BeanSerializerFactory
that is used to
construct BeanPropertyWriter
instances.PropertyValue
s.BasicDeserializerFactory
to register deserializers this class provides.
BasicSerializerFactory
to access
all serializers this class provides.
ObjectReader
with
default settings.
ObjectReader
that will
read or update instances of specified type
ObjectReader
that will
read or update instances of specified type
ObjectReader
that will
read or update instances of specified type
ObjectReader
that will
use specified JsonNodeFactory
for constructing JSON trees.
JsonParser
, which is
based on a Reader
to handle low-level character
conversion tasks.JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
Boolean
).
Boolean
).
Boolean
).
JsonNode
instances.
Boolean
).
JsonNode
of resulting model.
JsonIgnoreType
annotation but
can be supplied by module-provided introspectors too.
DeserializerProvider
,
but before being used.SerializerProvider
,
but before being used.DeserializerProvider
has registered
the deserializer, but before it has returned it to the caller.
SerializerProvider
has registered
the serializer, but before it has returned it to the caller.
DeserializationContext.leaseObjectBuffer()
.
JsonMappingException
ObjectReader
that will
pass specific schema object to JsonParser
used for
reading content.
ObjectWriter
that will
pass specific schema object to JsonGenerator
used for
writing content.
StringWriter
, based on using segmented
internal buffer.BeanPropertyWriter
instances.
JsonGenerator
.
BeanSerializer
to let filter decide what to do with
given bean property value: the usual choices are to either filter out (i.e.
BeanPropertyFilter
that needs to be called to determine
which properties are to be serialized (and possibly how)
SerializerProvider
to obtain actual
JsonSerializer
instances from multiple distinct factories.ObjectMapper
and
JsonSerializer
s to obtain serializers capable of serializing
instances of specific types.Serializers
implementation that implements all methods but provides
no serializers.ObjectMapper
to
execute recursive serialization, using serializers that
this provider has access to.
ObjectMapper
to
execute recursive serialization, using serializers that
this provider has access to; and using specified root type
for locating first-level serializer.
MapperConfig.withAnnotationIntrospector(AnnotationIntrospector)
or
Module API instead
AnnotationIntrospector
used by this
mapper instance for both serialization and deserialization
JsonGenerator
s
it creates.
JsonGenerator
s
it creates.
ObjectCodec
(typically
a ObjectMapper
) with
this factory (and more importantly, parsers and generators
it constructs).
JsonGenerator.writeObject(java.lang.Object)
).
ObjectCodec
associated with this
parser, if any.
ObjectMapper
instead; or construct new instance with
MapperConfig.withDateFormat(DateFormat)
DateFormat
to use when serializing time
values as Strings, and deserializing from JSON Strings.
SerializationConfig.withDateFormat(java.text.DateFormat)
instead.
DeserializerProvider
to use
for handling caching of JsonDeserializer
instances.
JsonGenerator.configure(org.codehaus.jackson.JsonGenerator.Feature, boolean)
instead
JsonParser.configure(org.codehaus.jackson.JsonParser.Feature, boolean)
instead
JsonFactory.configure(JsonGenerator.Feature, boolean)
instead
HandlerInstantiator
to use for creating
instances of handlers (such as serializers, deserializers, type and type
id resolvers), given a class.
MapperConfig.withClassIntrospector(ClassIntrospector)
instead
ObjectMapper
to use
for serialization and deserialization; if null, will use the standard
provider discovery from context instead.
DeserializationConfig.withNodeFactory(org.codehaus.jackson.node.JsonNodeFactory)
instead
JsonNodeFactory
to use for
constructing root level tree nodes (via method
ObjectMapper.createObjectNode()
JsonFactory.configure(JsonParser.Feature, boolean)
instead
SerializationConfig.withView(java.lang.Class>)
instead
SerializerFactory
to use
for constructing (bean) serializers.
SerializerProvider
to use
for handling caching of JsonSerializer
instances.
MapperConfig.withSubtypeResolver(SubtypeResolver)
instead.
TypeFactory
instance
used by this mapper.
JavaType.withTypeHandler(java.lang.Object)
instead -- this method is dangerous as
it changes state, whereas all other functionality is stateless
ObjectMapper
when module is registered.
AbstractTypeResolver
implementation, which is
based on static mapping from abstract super types into
sub types (concrete or abstract), but retaining generic
parameterization.BeanPropertyFilter
implementation that only uses property name
to determine whether to serialize property as is, or to filter it out.Deserializers
which allows registration of
deserializers based on raw (type erased class).FilterProvider
implementation that just stores
direct id-to-filter mapping.KeyDeserializers
which allows registration of
deserializers based on raw (type erased class).Module
implementation that allows registration
of serializers and deserializers, and bean serializer
and deserializer modifiers.Serializers
which allows registration of
serializers based on raw (type erased class).JsonToken.START_OBJECT
or JsonToken.START_ARRAY
.
SmileGenerator
and SmileParser
SmileParser
and SmileGenerator
instances; both of which handle
Smile encoded data.JsonGenerator
implementation for the experimental "Binary JSON Infoset".DateFormat
implementation used by standard Date
serializers and deserializers.DeserializationContext
.Number.class
, we can just rely on type
mappings that plain JsonParser.getNumberValue()
returns.Date
, SQL version is easier
to deal with: mostly because it is more limited.TokenBuffer
.DeserializerProvider
implementation.Map
s to JSON
Objects.SerializerProvider
implementation.StdSerializerProvider.createInstance(org.codehaus.jackson.map.SerializationConfig, org.codehaus.jackson.map.SerializerFactory)
(or by
sub-classes)
Double
s
(and primitive doubles)Integer
s
(and primitive ints)StdSerializers.IntegerSerializer
, but will not cast to Integer:
instead, cast is to Number
, and conversion is
by calling Number.intValue()
.Number
s (custom types).JsonSerializable
.JsonSerializableWithType
.StdSerializers.UtilDateSerializer
, we do use String
representation here.String
s.TokenBuffer
;
and since it is part of core package, it can not implement
JsonSerializable
(which is only included in the mapper
package)TypeResolverBuilder
implementation.Collection
s that contain Strings.StringBuffer
, with
following differences:
TextBuffer uses segments character arrays, to avoid having
to do additional array copies when array is not big enough.BeanDeserializer
but
override some aspects like instance construction.IllegalArgumentException
if it
is a checked exception; otherwise (runtime exception or error) throw as is
IllegalArgumentException
(and with
specified message) if it
is a checked exception; otherwise (runtime exception or error) throw as is
Exception
or Error
as is.
Timestamp
values.TypeFactory
from mapper package).
SmileConstants.TOKEN_MISC_FP
,
indicating 32-bit IEEE single precision floating point number.
SmileConstants.TOKEN_MISC_FP
,
indicating 64-bit IEEE double precision floating point number.
SmileConstants.TOKEN_MISC_FP
,
indicating BigDecimal
type.
SmileConstants.TOKEN_MISC_INTEGER
,
indicating 32-bit integer (int)
SmileConstants.TOKEN_MISC_INTEGER
,
indicating 32-bit integer (long)
SmileConstants.TOKEN_MISC_INTEGER
,
indicating BigInteger
type.
JsonToken
sequences, needed for temporary buffering.TextBuffer.contentsAsString()
, since it's not guaranteed that resulting
String is cached.
Object.toString()
returns the desired JSON
value.ToStringSerializer.instance
which is stateless and fully thread-safe.
JsonParser
instance for
iterating over contents of the tree that this
node is root of.
JsonParser
out of JSON tree
representation.
JsonParser
for reading
contents of a JSON tree, as if it was external serialized
JSON content.
ObjectMapper
insteadJsonNode
that implements JsonParser
to allow
accessing contents of JSON tree in alternate form (stream of tokens).ObjectWriter
that will
serialize objects using specified root type, instead of actual
runtime type of value.
ObjectWriter
that will
serialize objects using specified root type, instead of actual
runtime type of value.
ObjectWriter
that will
serialize objects using specified root type, instead of actual
runtime type of value.
JavaType
instances,
given various inputs.TypeIdResolver
of
specified type.
JavaType
instances constructed using TypeFactory
.JavaType
representations and constructing type instances.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.TypeIdResolver
of
specified type.
java.lang.Object
.
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).IllegalArgumentException
if it
is a checked exception; otherwise (runtime exception or error) throw as is
IllegalArgumentException
if it
is a checked exception; otherwise (runtime exception or error) throw as is
BeanDeserializerFactory
when it has collected
basic information such as tentative list of properties to deserializer.
BeanSerializerFactory
after collecting all information
regarding POJO to serialize and updating builder with it, but before constructing
serializer.
ObjectReader
that will
update given Object (usually Bean, but can be a Collection or Map
as well, but NOT an array) with JSON data.
DefaultPrettyPrinter
).
JsonParser
, which is
based on a InputStream
as the input source.EnumValues.serializedValueFor(java.lang.Enum>)
instead
ObjectMapper.treeToValue(org.codehaus.jackson.JsonNode, java.lang.Class)
; given a value (usually bean), will
construct equivalent JSON Tree representation.
Versioned.version()
.Version
for details).
Version
s.ObjectWriter
that will
serialize objects using specified JSON View (filter).
AbstractTypeResolver
.
DeserializerFactory
that provider has
to use specified deserializer provider, with highest precedence (that is,
additional providers have higher precedence than default one or previously
added ones)
KeyDeserializers
.
AnnotationIntrospector
to use (replacing old one).
ClassIntrospector
to use.
DateFormat
to use.
Feature.WRITE_DATES_AS_TIMESTAMPS
(enable if format set as null; disable if non-null)
BeanDeserializerModifier
.
HandlerInstantiator
to use.
Method
.
ObjectMapper.registerModule(org.codehaus.jackson.map.Module)
; functionally equivalent to:
PropertyNamingStrategy
to use.
SubtypeResolver
to use.
TypeFactory
to use.
TypeResolverBuilder
to use.
TypeSerializer
for decorating
contained values with additional type information.
VisibilityChecker
to use.
IOException
, or an unchecked exception.
DeserializationContext
DeserializationContext
IOException
, or an unchecked exception.
SerializerProvider
instead.
SerializerProvider
instead.
JsonGenerator.writeBinary(Base64Variant,byte[],int,int)
,
but default to using the Jackson default Base64 variant
(which is Base64Variants.MIME_NO_LINEFEEDS
).
JsonGenerator.writeBinary(Base64Variant,byte[],int,int)
,
but assumes default to using the Jackson default Base64 variant
(which is Base64Variants.MIME_NO_LINEFEEDS
).
JsonGenerator.writeFieldName(String)
, main difference
being that it may perform better as some of processing (such as
quoting of certain characters, or encoding into external encoding
if supported by generator) can be done just once and reused for
later calls.
JsonGenerator.writeFieldName(String)
, main difference
being that it may perform better as some of processing (such as
quoting of certain characters, or encoding into external encoding
if supported by generator) can be done just once and reused for
later calls.
ObjectWriter
with default settings.
JsonGenerator.writeString(String)
but that takes as
its input a UTF-8 encoded String that is to be output as-is, without additional
escaping (type of which depends on data format; backslashes for JSON).
JsonGenerator
that outputs JSON content using a Writer
which handles character encoding.JsonGenerator.writeString(String)
, but that takes
SerializableString
which can make this potentially
more efficient to call as generator may be able to reuse
quoted and/or encoded representation.
JsonGenerator
or ObjectMapper
instead.
ObjectReader
.
TypeSerializer.writeTypeSuffixForScalar(java.lang.Object, org.codehaus.jackson.JsonGenerator)
.
TypeSerializer.writeTypePrefixForObject(java.lang.Object, org.codehaus.jackson.JsonGenerator)
.
TypeSerializer.writeTypePrefixForScalar(java.lang.Object, org.codehaus.jackson.JsonGenerator)
.
JsonGenerator.writeString(String)
but that takes as its input
a UTF-8 encoded String which has not been escaped using whatever
escaping scheme data format requires (for JSON that is backslash-escaping
for control characters and double-quotes; for other formats something else).
JsonGenerator
.
JsonGenerator
,
configured as per passed configuration object.
JsonEncoding.UTF8
).
JsonGenerator
.
JsonEncoding.UTF8
).
ObjectMapper.viewWriter(java.lang.Class>)
instead
ObjectMapper.viewWriter(java.lang.Class>)
instead
ObjectMapper.viewWriter(java.lang.Class>)
instead
Class
or
ParameterizedType
.
JsonAnyGetter
annotated properties
MinimalClassNameIdResolver._basePackageName
, but includes trailing dot.
JsonParserMinimalBase.getBinaryValue(org.codehaus.jackson.Base64Variant)
will not need to decode data more
than once.
InputAccessor.Std._buffer
that are valid
buffered content.
DataFormatMatcher._bufferedData
that were read.
Writer
, for example)
should be delegated to regular Jackson JSON processing
(if set to true); or throw UnsupportedOperationException
(if set to false)
JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS
).
_charBuffer
JsonParseException
s
based on current state of the parser
TypeResolverBuilder
implementation.
getGenericXxx
methods
(usually for a return or argument type).
BeanPropertyWriter
for
given member (field or method).
Writer
and context object.
InputStream
and context object.
Reader
object for reading content.
Reader
object for reading content
passed as raw byte array.
OutputStream
and context object, using UTF-8 encoding.
JsonParser.nextToken()
, if any.
MapperConfigurator.setAnnotationsToUse(org.codehaus.jackson.jaxrs.Annotations[])
JsonSerialize.Inclusion.ALWAYS
, we need to know the default
value of the bean, to know if property value equals default
one.
JsonGenerator.Feature
s
are enabled.
JsonParser.Feature
s
are enabled.
TypeResolverBuilder
if given annotated element indicates one is needed.
BeanDeserializer.resolve(org.codehaus.jackson.map.DeserializationConfig, org.codehaus.jackson.map.DeserializerProvider)
).
TypeParser
when generics-aware version
is constructed.
JsonGenerator.Feature
s
are enabled.
Collection
instance that contained
the reference; used if index is relevant and available.
_buckets.length - 1
, when _buckets.length is
a power of two.
JsonParser
and JsonGenerator
instances as necessary.
JsonGenerator
s
JsonGenerator
s
JsonParser.clearCurrentToken()
was called.
ObjectMapper
DataFormatMatcher._match
BeanDeserializer
instances
are configured and constructed.
BeanSerializer
instances
are configured and constructed.
TypeModifier
s: objects that can change details
of JavaType
instances factory constructs.
JsonParserMinimalBase.getTextCharacters()
method (instead of String
returning alternatives)
JsonParserSequence._parsers
.
JsonNode
instances.
Map
having null key.
ObjectMapper
, but that abstract is not part of core
package.
Utf8Generator._outputStream
.
WriterBasedGenerator._writer
.
SmileGenerator._out
.
SmileGenerator._outputBuffer
.
char
s that we know will always fit
in the output buffer after escaping
SmileGenerator._outputBuffer
ObjectMapper
to use for actual
serialization.
InputAccessor.Std._buffer
.
ThreadLocal
contains a SoftRerefence
to a BufferRecycler
used to provide a low-cost
buffer recycling between reader and writer instances.
SmileGenerator._seenNames
; -1 if no shared name
detection is enabled
SmileGenerator._seenStringValues
; -1 if no shared text value
detection is enabled
SmileGenerator.Feature
s
are enabled.
ThreadLocal
contains a SoftRerefence
to a buffer recycler used to provide a low-cost
buffer recycling for Smile-specific buffers.
ThreadLocal
contains a SoftRerefence
to a buffer recycler used to provide a low-cost
buffer recycling for Smile-specific buffers.
ThreadLocal
contains a SoftRerefence
to a BufferRecycler
used to provide a low-cost
buffer recycling between reader and writer instances.
JavaType
instances;
needed to allow modules to add more custom type handling
(mostly to support types of non-Java JVM languages)
JavaType
instances;
needed to allow modules to add more custom type handling
(mostly to support types of non-Java JVM languages)
SimpleType._typeParameters
Object.class
)
Object
in some case)
JavaType._narrow(java.lang.Class>)
, since
underlying type construction is usually identical
JsonGeneratorBase.writeEndArray()
instead
of defining this method
JsonGeneratorBase.writeEndObject()
instead
of defining this method
_writeFieldName
, off-lined
to keep the "fast path" as simple (and hopefully fast) as possible.
_writeFieldName
, off-lined
to keep the "fast path" as simple (and hopefully fast) as possible.
JsonGeneratorBase.writeStartArray()
instead
of defining this method
JsonGeneratorBase.writeStartObject()
instead
of defining this method
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |