Uses of Class org.codehaus.jackson.map.introspect.AnnotatedClass (Jackson JSON Processor)
Date: 2013-07-14

## Uses of Class
org.codehaus.jackson.map.introspect.AnnotatedClass

- Packages that use AnnotatedClass
  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

- - ### Uses of AnnotatedClass in org.codehaus.jackson.map

    Methods in org.codehaus.jackson.map that return AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `abstract AnnotatedClass` | BeanDescription.`getClassInfo()`

    Methods in org.codehaus.jackson.map with parameters of type AnnotatedClass
    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)`

  - ### Uses of AnnotatedClass in org.codehaus.jackson.map.deser

    Fields in org.codehaus.jackson.map.deser declared as AnnotatedClass
    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)`).

    Constructors in org.codehaus.jackson.map.deser with parameters of type AnnotatedClass
    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)`

  - ### Uses of AnnotatedClass in org.codehaus.jackson.map.introspect

    Fields in org.codehaus.jackson.map.introspect declared as AnnotatedClass
    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.

    Methods in org.codehaus.jackson.map.introspect that return AnnotatedClass
    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)`

    Methods in org.codehaus.jackson.map.introspect with parameters of type AnnotatedClass
    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)`

    Constructors in org.codehaus.jackson.map.introspect with parameters of type AnnotatedClass
    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)`

  - ### Uses of AnnotatedClass in org.codehaus.jackson.map.jsontype

    Methods in org.codehaus.jackson.map.jsontype with parameters of type AnnotatedClass
    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.

  - ### Uses of AnnotatedClass in org.codehaus.jackson.map.jsontype.impl

    Methods in org.codehaus.jackson.map.jsontype.impl with parameters of type AnnotatedClass
    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)`

  - ### Uses of AnnotatedClass in org.codehaus.jackson.xc

    Methods in org.codehaus.jackson.xc with parameters of type AnnotatedClass
    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)`