Uses of Class
com.fasterxml.jackson.databind.introspect.Annotated

Packages that use Annotated
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.cfg Package that contains most of configuration-related classes; exception being couple of most-commonly used configuration things (like Feature enumerations) that are at the main level (com.fasterxml.jackson.databind). 
com.fasterxml.jackson.databind.deser Contains implementation classes of deserialization part of data binding. 
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.ser Contains implementation classes of serialization part of data binding. 
 

Uses of Annotated in com.fasterxml.jackson.databind
 

Methods in com.fasterxml.jackson.databind with parameters of type Annotated
abstract  JsonDeserializer<Object> DeserializationContext.deserializerInstance(Annotated annotated, Object deserDef)
           
 Object AnnotationIntrospector.findContentDeserializer(Annotated am)
          Method for getting a deserializer definition for content (values) of associated Collection, array or Map property.
 Object AnnotationIntrospector.findContentSerializer(Annotated am)
          Method for getting a serializer definition for content (values) of associated Collection, array or Map property.
 Class<?> AnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType baseContentType)
          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.findDeserializationKeyType(Annotated am, JavaType baseKeyType)
          Method for accessing additional narrowing type definition that a method can have, to define more specific key type to use.
 Class<?> AnnotationIntrospector.findDeserializationType(Annotated am, JavaType baseType)
          Method for accessing annotated type definition that a method can have, to be used as the type for serialization instead of the runtime type.
 Object AnnotationIntrospector.findDeserializer(Annotated am)
          Method for getting a deserializer definition on specified method or field.
 JsonFormat.Value AnnotationIntrospector.findFormat(Annotated memberOrClass)
          Method for finding format annotations for property or class.
 Object AnnotationIntrospector.findKeyDeserializer(Annotated am)
          Method for getting a deserializer definition for keys of associated Map property.
 Object AnnotationIntrospector.findKeySerializer(Annotated am)
          Method for getting a serializer definition for keys of associated Map property.
 PropertyName AnnotationIntrospector.findNameForDeserialization(Annotated a)
          Method for checking whether given property accessors (method, field) has an annotation that suggests property name to use for deserialization (reading JSON into POJOs).
 PropertyName AnnotationIntrospector.findNameForSerialization(Annotated a)
          Method for checking whether given property accessors (method, field) has an annotation that suggests property name to use for serialization.
 ObjectIdInfo AnnotationIntrospector.findObjectIdInfo(Annotated ann)
          Method for checking whether given annotated thing (type, or accessor) indicates that values referenced (values of type of annotated class, or values referenced by annotated property; latter having precedence) should include Object Identifier, and if so, specify details of Object Identity used.
 ObjectIdInfo AnnotationIntrospector.findObjectReferenceInfo(Annotated ann, ObjectIdInfo objectIdInfo)
          Method for figuring out additional properties of an Object Identity reference
 String[] AnnotationIntrospector.findPropertiesToIgnore(Annotated ac)
          Method for finding list of properties to ignore for given class (null is returned if not specified).
 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.
 JsonInclude.Include AnnotationIntrospector.findSerializationInclusion(Annotated a, JsonInclude.Include defValue)
          Method for checking whether given annotated entity (class, method, field) defines which Bean/Map properties are to be included in serialization.
 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.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.
 JsonSerialize.Typing AnnotationIntrospector.findSerializationTyping(Annotated a)
          Method for accessing declared typing mode annotated (if any).
 Object AnnotationIntrospector.findSerializer(Annotated am)
          Method for getting a serializer definition on specified method or field.
 List<NamedType> AnnotationIntrospector.findSubtypes(Annotated a)
          Method for locating annotation-specified subtypes related to annotated entity (class, method, field).
 Class<?>[] AnnotationIntrospector.findViews(Annotated a)
          Method for checking if annotated property (represented by a field or getter/setter method) has definitions for views it is to be included in.
 PropertyName AnnotationIntrospector.findWrapperName(Annotated ann)
          Method used to check if specified property has annotation that indicates that it should be wrapped in an element; and if so, name to use.
 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.
abstract  KeyDeserializer DeserializationContext.keyDeserializerInstance(Annotated annotated, Object deserDef)
           
abstract  ObjectIdGenerator<?> SerializerProvider.objectIdGeneratorInstance(Annotated annotated, ObjectIdInfo objectIdInfo)
           
abstract  ObjectIdGenerator<?> DeserializationContext.objectIdGeneratorInstance(Annotated annotated, ObjectIdInfo objectIdInfo)
           
abstract  JsonSerializer<Object> SerializerProvider.serializerInstance(Annotated annotated, Object serDef)
          Method that can be called to construct and configure serializer instance, either given a Class to instantiate (with default constructor), or an uninitialized serializer instance.
 

Uses of Annotated in com.fasterxml.jackson.databind.cfg
 

Methods in com.fasterxml.jackson.databind.cfg with parameters of type Annotated
abstract  JsonDeserializer<?> HandlerInstantiator.deserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> deserClass)
          Method called to get an instance of deserializer of specified type.
abstract  KeyDeserializer HandlerInstantiator.keyDeserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> keyDeserClass)
          Method called to get an instance of key deserializer of specified type.
 PropertyNamingStrategy HandlerInstantiator.namingStrategyInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)
          Method called to construct a NamingStrategy instance used for specified class.
 ObjectIdGenerator<?> HandlerInstantiator.objectIdGeneratorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)
          Method called to construct a ObjectIdHandler instance of specified type.
abstract  JsonSerializer<?> HandlerInstantiator.serializerInstance(SerializationConfig config, Annotated annotated, Class<?> 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<?> 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<?> builderClass)
          Method called to get an instance of TypeResolverBuilder of specified type.
 ValueInstantiator HandlerInstantiator.valueInstantiatorInstance(MapperConfig<?> config, Annotated annotated, Class<?> resolverClass)
          Method called to construct an instance of ValueInstantiator of specified type.
 

Uses of Annotated in com.fasterxml.jackson.databind.deser
 

Methods in com.fasterxml.jackson.databind.deser with parameters of type Annotated
 ValueInstantiator BasicDeserializerFactory._valueInstantiatorInstance(DeserializationConfig config, Annotated annotated, Object instDef)
           
 JsonDeserializer<Object> DefaultDeserializationContext.deserializerInstance(Annotated annotated, Object deserDef)
           
protected  JsonDeserializer<Object> DeserializerCache.findDeserializerFromAnnotation(DeserializationContext ctxt, Annotated ann)
          Helper method called to check if a class or method has annotation that tells which class to use for deserialization.
protected  JsonDeserializer<Object> BasicDeserializerFactory.findDeserializerFromAnnotation(DeserializationContext ctxt, Annotated ann)
          Helper method called to check if a class or method has annotation that tells which class to use for deserialization.
 KeyDeserializer DefaultDeserializationContext.keyDeserializerInstance(Annotated annotated, Object deserDef)
           
protected
<T extends JavaType>
T
BasicDeserializerFactory.modifyTypeByAnnotation(DeserializationContext ctxt, Annotated a, T type)
          Method called to see if given method has annotations that indicate a more specific type than what the argument specifies.
 ObjectIdGenerator<?> DefaultDeserializationContext.objectIdGeneratorInstance(Annotated annotated, ObjectIdInfo objectIdInfo)
           
 

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

Subclasses of Annotated in com.fasterxml.jackson.databind.introspect
 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 com.fasterxml.jackson.databind.introspect that return Annotated
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 com.fasterxml.jackson.databind.introspect with parameters of type Annotated
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<? extends JsonDeserializer<?>> JacksonAnnotationIntrospector.findContentDeserializer(Annotated a)
           
 Object AnnotationIntrospectorPair.findContentDeserializer(Annotated am)
           
 Class<? extends JsonSerializer<?>> JacksonAnnotationIntrospector.findContentSerializer(Annotated a)
           
 Object AnnotationIntrospectorPair.findContentSerializer(Annotated a)
           
 Class<?> JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType baseContentType)
           
 Class<?> AnnotationIntrospectorPair.findDeserializationContentType(Annotated am, JavaType baseContentType)
           
 Class<?> JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType baseKeyType)
           
 Class<?> AnnotationIntrospectorPair.findDeserializationKeyType(Annotated am, JavaType baseKeyType)
           
 Class<?> JacksonAnnotationIntrospector.findDeserializationType(Annotated am, JavaType baseType)
           
 Class<?> AnnotationIntrospectorPair.findDeserializationType(Annotated am, JavaType baseType)
           
 Class<? extends JsonDeserializer<?>> JacksonAnnotationIntrospector.findDeserializer(Annotated a)
           
 Object AnnotationIntrospectorPair.findDeserializer(Annotated am)
           
 JsonFormat.Value JacksonAnnotationIntrospector.findFormat(Annotated annotated)
           
 JsonFormat.Value AnnotationIntrospectorPair.findFormat(Annotated ann)
           
 Class<? extends KeyDeserializer> JacksonAnnotationIntrospector.findKeyDeserializer(Annotated a)
           
 Object AnnotationIntrospectorPair.findKeyDeserializer(Annotated am)
           
 Class<? extends JsonSerializer<?>> JacksonAnnotationIntrospector.findKeySerializer(Annotated a)
           
 Object AnnotationIntrospectorPair.findKeySerializer(Annotated a)
           
 PropertyName JacksonAnnotationIntrospector.findNameForDeserialization(Annotated a)
           
 PropertyName AnnotationIntrospectorPair.findNameForDeserialization(Annotated a)
           
 PropertyName JacksonAnnotationIntrospector.findNameForSerialization(Annotated a)
           
 PropertyName AnnotationIntrospectorPair.findNameForSerialization(Annotated a)
           
 ObjectIdInfo JacksonAnnotationIntrospector.findObjectIdInfo(Annotated ann)
           
 ObjectIdInfo AnnotationIntrospectorPair.findObjectIdInfo(Annotated ann)
           
 ObjectIdInfo JacksonAnnotationIntrospector.findObjectReferenceInfo(Annotated ann, ObjectIdInfo objectIdInfo)
           
 ObjectIdInfo AnnotationIntrospectorPair.findObjectReferenceInfo(Annotated ann, ObjectIdInfo objectIdInfo)
           
 String[] JacksonAnnotationIntrospector.findPropertiesToIgnore(Annotated ac)
           
 String[] AnnotationIntrospectorPair.findPropertiesToIgnore(Annotated ac)
           
 Class<?> JacksonAnnotationIntrospector.findSerializationContentType(Annotated am, JavaType baseType)
           
 Class<?> AnnotationIntrospectorPair.findSerializationContentType(Annotated am, JavaType baseType)
           
 JsonInclude.Include JacksonAnnotationIntrospector.findSerializationInclusion(Annotated a, JsonInclude.Include defValue)
           
 JsonInclude.Include AnnotationIntrospectorPair.findSerializationInclusion(Annotated a, JsonInclude.Include defValue)
           
 Class<?> JacksonAnnotationIntrospector.findSerializationKeyType(Annotated am, JavaType baseType)
           
 Class<?> AnnotationIntrospectorPair.findSerializationKeyType(Annotated am, JavaType baseType)
           
 Class<?> JacksonAnnotationIntrospector.findSerializationType(Annotated am)
           
 Class<?> AnnotationIntrospectorPair.findSerializationType(Annotated a)
           
 JsonSerialize.Typing JacksonAnnotationIntrospector.findSerializationTyping(Annotated a)
           
 JsonSerialize.Typing AnnotationIntrospectorPair.findSerializationTyping(Annotated a)
           
 Object JacksonAnnotationIntrospector.findSerializer(Annotated a)
           
 Object AnnotationIntrospectorPair.findSerializer(Annotated am)
           
 List<NamedType> JacksonAnnotationIntrospector.findSubtypes(Annotated a)
           
 List<NamedType> AnnotationIntrospectorPair.findSubtypes(Annotated a)
           
 Class<?>[] JacksonAnnotationIntrospector.findViews(Annotated a)
           
 Class<?>[] AnnotationIntrospectorPair.findViews(Annotated a)
           
 PropertyName AnnotationIntrospectorPair.findWrapperName(Annotated ann)
           
 boolean JacksonAnnotationIntrospector.hasCreatorAnnotation(Annotated a)
           
 boolean AnnotationIntrospectorPair.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 com.fasterxml.jackson.databind.ser
 

Methods in com.fasterxml.jackson.databind.ser with parameters of type Annotated
protected  JsonSerializer<Object> BasicSerializerFactory._findContentSerializer(SerializerProvider prov, Annotated a)
          Helper method called to try to find whether there is an annotation in the class that indicates content ("value") serializer to use.
protected  JsonSerializer<Object> BasicSerializerFactory._findKeySerializer(SerializerProvider prov, Annotated a)
          Helper method called to try to find whether there is an annotation in the class that indicates key serializer to use.
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(SerializerProvider prov, Annotated a)
          Helper method called to check if a class or method has an annotation (@link com.fasterxml.jackson.databind.annotation.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
 ObjectIdGenerator<?> DefaultSerializerProvider.objectIdGeneratorInstance(Annotated annotated, ObjectIdInfo objectIdInfo)
           
 JsonSerializer<Object> DefaultSerializerProvider.serializerInstance(Annotated annotated, Object serDef)
           
 



Copyright © 2012 FasterXML. All Rights Reserved.