|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
classWithMixIns contains into class
destinationClass.
classWithMixIns contains into class
destinationClass.
AnnotationMap).AnnotatedMethods, accessible by lookup.Object[]).JsonNode
implementations.Collection).Collection).BasicSerializerFactory.IntegerSerializer, but will not cast to Integer:
instead, cast is to Number, and conversion is
by calling Number.intValue().Numbers (custom types).BasicSerializerFactory.UtilDateSerializer, we do use String
representation here.ToStringSerializer instead (stand-along class,
more accurate name)Strings.ClassIntrospector to
help in constructing serializers and deserializers.Object.getClass() does not count);
as well as for "standard" JDK types.BeanPropertyWriter
that uses specified method as the accessors.
BeanPropertyWriter
that uses specified method as the accessors.
ByteArrayOutputStream
in usage, but more geared to Jackson use cases internally.Names, constructed directly from a byte-based
input source.JsonSerializers.JsonParser.hasCurrentToken() returns false, and
JsonParser.getCurrentToken() null).
Collection instance, with typed contents.Comparable) is to prevent constructing a
reference without type information.
ObjectBuffer.completeAndClearBuffer(Object[], int), to allow
for constructing explicitly typed result array.
SettableAnyProperty
for handling unknown bean properties, given a method that
has been designated as such setter.
BeanDeserializer.
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.
Date values.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, which is 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.JsonGenerator.Feature for list of features)
JsonParser.Feature for list of features)
JsonGenerator.Feature for list of features)
JsonParser.Feature for list of features)
JsonGenerator.Feature for list of available features.
JsonParser.Feature for list of features)
JsonGenerator.Feature for list of features)
JsonParser.Feature for list of features)
JsonGenerationException if its FailingSerializer.serialize(java.lang.Object, org.codehaus.jackson.JsonGenerator, org.codehaus.jackson.map.SerializerProvider)
gets invoeked.JsonAnySetter.
BeanSerializer for
given class.
JsonValue annotation,
if any.
Map.
AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject[], boolean) on
the underlying annotated element.
AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject[], boolean) on
the underlying annotated element.
AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject[], boolean) on
the underlying annotated element.
Class.
getGenericXxx methods
(usually for a return or argument type).
TypeReference.
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).
JsonParser.getBinaryValue(Base64Variant)
that defaults to using
Base64Variants.getDefaultVariant() as the default encoding.
JsonToken.VALUE_NUMBER_INT and
it can be expressed as a value of Java byte primitive type.
JsonGenerator.writeObject(java.lang.Object)).
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.
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.
JsonParser.clearCurrentToken().
JsonToken.VALUE_NUMBER_INT and
it can be expressed as a Java long primitive type.
JsonToken.VALUE_NULL).
JsonToken.VALUE_NUMBER_INT or
JsonToken.VALUE_NUMBER_FLOAT, returns
one of JsonParser.NumberType constants; otherwise returns null.
JsonNode.getPath(String) instead
JsonNode.getPath(int) instead
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.
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.
SerializerFactory
instances are able to construct a serializer.
JsonNode.isValueNode() returns true), otherwise null.
BasicSerializerFactory, this factory is stateless, and
thus a single shared global (== singleton) instance can be used
without thread-safety issues.
JsonParser.Feature
is enabled.
BasicBeanDescription.isCglibGetCallbacks(org.codehaus.jackson.map.introspect.AnnotatedMethod), need to suppress
a cyclic reference to resolve [JACKSON-103]
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 POJOs.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.JsonDeserialize.keyAs() insteadJsonAutoDetect apply to.JsonNode from any
Json content.JsonParser
implementations.JsonParser
implementations.JsonStreamContext, which implements
core methods needed, and also exposes
more complete API to parser implementation classes.JsonNode that represents a JSON-Schema instance.JsonGenerator
(and SerializerProvider if necessary).JsonSerialize.include() property
to define which properties
of Java Beans are to be included in serializationObjectMapper (and
other chained JsonSerializers too) to serialize Objects of
arbitrary types into JSON, using provided JsonGenerator.JsonDeserialize insteadJsonSerialize insteadXmlValue
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.JsonFactory that will create a proper
ObjectCodec to allow seamless conversions between
Json content and Java objects (POJOs).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.Methods
in Maps.Base64Variants.MIME which does not
use linefeeds (max line length set to infinite).
InputStream.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
used for constructing
Json parser (JsonParser)
and generator
(JsonParser)
instances.ObjectMapper class, as well
as convenience methods included in
JsonParserJavaType implementations.JsonNode implementations
Jackson uses for the Tree model.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.JsonParser, which is
based on a Reader to handle low-level character
conversion tasks.JsonSerializer instances
keyed by Class.JsonNode instances.
JsonNode instances.
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.
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.
JsonGenerator.writeObject(java.lang.Object)).
JsonGenerator.Feature for list of available features.
JsonParser.Feature for list of features)
ObjectMapper to use
for serialization and deserialization; if null, will use the standard
provider discovery from context instead.
JsonCachable instead
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.DeserializerProvider implementation.Maps to Json
Objects.SerializerProvider implementation.StdSerializerProvider.createInstance(org.codehaus.jackson.map.SerializationConfig, org.codehaus.jackson.map.SerializerFactory) (or by
sub-classes)
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.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.
JavaType instances,
given various inputs.DefaultPrettyPrinter).
JsonParser, which is
based on a InputStream as the input source.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.
JsonGenerator.
JsonGenerator,
configured as per passed configuration object.
JsonEncoding.UTF8).
JsonParserBase.getBinaryValue(org.codehaus.jackson.Base64Variant) will not need to decode data more
than once.
JsonParser.nextToken(), if any.
SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS being set to false).
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.
getGenericXxx methods
(usually for a return or argument type).
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.
JsonParser.clearCurrentToken() was called.
JsonParserBase.getTextCharacters() method (instead of String
returning alternatives)
FIELD_NAME but the
actual value token is also known.
Map having null key.
WriterBasedGenerator._writer.
ObjectMapper to use for actual
serialization.
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 | ||||||||||