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	Description
JsonDeserializer<java.lang.Object>	DeserializationConfig.deserializerInstance(Annotated annotated, java.lang.Class<? extends JsonDeserializer<?>> deserClass)
abstract JsonDeserializer<?>	HandlerInstantiator.deserializerInstance(DeserializationConfig config, Annotated annotated, java.lang.Class<? extends JsonDeserializer<?>> deserClass)	Method called to get an instance of deserializer of specified type.
abstract java.lang.Class<? extends JsonDeserializer<?>>	AnnotationIntrospector.findContentDeserializer(Annotated am)	Method for getting a deserializer definition for content (values) of associated Collection, array or Map property.
java.lang.Class<? extends JsonDeserializer<?>>	AnnotationIntrospector.Pair.findContentDeserializer(Annotated am)
java.lang.Class<? extends JsonSerializer<?>>	AnnotationIntrospector.findContentSerializer(Annotated am)	Method for getting a serializer definition for content (values) of associated Collection, array or Map property.
java.lang.Class<? extends JsonSerializer<?>>	AnnotationIntrospector.Pair.findContentSerializer(Annotated a)
abstract java.lang.Class<?>	AnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType baseContentType, java.lang.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.
java.lang.Class<?>	AnnotationIntrospector.Pair.findDeserializationContentType(Annotated am, JavaType baseContentType, java.lang.String propName)
abstract java.lang.Class<?>	AnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType baseKeyType, java.lang.String propName)	Method for accessing additional narrowing type definition that a method can have, to define more specific key type to use.
java.lang.Class<?>	AnnotationIntrospector.Pair.findDeserializationKeyType(Annotated am, JavaType baseKeyType, java.lang.String propName)
abstract java.lang.Class<?>	AnnotationIntrospector.findDeserializationType(Annotated am, JavaType baseType, java.lang.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.
java.lang.Class<?>	AnnotationIntrospector.Pair.findDeserializationType(Annotated am, JavaType baseType, java.lang.String propName)
abstract java.lang.Object	AnnotationIntrospector.findDeserializer(Annotated am)	Method for getting a deserializer definition on specified method or field.
java.lang.Object	AnnotationIntrospector.Pair.findDeserializer(Annotated am)
abstract java.lang.Class<? extends KeyDeserializer>	AnnotationIntrospector.findKeyDeserializer(Annotated am)	Method for getting a deserializer definition for keys of associated Map property.
java.lang.Class<? extends KeyDeserializer>	AnnotationIntrospector.Pair.findKeyDeserializer(Annotated am)
java.lang.Class<? extends JsonSerializer<?>>	AnnotationIntrospector.findKeySerializer(Annotated am)	Method for getting a serializer definition for keys of associated Map property.
java.lang.Class<? extends JsonSerializer<?>>	AnnotationIntrospector.Pair.findKeySerializer(Annotated a)
java.lang.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.
java.lang.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)
java.lang.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.
java.lang.Class<?>	AnnotationIntrospector.Pair.findSerializationKeyType(Annotated am, JavaType baseType)
abstract java.lang.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.
java.lang.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 java.lang.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.
java.lang.Class<?>[]	AnnotationIntrospector.Pair.findSerializationViews(Annotated a)
abstract java.lang.Object	AnnotationIntrospector.findSerializer(Annotated am)	Method for getting a serializer definition on specified method or field.
java.lang.Object	AnnotationIntrospector.Pair.findSerializer(Annotated am)
java.util.List<NamedType>	AnnotationIntrospector.findSubtypes(Annotated a)	Method for locating annotation-specified subtypes related to annotated entity (class, method, field).
java.util.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, java.lang.Class<? extends KeyDeserializer> keyDeserClass)
abstract KeyDeserializer	HandlerInstantiator.keyDeserializerInstance(DeserializationConfig config, Annotated annotated, java.lang.Class<? extends KeyDeserializer> keyDeserClass)	Method called to get an instance of key deserializer of specified type.
abstract JsonSerializer<?>	HandlerInstantiator.serializerInstance(SerializationConfig config, Annotated annotated, java.lang.Class<? extends JsonSerializer<?>> serClass)	Method called to get an instance of serializer of specified type.
JsonSerializer<java.lang.Object>	SerializationConfig.serializerInstance(Annotated annotated, java.lang.Class<? extends JsonSerializer<?>> serClass)
abstract TypeIdResolver	HandlerInstantiator.typeIdResolverInstance(MapperConfig<?> config, Annotated annotated, java.lang.Class<? extends TypeIdResolver> resolverClass)	Method called to get an instance of TypeIdResolver of specified type.
TypeIdResolver	MapperConfig.typeIdResolverInstance(Annotated annotated, java.lang.Class<? extends TypeIdResolver> resolverClass)	Method that can be called to obtain an instance of TypeIdResolver of specified type.
abstract TypeResolverBuilder<?>	HandlerInstantiator.typeResolverBuilderInstance(MapperConfig<?> config, Annotated annotated, java.lang.Class<? extends TypeResolverBuilder<?>> builderClass)	Method called to get an instance of TypeResolverBuilder of specified type.
TypeResolverBuilder<?>	MapperConfig.typeResolverBuilderInstance(Annotated annotated, java.lang.Class<? extends TypeResolverBuilder<?>> builderClass)	Method that can be called to obtain an instance of TypeIdResolver of specified type.
ValueInstantiator	DeserializationConfig.valueInstantiatorInstance(Annotated annotated, java.lang.Class<? extends ValueInstantiator> instClass)
ValueInstantiator	HandlerInstantiator.valueInstantiatorInstance(MapperConfig<?> config, Annotated annotated, java.lang.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	Description
protected JsonDeserializer<java.lang.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, java.lang.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	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	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	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)
java.lang.Class<? extends JsonDeserializer<?>>	JacksonAnnotationIntrospector.findContentDeserializer(Annotated a)
java.lang.Class<JsonDeserializer<?>>	NopAnnotationIntrospector.findContentDeserializer(Annotated am)
java.lang.Class<? extends JsonSerializer<?>>	JacksonAnnotationIntrospector.findContentSerializer(Annotated a)
java.lang.Class<?>	JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType baseContentType, java.lang.String propName)
java.lang.Class<?>	NopAnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType t, java.lang.String propName)
java.lang.Class<?>	JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType baseKeyType, java.lang.String propName)
java.lang.Class<?>	NopAnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType t, java.lang.String propName)
java.lang.Class<?>	JacksonAnnotationIntrospector.findDeserializationType(Annotated am, JavaType baseType, java.lang.String propName)
java.lang.Class<?>	NopAnnotationIntrospector.findDeserializationType(Annotated am, JavaType t, java.lang.String propName)
java.lang.Class<? extends JsonDeserializer<?>>	JacksonAnnotationIntrospector.findDeserializer(Annotated a)
java.lang.Object	NopAnnotationIntrospector.findDeserializer(Annotated am)
java.lang.Class<? extends KeyDeserializer>	JacksonAnnotationIntrospector.findKeyDeserializer(Annotated a)
java.lang.Class<KeyDeserializer>	NopAnnotationIntrospector.findKeyDeserializer(Annotated am)
java.lang.Class<? extends JsonSerializer<?>>	JacksonAnnotationIntrospector.findKeySerializer(Annotated a)
java.lang.Class<?>	JacksonAnnotationIntrospector.findSerializationContentType(Annotated am, JavaType baseType)
JsonSerialize.Inclusion	JacksonAnnotationIntrospector.findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)
java.lang.Class<?>	JacksonAnnotationIntrospector.findSerializationKeyType(Annotated am, JavaType baseType)
java.lang.Class<?>	JacksonAnnotationIntrospector.findSerializationType(Annotated am)
java.lang.Class<?>	NopAnnotationIntrospector.findSerializationType(Annotated a)
JsonSerialize.Typing	JacksonAnnotationIntrospector.findSerializationTyping(Annotated a)
JsonSerialize.Typing	NopAnnotationIntrospector.findSerializationTyping(Annotated a)
java.lang.Class<?>[]	JacksonAnnotationIntrospector.findSerializationViews(Annotated a)
java.lang.Class<?>[]	NopAnnotationIntrospector.findSerializationViews(Annotated a)
java.lang.Object	JacksonAnnotationIntrospector.findSerializer(Annotated a)
java.lang.Object	NopAnnotationIntrospector.findSerializer(Annotated am)
java.util.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	Description
protected static JsonSerializer<java.lang.Object>	BasicSerializerFactory.findContentSerializer(SerializationConfig config, Annotated a, BeanProperty property)
protected static JsonSerializer<java.lang.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<java.lang.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	Description
protected java.lang.Class<?>	JaxbAnnotationIntrospector._doFindDeserializationType(Annotated a, JavaType baseType, java.lang.String propName)
protected javax.xml.bind.annotation.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 java.lang.annotation.Annotation> A	JaxbAnnotationIntrospector.findAnnotation(java.lang.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)
java.lang.Class<JsonDeserializer<?>>	JaxbAnnotationIntrospector.findContentDeserializer(Annotated am)
java.lang.Class<?>	JaxbAnnotationIntrospector.findDeserializationContentType(Annotated a, JavaType baseContentType, java.lang.String propName)
java.lang.Class<?>	JaxbAnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType baseKeyType, java.lang.String propName)
java.lang.Class<?>	JaxbAnnotationIntrospector.findDeserializationType(Annotated a, JavaType baseType, java.lang.String propName)	JAXB does allow specifying (more) concrete class for deserialization by using \@XmlElement annotation.
JsonDeserializer<?>	JaxbAnnotationIntrospector.findDeserializer(Annotated am)
java.lang.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.
java.lang.Class<?>	JaxbAnnotationIntrospector.findSerializationType(Annotated a)
JsonSerialize.Typing	JaxbAnnotationIntrospector.findSerializationTyping(Annotated a)
java.lang.Class<?>[]	JaxbAnnotationIntrospector.findSerializationViews(Annotated a)
JsonSerializer<?>	JaxbAnnotationIntrospector.findSerializer(Annotated am)
java.util.List<NamedType>	JaxbAnnotationIntrospector.findSubtypes(Annotated a)
boolean	JaxbAnnotationIntrospector.hasCreatorAnnotation(Annotated am)