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

Packages that use AnnotatedClass
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
abstract  AnnotatedClass BeanDescription.getClassInfo()
           
 

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