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

Packages that use Annotated
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. 
 

Uses of Annotated in org.codehaus.jackson.map
 

Methods in org.codehaus.jackson.map with parameters of type Annotated
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)
           
abstract  Class<?> AnnotationIntrospector.findDeserializationContentType(Annotated am)
          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)
           
abstract  Class<?> AnnotationIntrospector.findDeserializationKeyType(Annotated am)
          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)
           
abstract  Class<?> AnnotationIntrospector.findDeserializationType(Annotated am)
          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)
           
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)
           
abstract  String AnnotationIntrospector.findNamespace(Annotated ann)
          Method that can be called to figure out generic namespace property for an annotated object.
 String AnnotationIntrospector.Pair.findNamespace(Annotated ann)
          Combination logic is such that if the primary returns non-null non-empty namespace, that is returned.
abstract  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)
           
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  Object AnnotationIntrospector.findSerializer(Annotated am)
          Method for getting a serializer definition on specified method or field.
 Object AnnotationIntrospector.Pair.findSerializer(Annotated am)
           
abstract  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)
           
 

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

Methods in org.codehaus.jackson.map.deser with parameters of type Annotated
protected  JsonDeserializer<Object> BasicDeserializerFactory.findDeserializerFromAnnotation(DeserializationConfig config, Annotated a)
          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)
          Method called to see if given method has annotations that indicate a more specific type than what the argument specifies.
protected  JavaType BasicDeserializerFactory.resolveType(DeserializationConfig config, BasicBeanDescription beanDesc, Type rawType, Annotated a)
          Helper method used to resolve method return types and field types.
 

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

Subclasses of Annotated in org.codehaus.jackson.map.introspect
 class AnnotatedClass
           
 class AnnotatedConstructor
           
 class AnnotatedField
           
 class AnnotatedMethod
           
 class AnnotatedParameter
          Object that represents method parameters, mostly so that associated annotations can be processed conveniently.
 

Methods in org.codehaus.jackson.map.introspect with parameters of type Annotated
protected  boolean JacksonAnnotationIntrospector._isIgnorable(Annotated a)
           
 Class<JsonDeserializer<?>> NopAnnotationIntrospector.findContentDeserializer(Annotated am)
           
 Class<? extends JsonDeserializer<?>> JacksonAnnotationIntrospector.findContentDeserializer(Annotated a)
           
 Class<?> NopAnnotationIntrospector.findDeserializationContentType(Annotated am)
           
 Class<?> JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am)
           
 Class<?> NopAnnotationIntrospector.findDeserializationKeyType(Annotated am)
           
 Class<?> JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am)
           
 Class<?> NopAnnotationIntrospector.findDeserializationType(Annotated am)
           
 Class<?> JacksonAnnotationIntrospector.findDeserializationType(Annotated am)
           
 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)
           
 String NopAnnotationIntrospector.findNamespace(Annotated ann)
           
 String JacksonAnnotationIntrospector.findNamespace(Annotated ann)
           
 JsonSerialize.Inclusion NopAnnotationIntrospector.findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)
           
 JsonSerialize.Inclusion JacksonAnnotationIntrospector.findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)
           
 Class<?> NopAnnotationIntrospector.findSerializationType(Annotated a)
           
 Class<?> JacksonAnnotationIntrospector.findSerializationType(Annotated am)
           
 JsonSerialize.Typing NopAnnotationIntrospector.findSerializationTyping(Annotated a)
           
 JsonSerialize.Typing JacksonAnnotationIntrospector.findSerializationTyping(Annotated a)
           
 Object NopAnnotationIntrospector.findSerializer(Annotated am)
           
 Class<? extends JsonSerializer<?>> JacksonAnnotationIntrospector.findSerializer(Annotated a)
           
 boolean NopAnnotationIntrospector.hasCreatorAnnotation(Annotated a)
           
 boolean JacksonAnnotationIntrospector.hasCreatorAnnotation(Annotated a)
           
protected  String BasicBeanDescription.mangleGetterName(Annotated a, String basename)
           
protected  String BasicBeanDescription.mangleSetterName(Annotated a, String basename)
           
 

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

Methods in org.codehaus.jackson.map.ser with parameters of type Annotated
protected  BeanPropertyWriter PropertyBuilder._buildProperty(String name, JsonSerializer<Object> ser, boolean defaultUseStaticTyping, Annotated a, Method m, Field f)
           
protected  Class<?> PropertyBuilder.findSerializationType(Annotated a, boolean useStaticTyping)
           
protected  JsonSerializer<Object> BasicSerializerFactory.findSerializerFromAnnotation(SerializationConfig config, Annotated a)
          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.
 

Uses of Annotated in org.codehaus.jackson.xc
 

Methods in org.codehaus.jackson.xc with parameters of type Annotated
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  XmlAdapter<Object,Object> JaxbAnnotationIntrospector.findAdapter(Annotated am)
          Finds the XmlAdapter for the specified annotation.
protected
<A extends Annotation>
A
JaxbAnnotationIntrospector.findAnnotation(Class<A> annotationClass, Annotated annotated, boolean includePackage, boolean includeClass, boolean includeSuperclasses)
          Finds an annotation.
 Class<JsonDeserializer<?>> JaxbAnnotationIntrospector.findContentDeserializer(Annotated am)
           
 Class<?> JaxbAnnotationIntrospector.findDeserializationContentType(Annotated am)
           
 Class<?> JaxbAnnotationIntrospector.findDeserializationKeyType(Annotated am)
           
 Class<?> JaxbAnnotationIntrospector.findDeserializationType(Annotated am)
           
 JsonDeserializer<?> JaxbAnnotationIntrospector.findDeserializer(Annotated am)
           
 Class<KeyDeserializer> JaxbAnnotationIntrospector.findKeyDeserializer(Annotated am)
           
 String JaxbAnnotationIntrospector.findNamespace(Annotated ann)
           
 JsonSerialize.Inclusion JaxbAnnotationIntrospector.findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)
          By default only non-null properties are written (per the JAXB spec.)
 Class<?> JaxbAnnotationIntrospector.findSerializationType(Annotated a)
           
 JsonSerialize.Typing JaxbAnnotationIntrospector.findSerializationTyping(Annotated a)
           
 JsonSerializer<?> JaxbAnnotationIntrospector.findSerializer(Annotated am)
           
 boolean JaxbAnnotationIntrospector.hasCreatorAnnotation(Annotated am)
           
protected  boolean JaxbAnnotationIntrospector.isFieldsAccessible(Annotated ac)
          Whether fields are accessible to this class.
protected  boolean JaxbAnnotationIntrospector.isPropertiesAccessible(Annotated ac)
          Whether properties are accessible to this class.