|
||||||||||
| 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).AnnotatedMethods, 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.Names, 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.
JsonSerializers.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.
Lists,
Maps and such.LinkedList
that can not}.BigDecimal.
JsonDeserializers can implement to get a callback
that can be used to create contextual instances of deserializer to use for
handling properties of supported type.KeyDeserializers 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.JsonSerializers 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.
DeserializerProviders 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
JsonDeserializers 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
EnumMaps.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.
JsonGenerators
it creates.
JsonGenerators
it creates.
JsonGenerators
it creates.
JsonGenerators
it creates.
JsonGenerator.writeObject(java.lang.Object)).
ObjectCodec associated with this
parser, if any.
ObjectMapper to use
JsonToken.FIELD_NAMEs 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 JsonParsers
and/or JsonGenerators.
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.
JsonSerializers, JsonDeserializers, various type
handlers) of specific types.TokenBuffer
(as field entries, name and value).
DeserializationProblemHandlers
of an unrecognized property.
DeserializationProblemHandlers
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.Lists 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 JsonDeserializers 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.JsonParsers 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 JsonSerializers 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
TypeSerializers
and TypeDeserializers
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).Methods and Constructors)
in Maps.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 JsonParsers and/or
JsonGenerators.
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
JsonParserTypeResolverBuilder
and
TypeIdResolver.Modules
(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,
Lists and Maps).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.PropertyValues.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().
JsonMappingExceptionObjectReader 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
JsonSerializers 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
JsonGenerators
it creates.
JsonGenerators
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 SmileParserSmileParser 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.Maps to JSON
Objects.SerializerProvider implementation.StdSerializerProvider.createInstance(org.codehaus.jackson.map.SerializationConfig, org.codehaus.jackson.map.SerializerFactory) (or by
sub-classes)
Doubles
(and primitive doubles)Integers
(and primitive ints)StdSerializers.IntegerSerializer, but will not cast to Integer:
instead, cast is to Number, and conversion is
by calling Number.intValue().Numbers (custom types).JsonSerializable.JsonSerializableWithType.StdSerializers.UtilDateSerializer, we do use String
representation here.Strings.TokenBuffer;
and since it is part of core package, it can not implement
JsonSerializable (which is only included in the mapper
package)TypeResolverBuilder implementation.Collections 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).
Versions.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
JsonParseExceptions
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.Features
are enabled.
JsonParser.Features
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.Features
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.
JsonGenerators
JsonGenerators
JsonParser.clearCurrentToken() was called.
ObjectMapper
DataFormatMatcher._match
BeanDeserializer instances
are configured and constructed.
BeanSerializer instances
are configured and constructed.
TypeModifiers: 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.
chars 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.Features
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 | |||||||||