org.codehaus.jackson.map.introspect

## Class AnnotatedClass

- java.lang.Object
- - org.codehaus.jackson.map.introspect.Annotated
  - - org.codehaus.jackson.map.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 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` | `_addFields(Map<String,AnnotatedField> fields, Class<?> c)`
    `protected void` | `_addMemberMethods(Class<?> cls, MethodFilter methodFilter, AnnotatedMethodMap methods, Class<?> mixInCls, AnnotatedMethodMap mixIns)`
    `protected void` | `_addMethodMixIns(Class<?> targetClass, MethodFilter methodFilter, 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 boolean` | `_isIncludableMethod(Method m, MethodFilter filter)`
    `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<?>, 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.
    `Iterable<AnnotatedField>` | `fields()`
    `AnnotatedMethod` | `findMethod(String name, Class<?>[] paramTypes)`
    `protected AnnotationMap` | `getAllAnnotations()`
    `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()`
    `void` | `resolveClassAnnotations()` Initialization method that will recursively collect Jackson annotations for this class and all super classes and interfaces.
    `void` | `resolveCreators(boolean includeAll)` Initialization method that will find out all constructors and potential static factory methods the class has.
    `void` | `resolveFields()` Method that will collect all member (non-static) fields that are either public, or have at least a single annotation associated with them.
    `void` | `resolveFields(boolean collectIgnored)` Deprecated.
    `void` | `resolveMemberMethods(MethodFilter methodFilter)` Method for resolving member method information: aggregating all non-static methods and combining annotations (to implement method-annotation inheritance)
    `void` | `resolveMemberMethods(MethodFilter methodFilter, boolean collectIgnored)` Deprecated.
    `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 org.codehaus.jackson.map.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

    - #### _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<?>, 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.

    - #### 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`

    - #### getAllAnnotations

          protected AnnotationMap getAllAnnotations()

      Specified by:
        `getAllAnnotations` in class `Annotated`

    - #### getAnnotations

          public Annotations getAnnotations()

      Returns:
        1.7

    - #### 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()

    - #### resolveClassAnnotations

          public void resolveClassAnnotations()

      Initialization method that will recursively collect Jackson annotations for this class and all super classes and interfaces.

      Starting with 1.2, it will also apply mix-in annotations, as per [JACKSON-76]

    - #### resolveCreators

          public void resolveCreators(boolean includeAll)

      Initialization method that will find out all constructors and potential static factory methods the class has.

      Starting with 1.2, it will also apply mix-in annotations, as per [JACKSON-76]

      Parameters:
        `includeAll` - If true, includes all creator methods; if false, will only include the no-arguments "default" constructor

    - #### resolveMemberMethods

          public void resolveMemberMethods(MethodFilter methodFilter)

      Method for resolving member method information: aggregating all non-static methods and combining annotations (to implement method-annotation inheritance)
      Parameters:
        `methodFilter` - Filter used to determine which methods to include
      Since:
        1.9

    - #### resolveFields

          public void resolveFields()

      Method that will collect all member (non-static) fields that are either public, or have at least a single annotation associated with them.
      Since:
        1.9

    - #### resolveMemberMethods

          @Deprecated
          public void resolveMemberMethods(MethodFilter methodFilter,
                                             boolean collectIgnored)

      Deprecated.
      Since:
        1.9 Use version without arguments

    - #### resolveFields

          @Deprecated
          public void resolveFields(boolean collectIgnored)

      Deprecated.
      Since:
        1.9 Use version without arguments

    - #### _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,
                               MethodFilter methodFilter,
                               AnnotatedMethodMap methods,
                               Class<?> mixInCls,
                               AnnotatedMethodMap mixIns)

    - #### _addMethodMixIns

          protected void _addMethodMixIns(Class<?> targetClass,
                              MethodFilter methodFilter,
                              AnnotatedMethodMap methods,
                              Class<?> mixInCls,
                              AnnotatedMethodMap mixIns)

    - #### _addFields

          protected void _addFields(Map<String,AnnotatedField> fields,
                        Class<?> c)

    - #### _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)

    - #### _collectRelevantAnnotations

          protected AnnotationMap[] _collectRelevantAnnotations(Annotation[][] anns)

    - #### _collectRelevantAnnotations

          protected AnnotationMap _collectRelevantAnnotations(Annotation[] anns)

    - #### _isIncludableMethod

          protected boolean _isIncludableMethod(Method m,
                                    MethodFilter filter)

    - #### _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`