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 |
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) |
Boolean |
AnnotationIntrospector.findCachability(AnnotatedClass ac)
Method that checks whether specified class has annotations
that indicate that it is (or is not) cachable.
|
Boolean |
AnnotationIntrospector.Pair.findCachability(AnnotatedClass ac) |
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.
|
Object |
AnnotationIntrospector.Pair.findFilterId(AnnotatedClass ac) |
abstract Boolean |
AnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac)
Method for checking whether an annotation indicates that all unknown properties
|
Boolean |
AnnotationIntrospector.Pair.findIgnoreUnknownProperties(AnnotatedClass ac) |
abstract String[] |
AnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac)
Method for finding list of properties to ignore for given class
(null is returned if not specified).
|
String[] |
AnnotationIntrospector.Pair.findPropertiesToIgnore(AnnotatedClass ac) |
abstract 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.
|
String |
AnnotationIntrospector.Pair.findRootName(AnnotatedClass ac) |
abstract String[] |
AnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac)
Method for accessing defined property serialization order (which may be
partial).
|
String[] |
AnnotationIntrospector.Pair.findSerializationPropertyOrder(AnnotatedClass ac) |
abstract 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
|
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
|
String |
AnnotationIntrospector.findTypeName(AnnotatedClass ac)
Method for checking if specified type has explicit name.
|
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) |
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. |
Object |
AnnotationIntrospector.Pair.findValueInstantiator(AnnotatedClass ac) |
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.
|
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,
Map<String,SettableBeanProperty> backRefs,
HashSet<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,
Map<String,SettableBeanProperty> backRefs,
HashSet<String> ignorableProps,
boolean ignoreAllUnknown,
SettableAnyProperty anySetter,
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 |
---|---|
AnnotatedClass |
BasicClassIntrospector.classWithCreators(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r) |
static AnnotatedClass |
AnnotatedClass.construct(Class<?> cls,
AnnotationIntrospector aintr,
ClassIntrospector.MixInResolver mir)
Factory method that instantiates an instance.
|
static AnnotatedClass |
AnnotatedClass.constructWithoutSuperTypes(Class<?> cls,
AnnotationIntrospector aintr,
ClassIntrospector.MixInResolver mir)
Method similar to
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. |
AnnotatedClass |
POJOPropertiesCollector.getClassDef() |
AnnotatedClass |
BasicBeanDescription.getClassInfo() |
AnnotatedClass |
AnnotatedClass.withAnnotations(AnnotationMap ann) |
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) |
Boolean |
JacksonAnnotationIntrospector.findCachability(AnnotatedClass ac) |
Object |
JacksonAnnotationIntrospector.findFilterId(AnnotatedClass ac) |
Boolean |
NopAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac) |
Boolean |
JacksonAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac) |
String[] |
NopAnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac) |
String[] |
JacksonAnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac) |
String |
NopAnnotationIntrospector.findRootName(AnnotatedClass ac) |
String |
JacksonAnnotationIntrospector.findRootName(AnnotatedClass ac) |
String[] |
NopAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac) |
String[] |
JacksonAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac) |
Boolean |
NopAnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac) |
Boolean |
JacksonAnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac) |
String |
JacksonAnnotationIntrospector.findTypeName(AnnotatedClass ac) |
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
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.
|
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,
List<BeanPropertyDefinition> properties) |
POJOPropertiesCollector(MapperConfig<?> config,
boolean forSerialization,
JavaType type,
AnnotatedClass classDef) |
Modifier and Type | Method and Description |
---|---|
abstract 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,
HashMap<NamedType,NamedType> collectedSubtypes)
Method called to find subtypes for a specific type (class)
|
Collection<NamedType> |
StdSubtypeResolver.collectAndResolveSubtypes(AnnotatedClass type,
MapperConfig<?> config,
AnnotationIntrospector ai) |
Modifier and Type | Method and Description |
---|---|
VisibilityChecker<?> |
JaxbAnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac,
VisibilityChecker<?> checker) |
Boolean |
JaxbAnnotationIntrospector.findCachability(AnnotatedClass ac) |
Boolean |
JaxbAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac) |
String[] |
JaxbAnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac) |
String |
JaxbAnnotationIntrospector.findRootName(AnnotatedClass ac) |
String[] |
JaxbAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac) |
Boolean |
JaxbAnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac) |
String |
JaxbAnnotationIntrospector.findTypeName(AnnotatedClass ac) |
TypeResolverBuilder<?> |
JaxbAnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
Boolean |
JaxbAnnotationIntrospector.isIgnorableType(AnnotatedClass ac) |