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.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.util Utility classes for Mapper package. 
org.codehaus.jackson.xc Package that contains Xml Compatibility functionality for Jackson. 
 

Uses of AnnotatedClass in org.codehaus.jackson.map
 

Methods in org.codehaus.jackson.map with parameters of type AnnotatedClass
abstract  VisibilityChecker<?> AnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> baseChecker)
          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)
           
abstract  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)
           
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
abstract  String AnnotationIntrospector.findTypeName(AnnotatedClass ac)
          Method for checking if specified type has explicit name.
 String AnnotationIntrospector.Pair.findTypeName(AnnotatedClass ac)
           
abstract  TypeResolverBuilder<?> AnnotationIntrospector.findTypeResolver(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(AnnotatedClass ac, JavaType baseType)
           
 

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

Fields in org.codehaus.jackson.map.introspect declared as AnnotatedClass
protected  AnnotatedClass BasicBeanDescription._classInfo
          Information collected about the class introspected.
 

Methods in org.codehaus.jackson.map.introspect that return AnnotatedClass
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 BasicBeanDescription.getClassInfo()
           
 

Methods in org.codehaus.jackson.map.introspect with parameters of type AnnotatedClass
 VisibilityChecker<?> NopAnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)
           
 VisibilityChecker<?> JacksonAnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)
           
 Boolean NopAnnotationIntrospector.findCachability(AnnotatedClass ac)
           
 Boolean JacksonAnnotationIntrospector.findCachability(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 NopAnnotationIntrospector.findTypeName(AnnotatedClass ac)
           
 String JacksonAnnotationIntrospector.findTypeName(AnnotatedClass ac)
           
 TypeResolverBuilder<?> NopAnnotationIntrospector.findTypeResolver(AnnotatedClass ac, JavaType baseType)
           
 TypeResolverBuilder<?> JacksonAnnotationIntrospector.findTypeResolver(AnnotatedClass ac, JavaType baseType)
           
 

Constructors in org.codehaus.jackson.map.introspect with parameters of type AnnotatedClass
BasicBeanDescription(JavaType type, AnnotatedClass ac, AnnotationIntrospector ai)
           
 

Uses of AnnotatedClass in org.codehaus.jackson.map.util
 

Methods in org.codehaus.jackson.map.util with parameters of type AnnotatedClass
protected  List<NamedType> SubTypeHelper._collectAndResolve(AnnotatedClass rootType, MapperConfig<?> config, AnnotationIntrospector ai, Collection<NamedType> subtypeList)
           
 

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(AnnotatedClass ac, JavaType baseType)