## Uses of Class
com.fasterxml.jackson.databind.introspect.AnnotatedClass

Packages that use AnnotatedClass
com.fasterxml.jackson.databind: 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`
com.fasterxml.jackson.databind.introspect: Functionality needed for Bean introspection, required for detecting accessors and mutators for Beans, as well as locating and handling method annotations.
com.fasterxml.jackson.databind.jsontype: Package that contains interfaces that define how to implement functionality for dynamically resolving type during deserialization.
com.fasterxml.jackson.databind.jsontype.impl: Package that contains standard implementations for `TypeResolverBuilder` and `TypeIdResolver`.
com.fasterxml.jackson.databind.ser: Contains implementation classes of serialization part of data binding.

Uses of AnnotatedClass in com.fasterxml.jackson.databind

Methods in com.fasterxml.jackson.databind that return AnnotatedClass
`abstract AnnotatedClass` `BeanDescription.getClassInfo()` Method for accessing low-level information about Class this item describes.

Methods in com.fasterxml.jackson.databind 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).
`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.
`Boolean` `AnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac)` Method for checking whether an annotation indicates that all unknown properties
`Object` `AnnotationIntrospector.findNamingStrategy(AnnotatedClass ac)` Method for finding `PropertyNamingStrategy` for given class, if any specified by annotations; and if so, either return a `PropertyNamingStrategy` instance, or Class to use for creating instance
`Class<?>` `AnnotationIntrospector.findPOJOBuilder(AnnotatedClass ac)` Method for finding Builder object to use for constructing value instance and binding data (sort of combining value instantiators that can construct, and deserializers that can bind data).
`JsonPOJOBuilder.Value` `AnnotationIntrospector.findPOJOBuilderConfig(AnnotatedClass ac)`
`PropertyName` `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.findSerializationPropertyOrder(AnnotatedClass ac)` Method for accessing defined property serialization order (which may be partial).
`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
`String` `AnnotationIntrospector.findTypeName(AnnotatedClass ac)` Method for checking if specified type has explicit name.
`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.
`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.
`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.

Uses of AnnotatedClass in com.fasterxml.jackson.databind.introspect

Fields in com.fasterxml.jackson.databind.introspect declared as AnnotatedClass
`protected AnnotatedClass` `POJOPropertiesCollector._classDef` Low-level introspected class information (methods, fields etc)
`protected AnnotatedClass` `BasicBeanDescription._classInfo` Information collected about the class introspected.

Methods in com.fasterxml.jackson.databind.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<?>, com.fasterxml.jackson.databind.AnnotationIntrospector, com.fasterxml.jackson.databind.introspect.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)`

Methods in com.fasterxml.jackson.databind.introspect with parameters of type AnnotatedClass
`protected POJOPropertiesCollector` `BasicClassIntrospector.constructPropertyCollector(MapperConfig<?> config, AnnotatedClass ac, JavaType type, boolean forSerialization, String mutatorPrefix)` 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)`
`VisibilityChecker<?>` `AnnotationIntrospectorPair.findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)`
`Object` `JacksonAnnotationIntrospector.findFilterId(AnnotatedClass ac)`
`Object` `AnnotationIntrospectorPair.findFilterId(AnnotatedClass ac)`
`Boolean` `JacksonAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac)`
`Boolean` `AnnotationIntrospectorPair.findIgnoreUnknownProperties(AnnotatedClass ac)`
`Object` `JacksonAnnotationIntrospector.findNamingStrategy(AnnotatedClass ac)`
`Object` `AnnotationIntrospectorPair.findNamingStrategy(AnnotatedClass ac)`
`Class<?>` `JacksonAnnotationIntrospector.findPOJOBuilder(AnnotatedClass ac)`
`Class<?>` `AnnotationIntrospectorPair.findPOJOBuilder(AnnotatedClass ac)`
`JsonPOJOBuilder.Value` `JacksonAnnotationIntrospector.findPOJOBuilderConfig(AnnotatedClass ac)`
`JsonPOJOBuilder.Value` `AnnotationIntrospectorPair.findPOJOBuilderConfig(AnnotatedClass ac)`
`PropertyName` `JacksonAnnotationIntrospector.findRootName(AnnotatedClass ac)`
`PropertyName` `AnnotationIntrospectorPair.findRootName(AnnotatedClass ac)`
`String[]` `JacksonAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac)`
`String[]` `AnnotationIntrospectorPair.findSerializationPropertyOrder(AnnotatedClass ac)`
`Boolean` `JacksonAnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac)`
`Boolean` `AnnotationIntrospectorPair.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` `JacksonAnnotationIntrospector.findTypeName(AnnotatedClass ac)`
`String` `AnnotationIntrospectorPair.findTypeName(AnnotatedClass ac)`
`TypeResolverBuilder<?>` `JacksonAnnotationIntrospector.findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)`
`TypeResolverBuilder<?>` `AnnotationIntrospectorPair.findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)`
`Object` `JacksonAnnotationIntrospector.findValueInstantiator(AnnotatedClass ac)`
`Object` `AnnotationIntrospectorPair.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)`
`Boolean` `AnnotationIntrospectorPair.isIgnorableType(AnnotatedClass ac)`

Constructors in com.fasterxml.jackson.databind.introspect with parameters of type AnnotatedClass
`BasicBeanDescription(MapperConfig<?> config, JavaType type, AnnotatedClass classDef, List<BeanPropertyDefinition> props)`
`POJOPropertiesCollector(MapperConfig<?> config, boolean forSerialization, JavaType type, AnnotatedClass classDef, String mutatorPrefix)`

Uses of AnnotatedClass in com.fasterxml.jackson.databind.jsontype

Methods in com.fasterxml.jackson.databind.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 com.fasterxml.jackson.databind.jsontype.impl

Methods in com.fasterxml.jackson.databind.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 com.fasterxml.jackson.databind.ser

Methods in com.fasterxml.jackson.databind.ser that return AnnotatedClass
`AnnotatedClass` `BeanSerializerBuilder.getClassInfo()`

Copyright © 2012 FasterXML. All Rights Reserved.