AnnotatedMethod (Jackson JSON Processor)
Date: 2013-07-14

org.codehaus.jackson.map.introspect

## Class AnnotatedMethod

- java.lang.Object
- - org.codehaus.jackson.map.introspect.Annotated
  - - org.codehaus.jackson.map.introspect.AnnotatedMember
    - - org.codehaus.jackson.map.introspect.AnnotatedWithParams
      - - org.codehaus.jackson.map.introspect.AnnotatedMethod

-     public final class AnnotatedMethod
      extends AnnotatedWithParams

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Method` | `_method`
    `protected Class<?>[]` | `_paramTypes`

    - ### Fields inherited from class org.codehaus.jackson.map.introspect.AnnotatedWithParams

      `_paramAnnotations`

    - ### Fields inherited from class org.codehaus.jackson.map.introspect.AnnotatedMember

      `_annotations`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AnnotatedMethod(Method method, AnnotationMap classAnn, AnnotationMap[] paramAnnotations)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Object` | `call()` Method that can be used to (try to) call this object without arguments.
    `Object` | `call(Object[] args)` Method that can be used to (try to) call this object with specified arguments.
    `Object` | `call1(Object arg)` Method that can be used to (try to) call this object with single arguments.
    `Method` | `getAnnotated()` Method that can be used to find actual JDK element that this instance represents.
    `Class<?>` | `getDeclaringClass()`
    `String` | `getFullName()`
    `Type` | `getGenericType()` For methods, this returns declared return type, which is only useful with getters (setters do not return anything; hence "void" type is returned here)
    `Member` | `getMember()`
    `int` | `getModifiers()`
    `String` | `getName()`
    `Class<?>` | `getParameterClass(int index)`
    `Class<?>[]` | `getParameterClasses()`
    `int` | `getParameterCount()`
    `Type` | `getParameterType(int index)`
    `Type[]` | `getParameterTypes()`
    `Class<?>` | `getRawType()` For methods, this returns declared return type, which is only useful with getters (setters do not return anything; hence "void" type is returned here)
    `JavaType` | `getType(TypeBindings bindings)` As per [JACKSON-468], we need to also allow declaration of local type bindings; mostly it will allow defining bounds.
    `void` | `setValue(Object pojo, Object value)` Optional method that can be used to assign value of this member on given object, if this is a supported operation for member type.
    `String` | `toString()`
    `AnnotatedMethod` | `withAnnotations(AnnotationMap ann)` Fluent factory method that will construct a new instance that uses specified instance annotations instead of currently configured ones.
    `AnnotatedMethod` | `withMethod(Method m)` Method that constructs a new instance with settings (annotations, parameter annotations) of this instance, but with different physical `Method`.

    - ### Methods inherited from class org.codehaus.jackson.map.introspect.AnnotatedWithParams

      `addIfNotPresent, addOrOverride, addOrOverrideParam, getAnnotation, getAnnotationCount, getParameter, getParameterAnnotations, getType, replaceParameterAnnotations, resolveParameterType`

    - ### Methods inherited from class org.codehaus.jackson.map.introspect.AnnotatedMember

      `fixAccess, getAllAnnotations`

    - ### Methods inherited from class org.codehaus.jackson.map.introspect.Annotated

      `hasAnnotation, isPublic, withFallBackAnnotationsFrom`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### _method

          protected final Method _method

    - #### _paramTypes

          protected Class<?>[] _paramTypes

  - ### Constructor Detail

    - #### AnnotatedMethod

          public AnnotatedMethod(Method method,
                         AnnotationMap classAnn,
                         AnnotationMap[] paramAnnotations)

  - ### Method Detail

    - #### withMethod

          public AnnotatedMethod withMethod(Method m)

      Method that constructs a new instance with settings (annotations, parameter annotations) of this instance, but with different physical `Method`.
      Since:
        1.7

    - #### withAnnotations

          public AnnotatedMethod 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`

    - #### getAnnotated

          public Method 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`

    - #### getGenericType

          public Type getGenericType()

      For methods, this returns declared return type, which is only useful with getters (setters do not return anything; hence "void" type is returned here)
      Specified by:
        `getGenericType` in class `Annotated`

    - #### getRawType

          public Class<?> getRawType()

      For methods, this returns declared return type, which is only useful with getters (setters do not return anything; hence "void" type is returned here)
      Specified by:
        `getRawType` in class `Annotated`

    - #### getType

          public JavaType getType(TypeBindings bindings)

      As per [JACKSON-468], we need to also allow declaration of local type bindings; mostly it will allow defining bounds.
      Overrides:
        `getType` in class `Annotated`

    - #### call

          public final Object call()
                            throws Exception

      Description copied from class: `AnnotatedWithParams`
      Method that can be used to (try to) call this object without arguments. This may succeed or fail, depending on expected number of arguments: caller needs to take care to pass correct number. Exceptions are thrown directly from actual low-level call.

      Note: only works for constructors and static methods.

      Specified by:
        `call` in class `AnnotatedWithParams`
      Throws:
        `Exception`

    - #### call

          public final Object call(Object[] args)
                            throws Exception

      Description copied from class: `AnnotatedWithParams`
      Method that can be used to (try to) call this object with specified arguments. This may succeed or fail, depending on expected number of arguments: caller needs to take care to pass correct number. Exceptions are thrown directly from actual low-level call.

      Note: only works for constructors and static methods.

      Specified by:
        `call` in class `AnnotatedWithParams`
      Throws:
        `Exception`

    - #### call1

          public final Object call1(Object arg)
                             throws Exception

      Description copied from class: `AnnotatedWithParams`
      Method that can be used to (try to) call this object with single arguments. This may succeed or fail, depending on expected number of arguments: caller needs to take care to pass correct number. Exceptions are thrown directly from actual low-level call.

      Note: only works for constructors and static methods.

      Specified by:
        `call1` in class `AnnotatedWithParams`
      Throws:
        `Exception`

    - #### getDeclaringClass

          public Class<?> getDeclaringClass()

      Specified by:
        `getDeclaringClass` in class `AnnotatedMember`

    - #### getMember

          public Member getMember()

      Specified by:
        `getMember` in class `AnnotatedMember`

    - #### setValue

          public void setValue(Object pojo,
                      Object value)
                        throws IllegalArgumentException

      Description copied from class: `AnnotatedMember`
      Optional method that can be used to assign value of this member on given object, if this is a supported operation for member type.

      This is implemented for fiedlds and single-argument methods; but not for constructor parameters or other types of methods.

      Specified by:
        `setValue` in class `AnnotatedMember`
      Throws:
        `IllegalArgumentException`

    - #### getParameterCount

          public int getParameterCount()

      Specified by:
        `getParameterCount` in class `AnnotatedWithParams`

    - #### getParameterTypes

          public Type[] getParameterTypes()

    - #### getParameterClass

          public Class<?> getParameterClass(int index)

      Specified by:
        `getParameterClass` in class `AnnotatedWithParams`

    - #### getParameterType

          public Type getParameterType(int index)

      Specified by:
        `getParameterType` in class `AnnotatedWithParams`

    - #### getParameterClasses

          public Class<?>[] getParameterClasses()

    - #### getFullName

          public String getFullName()

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`