Package | Description |
---|---|
org.codehaus.jackson.map |
Contains basic mapper (conversion) functionality that
allows for converting between regular streaming json content and
Java objects (beans or Tree Model: support for both is via
ObjectMapper class, as well
as convenience methods included in
JsonParser
Object mapper will convert Json content to ant from
basic Java wrapper types (Integer, Boolean, Double),
Collection types (List, Map), Java Beans,
Strings and nulls. |
org.codehaus.jackson.map.deser |
Contains implementation classes of deserialization part of
data binding.
|
org.codehaus.jackson.map.introspect |
Functionality needed for Bean introspection, required for detecting
accessors and mutators for Beans, as well as locating and handling
method annotations.
|
org.codehaus.jackson.map.jsontype |
Package that contains interfaces that define how to implement
functionality for dynamically resolving type during deserialization.
|
org.codehaus.jackson.map.jsontype.impl |
Package that contains standard implementations for
TypeResolverBuilder
and
TypeIdResolver . |
org.codehaus.jackson.xc |
Package that contains XML Compatibility functionality for Jackson, such
as handlers for JAXB annotations
|
Modifier and Type | Method and Description |
---|---|
abstract AnnotatedClass |
BeanDescription.getClassInfo() |
Modifier and Type | Method and Description |
---|---|
VisibilityChecker<?> |
AnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac,
VisibilityChecker<?> checker)
Method for checking if annotations indicate changes to minimum visibility levels
needed for auto-detecting property elements (fields, methods, constructors).
|
VisibilityChecker<?> |
AnnotationIntrospector.Pair.findAutoDetectVisibility(AnnotatedClass ac,
VisibilityChecker<?> checker) |
java.lang.Boolean |
AnnotationIntrospector.findCachability(AnnotatedClass ac)
Method that checks whether specified class has annotations
that indicate that it is (or is not) cachable.
|
java.lang.Boolean |
AnnotationIntrospector.Pair.findCachability(AnnotatedClass ac) |
java.lang.Object |
AnnotationIntrospector.findFilterId(AnnotatedClass ac)
Method for finding if annotated class has associated filter; and if so,
to return id that is used to locate filter.
|
java.lang.Object |
AnnotationIntrospector.Pair.findFilterId(AnnotatedClass ac) |
abstract java.lang.Boolean |
AnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac)
Method for checking whether an annotation indicates that all unknown properties
|
java.lang.Boolean |
AnnotationIntrospector.Pair.findIgnoreUnknownProperties(AnnotatedClass ac) |
abstract java.lang.String[] |
AnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac)
Method for finding list of properties to ignore for given class
(null is returned if not specified).
|
java.lang.String[] |
AnnotationIntrospector.Pair.findPropertiesToIgnore(AnnotatedClass ac) |
abstract java.lang.String |
AnnotationIntrospector.findRootName(AnnotatedClass ac)
Method for locating name used as "root name" (for use by
some serializers when outputting root-level object -- mostly
for XML compatibility purposes) for given class, if one
is defined.
|
java.lang.String |
AnnotationIntrospector.Pair.findRootName(AnnotatedClass ac) |
abstract java.lang.String[] |
AnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac)
Method for accessing defined property serialization order (which may be
partial).
|
java.lang.String[] |
AnnotationIntrospector.Pair.findSerializationPropertyOrder(AnnotatedClass ac) |
abstract java.lang.Boolean |
AnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac)
Method for checking whether an annotation indicates that serialized properties
for which no explicit is defined should be alphabetically (lexicograpically)
ordered
|
java.lang.Boolean |
AnnotationIntrospector.Pair.findSerializationSortAlphabetically(AnnotatedClass ac)
Method for checking whether an annotation indicates that serialized properties
for which no explicit is defined should be alphabetically (lexicograpically)
ordered
|
java.lang.String |
AnnotationIntrospector.findTypeName(AnnotatedClass ac)
Method for checking if specified type has explicit name.
|
java.lang.String |
AnnotationIntrospector.Pair.findTypeName(AnnotatedClass ac) |
TypeResolverBuilder<?> |
AnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType)
Method for checking if given class has annotations that indicate
that specific type resolver is to be used for handling instances.
|
TypeResolverBuilder<?> |
AnnotationIntrospector.Pair.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
java.lang.Object |
AnnotationIntrospector.findValueInstantiator(AnnotatedClass ac)
Method getting
ValueInstantiator to use for given
type (class): return value can either be an instance of
instantiator, or class of instantiator to create. |
java.lang.Object |
AnnotationIntrospector.Pair.findValueInstantiator(AnnotatedClass ac) |
java.lang.Boolean |
AnnotationIntrospector.isIgnorableType(AnnotatedClass ac)
Method for checking whether properties that have specified type
(class, not generics aware) should be completely ignored for
serialization and deserialization purposes.
|
java.lang.Boolean |
AnnotationIntrospector.Pair.isIgnorableType(AnnotatedClass ac) |
Modifier and Type | Field and Description |
---|---|
protected AnnotatedClass |
BeanDeserializer._forClass
Class for which deserializer is built; used for accessing
annotations during resolution phase (see
BeanDeserializer.resolve(org.codehaus.jackson.map.DeserializationConfig, org.codehaus.jackson.map.DeserializerProvider) ). |
Constructor and Description |
---|
BeanDeserializer(AnnotatedClass forClass,
JavaType type,
BeanProperty property,
CreatorCollector creators,
BeanPropertyMap properties,
java.util.Map<java.lang.String,SettableBeanProperty> backRefs,
java.util.HashSet<java.lang.String> ignorableProps,
boolean ignoreAllUnknown,
SettableAnyProperty anySetter)
Deprecated.
(since 1.9) Use the constructor that takes
ValueInstantiator instead |
BeanDeserializer(AnnotatedClass forClass,
JavaType type,
BeanProperty property,
ValueInstantiator valueInstantiator,
BeanPropertyMap properties,
java.util.Map<java.lang.String,SettableBeanProperty> backRefs,
java.util.HashSet<java.lang.String> ignorableProps,
boolean ignoreAllUnknown,
SettableAnyProperty anySetter,
java.util.List<ValueInjector> injectables) |
Modifier and Type | Field and Description |
---|---|
protected AnnotatedClass |
POJOPropertiesCollector._classDef
Low-level introspected class information (methods, fields etc)
|
protected AnnotatedClass |
BasicBeanDescription._classInfo
Information collected about the class introspected.
|
Modifier and Type | Method and Description |
---|---|
protected POJOPropertiesCollector |
BasicClassIntrospector.constructPropertyCollector(MapperConfig<?> config,
AnnotatedClass ac,
JavaType type,
boolean forSerialization)
Overridable method called for creating
POJOPropertiesCollector instance
to use; override is needed if a custom sub-class is to be used. |
VisibilityChecker<?> |
JacksonAnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac,
VisibilityChecker<?> checker) |
java.lang.Boolean |
JacksonAnnotationIntrospector.findCachability(AnnotatedClass ac) |
java.lang.Object |
JacksonAnnotationIntrospector.findFilterId(AnnotatedClass ac) |
java.lang.Boolean |
JacksonAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac) |
java.lang.Boolean |
NopAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac) |
java.lang.String[] |
JacksonAnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac) |
java.lang.String[] |
NopAnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac) |
java.lang.String |
JacksonAnnotationIntrospector.findRootName(AnnotatedClass ac) |
java.lang.String |
NopAnnotationIntrospector.findRootName(AnnotatedClass ac) |
java.lang.String[] |
JacksonAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac) |
java.lang.String[] |
NopAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac) |
java.lang.Boolean |
JacksonAnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac) |
java.lang.Boolean |
NopAnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac) |
java.lang.String |
JacksonAnnotationIntrospector.findTypeName(AnnotatedClass ac) |
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
java.lang.Object |
JacksonAnnotationIntrospector.findValueInstantiator(AnnotatedClass ac) |
static BasicBeanDescription |
BasicBeanDescription.forOtherUse(MapperConfig<?> config,
JavaType type,
AnnotatedClass ac)
Factory method to use for constructing an instance to use for purposes
other than building serializers or deserializers; will only have information
on class, not on properties.
|
java.lang.Boolean |
JacksonAnnotationIntrospector.isIgnorableType(AnnotatedClass ac) |
Constructor and Description |
---|
BasicBeanDescription(MapperConfig<?> config,
JavaType type,
AnnotatedClass ac)
Deprecated.
Since 1.9, should use factory methods instead
|
BasicBeanDescription(MapperConfig<?> config,
JavaType type,
AnnotatedClass ac,
java.util.List<BeanPropertyDefinition> properties) |
POJOPropertiesCollector(MapperConfig<?> config,
boolean forSerialization,
JavaType type,
AnnotatedClass classDef) |
Modifier and Type | Method and Description |
---|---|
abstract java.util.Collection<NamedType> |
SubtypeResolver.collectAndResolveSubtypes(AnnotatedClass basetype,
MapperConfig<?> config,
AnnotationIntrospector ai)
Method for finding out all reachable subtypes for given type.
|
Modifier and Type | Method and Description |
---|---|
protected void |
StdSubtypeResolver._collectAndResolve(AnnotatedClass annotatedType,
NamedType namedType,
MapperConfig<?> config,
AnnotationIntrospector ai,
java.util.HashMap<NamedType,NamedType> collectedSubtypes)
Method called to find subtypes for a specific type (class)
|
java.util.Collection<NamedType> |
StdSubtypeResolver.collectAndResolveSubtypes(AnnotatedClass type,
MapperConfig<?> config,
AnnotationIntrospector ai) |
Modifier and Type | Method and Description |
---|---|
VisibilityChecker<?> |
JaxbAnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac,
VisibilityChecker<?> checker) |
java.lang.Boolean |
JaxbAnnotationIntrospector.findCachability(AnnotatedClass ac) |
java.lang.Boolean |
JaxbAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac) |
java.lang.String[] |
JaxbAnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac) |
java.lang.String |
JaxbAnnotationIntrospector.findRootName(AnnotatedClass ac) |
java.lang.String[] |
JaxbAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac) |
java.lang.Boolean |
JaxbAnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac) |
java.lang.String |
JaxbAnnotationIntrospector.findTypeName(AnnotatedClass ac) |
TypeResolverBuilder<?> |
JaxbAnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
java.lang.Boolean |
JaxbAnnotationIntrospector.isIgnorableType(AnnotatedClass ac) |