## 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`.

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).
`VisibilityChecker<?>` `AnnotationIntrospector.Pair.findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)`
`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)`
`Boolean` `AnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac)` Method for checking whether an annotation indicates that all unknown properties
`Boolean` `AnnotationIntrospector.Pair.findIgnoreUnknownProperties(AnnotatedClass ac)`
`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).
`Class<?>` `AnnotationIntrospector.Pair.findPOJOBuilder(AnnotatedClass ac)`
`JsonPOJOBuilder.Value` `AnnotationIntrospector.findPOJOBuilderConfig(AnnotatedClass ac)`
`JsonPOJOBuilder.Value` `AnnotationIntrospector.Pair.findPOJOBuilderConfig(AnnotatedClass ac)`
`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)`
`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)`
`String[]` `AnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac)` Method for accessing defined property serialization order (which may be partial).
`String[]` `AnnotationIntrospector.Pair.findSerializationPropertyOrder(AnnotatedClass ac)`
`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)`

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)`
`Object` `JacksonAnnotationIntrospector.findFilterId(AnnotatedClass ac)`
`Boolean` `JacksonAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac)`
`Class<?>` `JacksonAnnotationIntrospector.findPOJOBuilder(AnnotatedClass ac)`
`JsonPOJOBuilder.Value` `JacksonAnnotationIntrospector.findPOJOBuilderConfig(AnnotatedClass ac)`
`String[]` `JacksonAnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac)`
`String` `JacksonAnnotationIntrospector.findRootName(AnnotatedClass ac)`
`String[]` `JacksonAnnotationIntrospector.findSerializationPropertyOrder(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)`

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)`

Copyright © 2012 fasterxml.com. All Rights Reserved.