|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use AnnotatedClass | |
---|---|
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 |
Uses of AnnotatedClass in org.codehaus.jackson.map |
---|
Methods in org.codehaus.jackson.map with parameters of type AnnotatedClass | |
---|---|
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)
|
abstract 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)
|
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)
|
Uses of AnnotatedClass in org.codehaus.jackson.map.deser |
---|
Fields in org.codehaus.jackson.map.deser declared as AnnotatedClass | |
---|---|
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) ). |
Constructors in org.codehaus.jackson.map.deser with parameters of type AnnotatedClass | |
---|---|
BeanDeserializer(AnnotatedClass forClass,
JavaType type,
BeanProperty property,
CreatorContainer creators,
BeanPropertyMap properties,
Map<String,SettableBeanProperty> backRefs,
HashSet<String> ignorableProps,
boolean ignoreAllUnknown,
SettableAnyProperty anySetter)
|
Uses of AnnotatedClass in org.codehaus.jackson.map.introspect |
---|
Fields in org.codehaus.jackson.map.introspect declared as AnnotatedClass | |
---|---|
protected AnnotatedClass |
BasicBeanDescription._classInfo
Information collected about the class introspected. |
Methods in org.codehaus.jackson.map.introspect that return AnnotatedClass | |
---|---|
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 |
BasicBeanDescription.getClassInfo()
|
Constructors in org.codehaus.jackson.map.introspect with parameters of type AnnotatedClass | |
---|---|
BasicBeanDescription(MapperConfig<?> config,
JavaType type,
AnnotatedClass ac)
|
Uses of AnnotatedClass in org.codehaus.jackson.map.jsontype |
---|
Methods in org.codehaus.jackson.map.jsontype with parameters of type AnnotatedClass | |
---|---|
abstract Collection<NamedType> |
SubtypeResolver.collectAndResolveSubtypes(AnnotatedClass basetype,
MapperConfig<?> config,
AnnotationIntrospector ai)
Method for finding out all reachable subtypes for given type. |
Uses of AnnotatedClass in org.codehaus.jackson.map.jsontype.impl |
---|
Methods in org.codehaus.jackson.map.jsontype.impl with parameters of type AnnotatedClass | |
---|---|
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)
|
Uses of AnnotatedClass in org.codehaus.jackson.xc |
---|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |