|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
classWithMixIns contains into class
destinationClass.
AnnotationMap).AnnotatedMethods, accessible by lookup.Object[]).JavaType that
represent array that contains elements
of specified type.
JavaType that
represent array that contains elements
of specified type.
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.Object.getClass() does not count);
as well as for "standard" JDK types.Map types.
Object[] (and subtypes).
ByteArrayOutputStream
in usage, but more geared to Jackson use cases internally.Names, constructed directly from a byte-based
input source.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.JavaType that
represent Collection of specified type and contains elements
of specified type
JavaType that
represent Collection of specified type and contains elements
of specified type
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.
SettableAnyProperty
for handling unknown bean properties, given a method that
has been designated as such setter.
BeanDeserializer.
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.
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.
JsonFactory
instance.
SerializerFactory.createSerializer(JavaType,SerializationConfig) instead
Date values.PrettyPrinter implementation that uses 2-space
indentation with platform-default linefeeds.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.JsonParser.Feature for list of features)
JsonGenerator.Feature for list of features)
JsonGenerator.Feature for list of features)
JsonParser.Feature for list of features)
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)
JsonGenerator.enable(org.codehaus.jackson.JsonGenerator.Feature) instead
JsonParser.enable(Feature) instead
JsonFactory.enable(JsonGenerator.Feature) instead
JsonFactory.enable(JsonParser.Feature) instead
EnumMaps.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.XmlAccessType annotation value
for given annotated entity, if it has one, or inherits one from
its ancestors (in JAXB sense, package etc).
JsonAnySetter.
BeanSerializer for
given class.
Collection, array or
Map property.
EnumSet, without having
access to its declaration.
EnumSet, without having
access to its declaration.
JsonValue annotation,
if any.
Map property.
Map.
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.
JavaType out of its canonical
representation (see JavaType.toCanonical()).
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.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.
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.
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
JsonNode.path(String) instead
JsonNode.path(int) instead
JsonValue annotation
to represent serialization to use; same as if explicitly
serializing returned object.
SerializationConfig object
that defines configuration settings for serialization.
SerializationConfig.getSerializationView().
JsonToken.VALUE_NUMBER_INT and
it can be expressed as a value of Java short primitive type.
JsonParserBase.nextToken(), or
after encountering end-of-input), returns null.
JsonParser.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.
SerializerFactory
instances are able to construct a serializer.
JsonNode.isValueNode() returns true), otherwise null.
TokenBuffer
(as field entries, name and value).
DeserializationProblemHandlers
of an unrecognized property.
DeserializationProblemHandlers
of an unrecognized property.
NumberInput.inLongRange(char[],int,int,boolean), but
with String argument
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.
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
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 or
suchDateTime.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.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.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 instead (deprecated since version 1.5)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.JsonStreamContext, which implements
core methods needed, and also exposes
more complete API to generator implementation classes.ObjectMapper to use for serialization
and deserialization.
Map instance, with typed contents.ObjectMapper instance to be used for data binding, as
well as accessing it.JsonFactory that will create a proper
ObjectCodec to allow seamless conversions between
Json content and Java objects (POJOs).JavaType that
represent Map of specified type and contains elements
of specified type
JavaType that
represent Map of specified type and contains elements
of specified type
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).
InputStream.AnnotationIntrospector.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
resolver builders based on its configuration.ObjectMapper.enableDefaultTyping()
to specify what kind of types (classes) default typing should
be used for.ObjectMapper for initial instantiation
JsonFactory
used for constructing
Json parser (JsonParser)
and generator
(JsonParser)
instances.ObjectMapper class, as well
as convenience methods included in
JsonParserTypeResolverBuilder
and
org.codehaus.jackson.map.jsontype.JsonTypeResolver it
can construct.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.JavaType that
represents a parameterized type.
JavaType that
represents a parameterized type.
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).BeanSerializerFactory that is used to
construct BeanPropertyWriter instances.PropertyValues.BasicDeserializerFactory
to register deserializers this class provides.
BasicSerializerFactory to access
all serializers this class provides.
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.
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().
JsonMappingExceptionStringWriter, based on using segmented
internal buffer.BeanPropertyWriter instances.
JsonGenerator.
SerializerProvider
to obtain actual
JsonSerializer instances from multiple distinct factories.ObjectMapper and
JsonSerializers to obtain serializers capable of serializing
instances of specific types.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.
JsonGenerator.writeObject(java.lang.Object)).
ObjectCodec associated with this
parser, if any.
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
ObjectMapper to use
for serialization and deserialization; if null, will use the standard
provider discovery from context instead.
JsonNodeFactory to use for
constructing root level tree nodes (via method
ObjectMapper.createObjectNode()
JsonFactory.configure(JsonParser.Feature, boolean) instead
SerializerFactory to use
for constructing (bean) serializers.
SerializerProvider to use
for handling caching of JsonSerializer instances.
JsonToken.START_OBJECT or JsonToken.START_ARRAY.
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.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.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.TypeFactory from mapper package).
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 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).JavaType from given
"raw" type; which may be anything from simple Class
to full generic type.
TypeReference.
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.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.DefaultPrettyPrinter).
JsonParser, which is
based on a InputStream as the input source.ObjectWriter that will
serialize objects using specified JSON View (filter).
TypeSerializer for decorating
contained values with additiona type information.
IOException, or an unchecked exception.
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
or ObjectMapper
instead.
TypeSerializer.writeTypePrefixForObject(java.lang.Object, org.codehaus.jackson.JsonGenerator).
TypeSerializer.writeTypePrefixForScalar(java.lang.Object, org.codehaus.jackson.JsonGenerator).
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
MinimalClassNameIdResolver._basePackageName, but includes trailing dot.
JsonParserBase.getBinaryValue(org.codehaus.jackson.Base64Variant) will not need to decode data more
than once.
JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS).
JsonParseExceptions
based on current state of the parser
BeanPropertyWriter for
given member (field or method).
JsonParser.nextToken(), if any.
SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS being set to false).
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.
JsonTypeInfo)
If set to null, no type information will be added unless annotations
are used; if set to non-null, resolver builder is used to check
which type serializers and deserializers are to be used (if any)
JsonGenerator.Features
are enabled.
JsonParser.Features
are enabled.
TypeParser when generics-aware version
is constructed.
getGenericXxx methods
(usually for a return or argument type).
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
JsonParser.clearCurrentToken() was called.
ObjectMapper
JsonParserBase.getTextCharacters() method (instead of String
returning alternatives)
JsonParserSequence._parsers.
FIELD_NAME but the
actual value token is also known.
JsonNodes
for tree model instances when binding JSON content
as JSON trees.
Map having null key.
WriterBasedGenerator._writer.
ObjectMapper to use for actual
serialization.
SimpleType._typeParameters
Object.class)
Object.class)
Object in some case)
JavaType._narrow(java.lang.Class), since
underlying type construction is usually identical
_writeFieldName, off-lined
to keep the "fast path" as simple (and hopefully fast) as possible.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||