AnnotatedClass (jackson-databind 2.3.2)

java.lang.Object
- com.fasterxml.jackson.databind.introspect.Annotated
- - com.fasterxml.jackson.databind.introspect.AnnotatedClass

public final class AnnotatedClass
extends Annotated

Field Summary

Fields
Modifier and Type	Field and Description
`protected AnnotationIntrospector`	`_annotationIntrospector` Filter used to determine which annotations to gather; used to optimize things so that unnecessary annotations are ignored.
`protected Class<?>`	`_class` Class for which annotations apply, and that owns other components (constructors, methods)
`protected AnnotationMap`	`_classAnnotations` Combined list of Jackson annotations that the class has, including inheritable ones from super classes and interfaces
`protected List<AnnotatedConstructor>`	`_constructors` Single argument constructors the class has, if any.
`protected List<AnnotatedMethod>`	`_creatorMethods` Single argument static methods that might be usable as factory methods
`protected boolean`	`_creatorsResolved` Flag to indicate whether creator information has been resolved or not.
`protected AnnotatedConstructor`	`_defaultConstructor` Default constructor of the annotated class, if it has one.
`protected List<AnnotatedField>`	`_fields` Member fields of interest: ones that are either public, or have at least one annotation.
`protected AnnotatedMethodMap`	`_memberMethods` Member methods of interest; for now ones with 0 or 1 arguments (just optimization, since others won't be used now)
`protected ClassIntrospector.MixInResolver`	`_mixInResolver` Object that knows mapping of mix-in classes (ones that contain annotations to add) with their target classes (ones that get these additional annotations "mixed in").
`protected Class<?>`	`_primaryMixIn` Primary mix-in class; one to use for the annotated class itself.
`protected List<Class<?>>`	`_superTypes` Ordered set of super classes and interfaces of the class itself: included in order of precedence

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`_addClassMixIns(AnnotationMap annotations, Class<?> toMask)` Helper method for adding any mix-in annotations specified class might have.
`protected void`	`_addClassMixIns(AnnotationMap annotations, Class<?> toMask, Class<?> mixin)`
`protected void`	`_addConstructorMixIns(Class<?> mixin)`
`protected void`	`_addFactoryMixIns(Class<?> mixin)`
`protected void`	`_addFieldMixIns(Class<?> targetClass, Class<?> mixInCls, Map<String,AnnotatedField> fields)` Method called to add field mix-ins from given mix-in class (and its fields) into already collected actual fields (from introspected classes and their super-classes)
`protected void`	`_addMemberMethods(Class<?> cls, AnnotatedMethodMap methods, Class<?> mixInCls, AnnotatedMethodMap mixIns)`
`protected void`	`_addMethodMixIns(Class<?> targetClass, AnnotatedMethodMap methods, Class<?> mixInCls, AnnotatedMethodMap mixIns)`
`protected void`	`_addMixOvers(Constructor<?> mixin, AnnotatedConstructor target, boolean addParamAnnotations)`
`protected void`	`_addMixOvers(Method mixin, AnnotatedMethod target, boolean addParamAnnotations)`
`protected void`	`_addMixUnders(Method src, AnnotatedMethod target)` Method that will add annotations from specified source method to target method, but only if target does not yet have them.
`protected AnnotationMap`	`_collectRelevantAnnotations(Annotation[] anns)`
`protected AnnotationMap[]`	`_collectRelevantAnnotations(Annotation[][] anns)`
`protected AnnotatedConstructor`	`_constructConstructor(Constructor<?> ctor, boolean defaultCtor)`
`protected AnnotatedMethod`	`_constructCreatorMethod(Method m)`
`protected AnnotatedField`	`_constructField(Field f)`
`protected AnnotatedMethod`	`_constructMethod(Method m)`
`protected Map<String,AnnotatedField>`	`_findFields(Class<?> c, Map<String,AnnotatedField> fields)`
`protected boolean`	`_isIncludableMemberMethod(Method m)`
`Iterable<Annotation>`	`annotations()` Accessor that can be used to iterate over all the annotations associated with annotated component.
`static AnnotatedClass`	`construct(Class<?> cls, AnnotationIntrospector aintr, ClassIntrospector.MixInResolver mir)` Factory method that instantiates an instance.
`static AnnotatedClass`	`constructWithoutSuperTypes(Class<?> cls, AnnotationIntrospector aintr, ClassIntrospector.MixInResolver mir)` Method similar to `construct(java.lang.Class<?>, com.fasterxml.jackson.databind.AnnotationIntrospector, com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver)`, but that will NOT include information from supertypes; only class itself and any direct mix-ins it may have.
`Iterable<AnnotatedField>`	`fields()`
`AnnotatedMethod`	`findMethod(String name, Class<?>[] paramTypes)`
`protected AnnotationMap`	`getAllAnnotations()` Internal helper method used to access annotation information; not exposed to developers since instances are mutable.
`Class<?>`	`getAnnotated()` Method that can be used to find actual JDK element that this instance represents.
`<A extends Annotation> A`	`getAnnotation(Class<A> acls)`
`Annotations`	`getAnnotations()`
`List<AnnotatedConstructor>`	`getConstructors()`
`AnnotatedConstructor`	`getDefaultConstructor()`
`int`	`getFieldCount()`
`Type`	`getGenericType()` Full generic type of the annotated element; definition of what exactly this means depends on sub-class.
`int`	`getMemberMethodCount()`
`int`	`getModifiers()`
`String`	`getName()`
`Class<?>`	`getRawType()` "Raw" type (type-erased class) of the annotated element; definition of what exactly this means depends on sub-class.
`List<AnnotatedMethod>`	`getStaticMethods()`
`boolean`	`hasAnnotations()`
`Iterable<AnnotatedMethod>`	`memberMethods()`
`String`	`toString()`
`AnnotatedClass`	`withAnnotations(AnnotationMap ann)` Fluent factory method that will construct a new instance that uses specified instance annotations instead of currently configured ones.

Methods inherited from class com.fasterxml.jackson.databind.introspect.Annotated
getType, hasAnnotation, isPublic, withFallBackAnnotationsFrom

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - _class
```
protected final Class<?> _class
```
    Class for which annotations apply, and that owns other components (constructors, methods)
  - _superTypes
```
protected final List<Class<?>> _superTypes
```
    Ordered set of super classes and interfaces of the class itself: included in order of precedence
  - _annotationIntrospector
```
protected final AnnotationIntrospector _annotationIntrospector
```
    Filter used to determine which annotations to gather; used to optimize things so that unnecessary annotations are ignored.
  - _mixInResolver
```
protected final ClassIntrospector.MixInResolver _mixInResolver
```
    Object that knows mapping of mix-in classes (ones that contain annotations to add) with their target classes (ones that get these additional annotations "mixed in").
  - _primaryMixIn
```
protected final Class<?> _primaryMixIn
```
    Primary mix-in class; one to use for the annotated class itself. Can be null.
  - _classAnnotations
```
protected AnnotationMap _classAnnotations
```
    Combined list of Jackson annotations that the class has, including inheritable ones from super classes and interfaces
  - _creatorsResolved
```
protected boolean _creatorsResolved
```
    Flag to indicate whether creator information has been resolved or not.
  - _defaultConstructor
```
protected AnnotatedConstructor _defaultConstructor
```
    Default constructor of the annotated class, if it has one.
  - _constructors
```
protected List<AnnotatedConstructor> _constructors
```
    Single argument constructors the class has, if any.
  - _creatorMethods
```
protected List<AnnotatedMethod> _creatorMethods
```
    Single argument static methods that might be usable as factory methods
  - _memberMethods
```
protected AnnotatedMethodMap _memberMethods
```
    Member methods of interest; for now ones with 0 or 1 arguments (just optimization, since others won't be used now)
  - _fields
```
protected List<AnnotatedField> _fields
```
    Member fields of interest: ones that are either public, or have at least one annotation.
- Method Detail
  - withAnnotations
```
public AnnotatedClass withAnnotations(AnnotationMap ann)
```
    Description copied from class: Annotated
    
    Fluent factory method that will construct a new instance that uses specified instance annotations instead of currently configured ones.
    
    Specified by:
    
    withAnnotations in class Annotated
  - construct
```
public static AnnotatedClass construct(Class<?> cls,
                       AnnotationIntrospector aintr,
                       ClassIntrospector.MixInResolver mir)
```
    Factory method that instantiates an instance. Returned instance will only be initialized with class annotations, but not with any method information.
  - constructWithoutSuperTypes
```
public static AnnotatedClass constructWithoutSuperTypes(Class<?> cls,
                                        AnnotationIntrospector aintr,
                                        ClassIntrospector.MixInResolver mir)
```
    Method similar to construct(java.lang.Class<?>, com.fasterxml.jackson.databind.AnnotationIntrospector, com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver), but that will NOT include information from supertypes; only class itself and any direct mix-ins it may have.
  - getAnnotated
```
public Class<?> getAnnotated()
```
    Description copied from class: Annotated
    
    Method that can be used to find actual JDK element that this instance represents. It is non-null, except for method/constructor parameters which do not have a JDK counterpart.
    
    Specified by:
    
    getAnnotated in class Annotated
  - getModifiers
```
public int getModifiers()
```
    Specified by:
    
    getModifiers in class Annotated
  - getName
```
public String getName()
```
    Specified by:
    
    getName in class Annotated
  - getAnnotation
```
public <A extends Annotation> A getAnnotation(Class<A> acls)
```
    Specified by:
    
    getAnnotation in class Annotated
  - getGenericType
```
public Type getGenericType()
```
    Description copied from class: Annotated
    
    Full generic type of the annotated element; definition of what exactly this means depends on sub-class.
    
    Specified by:
    
    getGenericType in class Annotated
  - getRawType
```
public Class<?> getRawType()
```
    Description copied from class: Annotated
    
    "Raw" type (type-erased class) of the annotated element; definition of what exactly this means depends on sub-class.
    
    Specified by:
    
    getRawType in class Annotated
  - annotations
```
public Iterable<Annotation> annotations()
```
    Description copied from class: Annotated
    
    Accessor that can be used to iterate over all the annotations associated with annotated component.
    
    Specified by:
    
    annotations in class Annotated
  - getAllAnnotations
```
protected AnnotationMap getAllAnnotations()
```
    Description copied from class: Annotated
    
    Internal helper method used to access annotation information; not exposed to developers since instances are mutable.
    
    Specified by:
    
    getAllAnnotations in class Annotated
  - getAnnotations
```
public Annotations getAnnotations()
```
  - hasAnnotations
```
public boolean hasAnnotations()
```
  - getDefaultConstructor
```
public AnnotatedConstructor getDefaultConstructor()
```
  - getConstructors
```
public List<AnnotatedConstructor> getConstructors()
```
  - getStaticMethods
```
public List<AnnotatedMethod> getStaticMethods()
```
  - memberMethods
```
public Iterable<AnnotatedMethod> memberMethods()
```
  - getMemberMethodCount
```
public int getMemberMethodCount()
```
  - findMethod
```
public AnnotatedMethod findMethod(String name,
                         Class<?>[] paramTypes)
```
  - getFieldCount
```
public int getFieldCount()
```
  - fields
```
public Iterable<AnnotatedField> fields()
```
  - _addClassMixIns
```
protected void _addClassMixIns(AnnotationMap annotations,
                   Class<?> toMask)
```
    Helper method for adding any mix-in annotations specified class might have.
  - _addClassMixIns
```
protected void _addClassMixIns(AnnotationMap annotations,
                   Class<?> toMask,
                   Class<?> mixin)
```
  - _addConstructorMixIns
```
protected void _addConstructorMixIns(Class<?> mixin)
```
  - _addFactoryMixIns
```
protected void _addFactoryMixIns(Class<?> mixin)
```
  - _addMemberMethods
```
protected void _addMemberMethods(Class<?> cls,
                     AnnotatedMethodMap methods,
                     Class<?> mixInCls,
                     AnnotatedMethodMap mixIns)
```
  - _addMethodMixIns
```
protected void _addMethodMixIns(Class<?> targetClass,
                    AnnotatedMethodMap methods,
                    Class<?> mixInCls,
                    AnnotatedMethodMap mixIns)
```
  - _findFields
```
protected Map<String,AnnotatedField> _findFields(Class<?> c,
                                     Map<String,AnnotatedField> fields)
```
  - _addFieldMixIns
```
protected void _addFieldMixIns(Class<?> targetClass,
                   Class<?> mixInCls,
                   Map<String,AnnotatedField> fields)
```
    Method called to add field mix-ins from given mix-in class (and its fields) into already collected actual fields (from introspected classes and their super-classes)
  - _constructMethod
```
protected AnnotatedMethod _constructMethod(Method m)
```
  - _constructConstructor
```
protected AnnotatedConstructor _constructConstructor(Constructor<?> ctor,
                                         boolean defaultCtor)
```
  - _constructCreatorMethod
```
protected AnnotatedMethod _constructCreatorMethod(Method m)
```
  - _constructField
```
protected AnnotatedField _constructField(Field f)
```
  - _isIncludableMemberMethod
```
protected boolean _isIncludableMemberMethod(Method m)
```
  - _collectRelevantAnnotations
```
protected AnnotationMap[] _collectRelevantAnnotations(Annotation[][] anns)
```
  - _collectRelevantAnnotations
```
protected AnnotationMap _collectRelevantAnnotations(Annotation[] anns)
```
  - _addMixOvers
```
protected void _addMixOvers(Constructor<?> mixin,
                AnnotatedConstructor target,
                boolean addParamAnnotations)
```
    Parameters:
    addParamAnnotations - Whether parameter annotations are to be added as well
  - _addMixOvers
```
protected void _addMixOvers(Method mixin,
                AnnotatedMethod target,
                boolean addParamAnnotations)
```
    Parameters:
    addParamAnnotations - Whether parameter annotations are to be added as well
  - _addMixUnders
```
protected void _addMixUnders(Method src,
                 AnnotatedMethod target)
```
    Method that will add annotations from specified source method to target method, but only if target does not yet have them.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class AnnotatedClass

Field Summary

Method Summary

Methods inherited from class com.fasterxml.jackson.databind.introspect.Annotated

Methods inherited from class java.lang.Object

Field Detail

_class

_superTypes

_annotationIntrospector

_mixInResolver

_primaryMixIn

_classAnnotations

_creatorsResolved

_defaultConstructor

_constructors

_creatorMethods

_memberMethods

_fields

Method Detail

withAnnotations

construct

constructWithoutSuperTypes

getAnnotated

getModifiers

getName

getAnnotation

getGenericType

getRawType

annotations

getAllAnnotations

getAnnotations

hasAnnotations

getDefaultConstructor

getConstructors

getStaticMethods

memberMethods

getMemberMethodCount

findMethod

getFieldCount

fields

_addClassMixIns

_addClassMixIns

_addConstructorMixIns

_addFactoryMixIns

_addMemberMethods

_addMethodMixIns

_findFields

_addFieldMixIns

_constructMethod

_constructConstructor

_constructCreatorMethod

_constructField

_isIncludableMemberMethod

_collectRelevantAnnotations

_collectRelevantAnnotations

_addMixOvers

_addMixOvers

_addMixUnders

toString