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

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

- Packages that use Annotated
  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.ser | Contains implementation classes of serialization part of data binding.
  org.codehaus.jackson.xc | Package that contains XML Compatibility functionality for Jackson, such as handlers for JAXB annotations

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

    Methods in org.codehaus.jackson.map with parameters of type Annotated
    Modifier and Type | Method and Description
    --- | ---
    `JsonDeserializer<Object>` | DeserializationConfig.`deserializerInstance(Annotated annotated, Class<? extends JsonDeserializer<?>> deserClass)`
    `abstract JsonDeserializer<?>` | HandlerInstantiator.`deserializerInstance(DeserializationConfig config, Annotated annotated, Class<? extends JsonDeserializer<?>> deserClass)` Method called to get an instance of deserializer of specified type.
    `abstract Class<? extends JsonDeserializer<?>>` | AnnotationIntrospector.`findContentDeserializer(Annotated am)` Method for getting a deserializer definition for content (values) of associated `Collection`, `array` or `Map` property.
    `Class<? extends JsonDeserializer<?>>` | AnnotationIntrospector.Pair.`findContentDeserializer(Annotated am)`
    `Class<? extends JsonSerializer<?>>` | AnnotationIntrospector.`findContentSerializer(Annotated am)` Method for getting a serializer definition for content (values) of associated `Collection`, `array` or `Map` property.
    `Class<? extends JsonSerializer<?>>` | AnnotationIntrospector.Pair.`findContentSerializer(Annotated a)`
    `abstract Class<?>` | AnnotationIntrospector.`findDeserializationContentType(Annotated am, JavaType baseContentType, String propName)` Method for accessing additional narrowing type definition that a method can have, to define more specific content type to use; content refers to Map values and Collection/array elements.
    `Class<?>` | AnnotationIntrospector.Pair.`findDeserializationContentType(Annotated am, JavaType baseContentType, String propName)`
    `abstract Class<?>` | AnnotationIntrospector.`findDeserializationKeyType(Annotated am, JavaType baseKeyType, String propName)` Method for accessing additional narrowing type definition that a method can have, to define more specific key type to use.
    `Class<?>` | AnnotationIntrospector.Pair.`findDeserializationKeyType(Annotated am, JavaType baseKeyType, String propName)`
    `abstract Class<?>` | AnnotationIntrospector.`findDeserializationType(Annotated am, JavaType baseType, String propName)` Method for accessing annotated type definition that a method can have, to be used as the type for serialization instead of the runtime type.
    `Class<?>` | AnnotationIntrospector.Pair.`findDeserializationType(Annotated am, JavaType baseType, String propName)`
    `abstract Object` | AnnotationIntrospector.`findDeserializer(Annotated am)` Method for getting a deserializer definition on specified method or field.
    `Object` | AnnotationIntrospector.Pair.`findDeserializer(Annotated am)`
    `abstract Class<? extends KeyDeserializer>` | AnnotationIntrospector.`findKeyDeserializer(Annotated am)` Method for getting a deserializer definition for keys of associated `Map` property.
    `Class<? extends KeyDeserializer>` | AnnotationIntrospector.Pair.`findKeyDeserializer(Annotated am)`
    `Class<? extends JsonSerializer<?>>` | AnnotationIntrospector.`findKeySerializer(Annotated am)` Method for getting a serializer definition for keys of associated `Map` property.
    `Class<? extends JsonSerializer<?>>` | AnnotationIntrospector.Pair.`findKeySerializer(Annotated a)`
    `Class<?>` | AnnotationIntrospector.`findSerializationContentType(Annotated am, JavaType baseType)` Method for finding possible widening type definition that a property value can have, to define less specific key type to use for serialization.
    `Class<?>` | AnnotationIntrospector.Pair.`findSerializationContentType(Annotated am, JavaType baseType)`
    `JsonSerialize.Inclusion` | AnnotationIntrospector.`findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)` Method for checking whether given annotated entity (class, method, field) defines which Bean/Map properties are to be included in serialization.
    `JsonSerialize.Inclusion` | AnnotationIntrospector.Pair.`findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)`
    `Class<?>` | AnnotationIntrospector.`findSerializationKeyType(Annotated am, JavaType baseType)` Method for finding possible widening type definition that a property value can have, to define less specific key type to use for serialization.
    `Class<?>` | AnnotationIntrospector.Pair.`findSerializationKeyType(Annotated am, JavaType baseType)`
    `abstract Class<?>` | AnnotationIntrospector.`findSerializationType(Annotated a)` Method for accessing annotated type definition that a method/field can have, to be used as the type for serialization instead of the runtime type.
    `Class<?>` | AnnotationIntrospector.Pair.`findSerializationType(Annotated a)`
    `abstract JsonSerialize.Typing` | AnnotationIntrospector.`findSerializationTyping(Annotated a)` Method for accessing declared typing mode annotated (if any).
    `JsonSerialize.Typing` | AnnotationIntrospector.Pair.`findSerializationTyping(Annotated a)`
    `abstract Class<?>[]` | AnnotationIntrospector.`findSerializationViews(Annotated a)` Method for checking if annotated serializable property (represented by field or getter method) has definitions for views it is to be included in.
    `Class<?>[]` | AnnotationIntrospector.Pair.`findSerializationViews(Annotated a)`
    `abstract Object` | AnnotationIntrospector.`findSerializer(Annotated am)` Method for getting a serializer definition on specified method or field.
    `Object` | AnnotationIntrospector.Pair.`findSerializer(Annotated am)`
    `List<NamedType>` | AnnotationIntrospector.`findSubtypes(Annotated a)` Method for locating annotation-specified subtypes related to annotated entity (class, method, field).
    `List<NamedType>` | AnnotationIntrospector.Pair.`findSubtypes(Annotated a)`
    `boolean` | AnnotationIntrospector.`hasCreatorAnnotation(Annotated a)` Method for checking whether given annotated item (method, constructor) has an annotation that suggests that the method is a "creator" (aka factory) method to be used for construct new instances of deserialized values.
    `boolean` | AnnotationIntrospector.Pair.`hasCreatorAnnotation(Annotated a)`
    `KeyDeserializer` | DeserializationConfig.`keyDeserializerInstance(Annotated annotated, Class<? extends KeyDeserializer> keyDeserClass)`
    `abstract KeyDeserializer` | HandlerInstantiator.`keyDeserializerInstance(DeserializationConfig config, Annotated annotated, Class<? extends KeyDeserializer> keyDeserClass)` Method called to get an instance of key deserializer of specified type.
    `JsonSerializer<Object>` | SerializationConfig.`serializerInstance(Annotated annotated, Class<? extends JsonSerializer<?>> serClass)`
    `abstract JsonSerializer<?>` | HandlerInstantiator.`serializerInstance(SerializationConfig config, Annotated annotated, Class<? extends JsonSerializer<?>> serClass)` Method called to get an instance of serializer of specified type.
    `TypeIdResolver` | MapperConfig.`typeIdResolverInstance(Annotated annotated, Class<? extends TypeIdResolver> resolverClass)` Method that can be called to obtain an instance of `TypeIdResolver` of specified type.
    `abstract TypeIdResolver` | HandlerInstantiator.`typeIdResolverInstance(MapperConfig<?> config, Annotated annotated, Class<? extends TypeIdResolver> resolverClass)` Method called to get an instance of TypeIdResolver of specified type.
    `TypeResolverBuilder<?>` | MapperConfig.`typeResolverBuilderInstance(Annotated annotated, Class<? extends TypeResolverBuilder<?>> builderClass)` Method that can be called to obtain an instance of `TypeIdResolver` of specified type.
    `abstract TypeResolverBuilder<?>` | HandlerInstantiator.`typeResolverBuilderInstance(MapperConfig<?> config, Annotated annotated, Class<? extends TypeResolverBuilder<?>> builderClass)` Method called to get an instance of TypeResolverBuilder of specified type.
    `ValueInstantiator` | DeserializationConfig.`valueInstantiatorInstance(Annotated annotated, Class<? extends ValueInstantiator> instClass)`
    `ValueInstantiator` | HandlerInstantiator.`valueInstantiatorInstance(MapperConfig<?> config, Annotated annotated, Class<? extends ValueInstantiator> resolverClass)` Method called to construct an instance of ValueInstantiator of specified type.

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

    Methods in org.codehaus.jackson.map.deser with parameters of type Annotated
    Modifier and Type | Method and Description
    --- | ---
    `protected JsonDeserializer<Object>` | BasicDeserializerFactory.`findDeserializerFromAnnotation(DeserializationConfig config, Annotated ann, BeanProperty property)` Helper method called to check if a class or method has annotation that tells which class to use for deserialization.
    `protected <T extends JavaType> T` | BasicDeserializerFactory.`modifyTypeByAnnotation(DeserializationConfig config, Annotated a, T type, String propName)` Method called to see if given method has annotations that indicate a more specific type than what the argument specifies.

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

    Subclasses of Annotated in org.codehaus.jackson.map.introspect
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AnnotatedClass`
    `class` | `AnnotatedConstructor`
    `class` | `AnnotatedField` Object that represents non-static (and usually non-transient/volatile) fields of a class.
    `class` | `AnnotatedMember` Intermediate base class for annotated entities that are members of a class; fields, methods and constructors.
    `class` | `AnnotatedMethod`
    `class` | `AnnotatedParameter` Object that represents method parameters, mostly so that associated annotations can be processed conveniently.
    `class` | `AnnotatedWithParams` Intermediate base class that encapsulates features that constructors and methods share.

    Methods in org.codehaus.jackson.map.introspect that return Annotated
    Modifier and Type | Method and Description
    --- | ---
    `abstract Annotated` | Annotated.`withAnnotations(AnnotationMap fallback)` Fluent factory method that will construct a new instance that uses specified instance annotations instead of currently configured ones.
    `Annotated` | Annotated.`withFallBackAnnotationsFrom(Annotated annotated)` Fluent factory method that will construct a new instance that uses annotations from specified `Annotated` as fallback annotations

    Methods in org.codehaus.jackson.map.introspect with parameters of type Annotated
    Modifier and Type | Method and Description
    --- | ---
    `protected TypeResolverBuilder<?>` | JacksonAnnotationIntrospector.`_findTypeResolver(MapperConfig<?> config, Annotated ann, JavaType baseType)` Helper method called to construct and initialize instance of `TypeResolverBuilder` if given annotated element indicates one is needed.
    `protected boolean` | JacksonAnnotationIntrospector.`_isIgnorable(Annotated a)`
    `Class<JsonDeserializer<?>>` | NopAnnotationIntrospector.`findContentDeserializer(Annotated am)`
    `Class<? extends JsonDeserializer<?>>` | JacksonAnnotationIntrospector.`findContentDeserializer(Annotated a)`
    `Class<? extends JsonSerializer<?>>` | JacksonAnnotationIntrospector.`findContentSerializer(Annotated a)`
    `Class<?>` | NopAnnotationIntrospector.`findDeserializationContentType(Annotated am, JavaType t, String propName)`
    `Class<?>` | JacksonAnnotationIntrospector.`findDeserializationContentType(Annotated am, JavaType baseContentType, String propName)`
    `Class<?>` | NopAnnotationIntrospector.`findDeserializationKeyType(Annotated am, JavaType t, String propName)`
    `Class<?>` | JacksonAnnotationIntrospector.`findDeserializationKeyType(Annotated am, JavaType baseKeyType, String propName)`
    `Class<?>` | NopAnnotationIntrospector.`findDeserializationType(Annotated am, JavaType t, String propName)`
    `Class<?>` | JacksonAnnotationIntrospector.`findDeserializationType(Annotated am, JavaType baseType, String propName)`
    `Object` | NopAnnotationIntrospector.`findDeserializer(Annotated am)`
    `Class<? extends JsonDeserializer<?>>` | JacksonAnnotationIntrospector.`findDeserializer(Annotated a)`
    `Class<KeyDeserializer>` | NopAnnotationIntrospector.`findKeyDeserializer(Annotated am)`
    `Class<? extends KeyDeserializer>` | JacksonAnnotationIntrospector.`findKeyDeserializer(Annotated a)`
    `Class<? extends JsonSerializer<?>>` | JacksonAnnotationIntrospector.`findKeySerializer(Annotated a)`
    `Class<?>` | JacksonAnnotationIntrospector.`findSerializationContentType(Annotated am, JavaType baseType)`
    `JsonSerialize.Inclusion` | JacksonAnnotationIntrospector.`findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)`
    `Class<?>` | JacksonAnnotationIntrospector.`findSerializationKeyType(Annotated am, JavaType baseType)`
    `Class<?>` | NopAnnotationIntrospector.`findSerializationType(Annotated a)`
    `Class<?>` | JacksonAnnotationIntrospector.`findSerializationType(Annotated am)`
    `JsonSerialize.Typing` | NopAnnotationIntrospector.`findSerializationTyping(Annotated a)`
    `JsonSerialize.Typing` | JacksonAnnotationIntrospector.`findSerializationTyping(Annotated a)`
    `Class<?>[]` | NopAnnotationIntrospector.`findSerializationViews(Annotated a)`
    `Class<?>[]` | JacksonAnnotationIntrospector.`findSerializationViews(Annotated a)`
    `Object` | NopAnnotationIntrospector.`findSerializer(Annotated am)`
    `Object` | JacksonAnnotationIntrospector.`findSerializer(Annotated a)`
    `List<NamedType>` | JacksonAnnotationIntrospector.`findSubtypes(Annotated a)`
    `boolean` | JacksonAnnotationIntrospector.`hasCreatorAnnotation(Annotated a)`
    `Annotated` | Annotated.`withFallBackAnnotationsFrom(Annotated annotated)` Fluent factory method that will construct a new instance that uses annotations from specified `Annotated` as fallback annotations

  - ### Uses of Annotated in org.codehaus.jackson.map.ser

    Methods in org.codehaus.jackson.map.ser with parameters of type Annotated
    Modifier and Type | Method and Description
    --- | ---
    `protected static JsonSerializer<Object>` | BasicSerializerFactory.`findContentSerializer(SerializationConfig config, Annotated a, BeanProperty property)`
    `protected static JsonSerializer<Object>` | BasicSerializerFactory.`findKeySerializer(SerializationConfig config, Annotated a, BeanProperty property)`
    `protected JavaType` | PropertyBuilder.`findSerializationType(Annotated a, boolean useStaticTyping, JavaType declaredType)` Method that will try to determine statically defined type of property being serialized, based on annotations (for overrides), and alternatively declared type (if static typing for serialization is enabled).
    `protected JsonSerializer<Object>` | BasicSerializerFactory.`findSerializerFromAnnotation(SerializationConfig config, Annotated a, BeanProperty property)` Helper method called to check if a class or method has an annotation (@link org.codehaus.jackson.map.ser.JsonSerialize#using) that tells the class to use for serialization.
    `protected static <T extends JavaType> T` | BasicSerializerFactory.`modifySecondaryTypesByAnnotation(SerializationConfig config, Annotated a, T type)`
    `protected <T extends JavaType> T` | BasicSerializerFactory.`modifyTypeByAnnotation(SerializationConfig config, Annotated a, T type)` Helper method used to encapsulate details of annotation-based type coercion

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

    Methods in org.codehaus.jackson.xc with parameters of type Annotated
    Modifier and Type | Method and Description
    --- | ---
    `protected Class<?>` | JaxbAnnotationIntrospector.`_doFindDeserializationType(Annotated a, JavaType baseType, String propName)`
    `protected XmlAccessType` | JaxbAnnotationIntrospector.`findAccessType(Annotated ac)` Method for locating JAXB `XmlAccessType` annotation value for given annotated entity, if it has one, or inherits one from its ancestors (in JAXB sense, package etc).
    `protected <A extends Annotation> A` | JaxbAnnotationIntrospector.`findAnnotation(Class<A> annotationClass, Annotated annotated, boolean includePackage, boolean includeClass, boolean includeSuperclasses)` Finds an annotation associated with given annotatable thing; or if not found, a default annotation it may have (from super class, package and so on)
    `Class<JsonDeserializer<?>>` | JaxbAnnotationIntrospector.`findContentDeserializer(Annotated am)`
    `Class<?>` | JaxbAnnotationIntrospector.`findDeserializationContentType(Annotated a, JavaType baseContentType, String propName)`
    `Class<?>` | JaxbAnnotationIntrospector.`findDeserializationKeyType(Annotated am, JavaType baseKeyType, String propName)`
    `Class<?>` | JaxbAnnotationIntrospector.`findDeserializationType(Annotated a, JavaType baseType, String propName)` JAXB does allow specifying (more) concrete class for deserialization by using \@XmlElement annotation.
    `JsonDeserializer<?>` | JaxbAnnotationIntrospector.`findDeserializer(Annotated am)`
    `Class<KeyDeserializer>` | JaxbAnnotationIntrospector.`findKeyDeserializer(Annotated am)`
    `JsonSerialize.Inclusion` | JaxbAnnotationIntrospector.`findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)` Implementation of this method is slightly tricky, given that JAXB defaults differ from Jackson defaults.
    `Class<?>` | JaxbAnnotationIntrospector.`findSerializationType(Annotated a)`
    `JsonSerialize.Typing` | JaxbAnnotationIntrospector.`findSerializationTyping(Annotated a)`
    `Class<?>[]` | JaxbAnnotationIntrospector.`findSerializationViews(Annotated a)`
    `JsonSerializer<?>` | JaxbAnnotationIntrospector.`findSerializer(Annotated am)`
    `List<NamedType>` | JaxbAnnotationIntrospector.`findSubtypes(Annotated a)`
    `boolean` | JaxbAnnotationIntrospector.`hasCreatorAnnotation(Annotated am)`