|
|||||||||
| 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.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.
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.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.
JsonUseDeserializer annotation which tells the
class to use for deserialization.
JsonValue annotation, if any.
Map.
JsonUseSerializer annotation which tells the
class to use for serialization.
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.
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.
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
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]
JsonIgnore annotation.
JsonNode.getElements(); implemented so that
convenience "for-each" loop can be used for looping over elements
of Json Array constructs.
ObjectMapper (and
other chained JsonDeserializers too) to deserialize Objects of
arbitrary types from JSON, using provided JsonParser.JsonGenerator)
instances.javax.xml.bind.annotation.XmlTransient that indicates that
the annotated method is to be ignored by introspection-based
serialization and deserialization functionality.JsonAutoDetect 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.JsonGenerator
(and SerializerProvider if necessary).ObjectMapper (and
other chained JsonSerializers too) to serialize Objects of
arbitrary types into JSON, using provided JsonGenerator.JsonDeserializer used to deserialize
instances of the class annotated, or the value of property
that is modifier using (setter) method annotated.JsonSerializer used to serialize
instances of the class annotated, or the value of property
that is accessed using (getter) method annotated.javax.xml.bind.annotation.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.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
JsonParserJsonNode implementations
Jackson uses.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).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)
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.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.
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).
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.
_writeFieldName, off-lined
to keep the "fast path" as simple (and hopefully fast) as possible.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||