/*

 * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.lang.reflect;

import sun.reflect.MethodAccessor;

import sun.reflect.Reflection;

import sun.reflect.generics.repository.MethodRepository;

import sun.reflect.generics.factory.CoreReflectionFactory;

import sun.reflect.generics.factory.GenericsFactory;

import sun.reflect.generics.scope.MethodScope;

import sun.reflect.annotation.AnnotationType;

import sun.reflect.annotation.AnnotationParser;

import java.lang.annotation.Annotation;

import java.lang.annotation.AnnotationFormatError;

import java.nio.ByteBuffer;

import java.util.Map;

/**

 * A {@code Method} provides information about, and access to, a single method

 * on a class or interface.  The reflected method may be a class method

 * or an instance method (including an abstract method).

 *

 * <p>A {@code Method} permits widening conversions to occur when matching the

 * actual parameters to invoke with the underlying method's formal

 * parameters, but it throws an {@code IllegalArgumentException} if a

 * narrowing conversion would occur.

 *

 * @see Member

 * @see java.lang.Class

 * @see java.lang.Class#getMethods()

 * @see java.lang.Class#getMethod(String, Class[])

 * @see java.lang.Class#getDeclaredMethods()

 * @see java.lang.Class#getDeclaredMethod(String, Class[])

 *

 * @author Kenneth Russell

 * @author Nakul Saraiya

 */

public final

    class Method extends AccessibleObject implements GenericDeclaration,

                                                     Member {

    private Class<?>            clazz;

    private int                 slot;

    // This is guaranteed to be interned by the VM in the 1.4

    // reflection implementation

    private String              name;

    private Class<?>            returnType;

    private Class<?>[]          parameterTypes;

    private Class<?>[]          exceptionTypes;

    private int                 modifiers;

    // Generics and annotations support

    private transient String              signature;

    // generic info repository; lazily initialized

    private transient MethodRepository genericInfo;

    private byte[]              annotations;

    private byte[]              parameterAnnotations;

    private byte[]              annotationDefault;

    private volatile MethodAccessor methodAccessor;

    // For sharing of MethodAccessors. This branching structure is

    // currently only two levels deep (i.e., one root Method and

    // potentially many Method objects pointing to it.)

    private Method              root;

   // Generics infrastructure

    private String getGenericSignature() {return signature;}

    // Accessor for factory

    private GenericsFactory getFactory() {

        // create scope and factory

        return CoreReflectionFactory.make(this, MethodScope.make(this));

    }

    // Accessor for generic info repository

    private MethodRepository getGenericInfo() {

        // lazily initialize repository if necessary

        if (genericInfo == null) {

            // create and cache generic info repository

            genericInfo = MethodRepository.make(getGenericSignature(),

                                                getFactory());

        }

        return genericInfo; //return cached repository

    }

    /**

     * Package-private constructor used by ReflectAccess to enable

     * instantiation of these objects in Java code from the java.lang

     * package via sun.reflect.LangReflectAccess.

     */

    Method(Class<?> declaringClass,

           String name,

           Class<?>[] parameterTypes,

           Class<?> returnType,

           Class<?>[] checkedExceptions,

           int modifiers,

           int slot,

           String signature,

           byte[] annotations,

           byte[] parameterAnnotations,

           byte[] annotationDefault)

    {

        this.clazz = declaringClass;

        this.name = name;

        this.parameterTypes = parameterTypes;

        this.returnType = returnType;

        this.exceptionTypes = checkedExceptions;

        this.modifiers = modifiers;

        this.slot = slot;

        this.signature = signature;

        this.annotations = annotations;

        this.parameterAnnotations = parameterAnnotations;

        this.annotationDefault = annotationDefault;

    }

    /**

     * Package-private routine (exposed to java.lang.Class via

     * ReflectAccess) which returns a copy of this Method. The copy's

     * "root" field points to this Method.

     */

    Method copy() {

        // This routine enables sharing of MethodAccessor objects

        // among Method objects which refer to the same underlying

        // method in the VM. (All of this contortion is only necessary

        // because of the "accessibility" bit in AccessibleObject,

        // which implicitly requires that new java.lang.reflect

        // objects be fabricated for each reflective call on Class

        // objects.)

        Method res = new Method(clazz, name, parameterTypes, returnType,

                                exceptionTypes, modifiers, slot, signature,

                                annotations, parameterAnnotations, annotationDefault);

        res.root = this;

        // Might as well eagerly propagate this if already present

        res.methodAccessor = methodAccessor;

        return res;

    }

    /**

     * Returns the {@code Class} object representing the class or interface

     * that declares the method represented by this {@code Method} object.

     */

    public Class<?> getDeclaringClass() {

        return clazz;

    }

    /**

     * Returns the name of the method represented by this {@code Method}

     * object, as a {@code String}.

     */

    public String getName() {

        return name;

    }

    /**

     * Returns the Java language modifiers for the method represented

     * by this {@code Method} object, as an integer. The {@code Modifier} class should

     * be used to decode the modifiers.

     *

     * @see Modifier

     */

    public int getModifiers() {

        return modifiers;

    }

    /**

     * Returns an array of {@code TypeVariable} objects that represent the

     * type variables declared by the generic declaration represented by this

     * {@code GenericDeclaration} object, in declaration order.  Returns an

     * array of length 0 if the underlying generic declaration declares no type

     * variables.

     *

     * @return an array of {@code TypeVariable} objects that represent

     *     the type variables declared by this generic declaration

     * @throws GenericSignatureFormatError if the generic

     *     signature of this generic declaration does not conform to

     *     the format specified in the Java Virtual Machine Specification,

     *     3rd edition

     * @since 1.5

     */

    public TypeVariable<Method>[] getTypeParameters() {

        if (getGenericSignature() != null)

            return (TypeVariable<Method>[])getGenericInfo().getTypeParameters();

        else

            return (TypeVariable<Method>[])new TypeVariable[0];

    }

    /**

     * Returns a {@code Class} object that represents the formal return type

     * of the method represented by this {@code Method} object.

     *

     * @return the return type for the method this object represents

     */

    public Class<?> getReturnType() {

        return returnType;

    }

    /**

     * Returns a {@code Type} object that represents the formal return

     * type of the method represented by this {@code Method} object.

     *

     * <p>If the return type is a parameterized type,

     * the {@code Type} object returned must accurately reflect

     * the actual type parameters used in the source code.

     *

     * <p>If the return type is a type variable or a parameterized type, it

     * is created. Otherwise, it is resolved.

     *

     * @return  a {@code Type} object that represents the formal return

     *     type of the underlying  method

     * @throws GenericSignatureFormatError

     *     if the generic method signature does not conform to the format

     *     specified in the Java Virtual Machine Specification, 3rd edition

     * @throws TypeNotPresentException if the underlying method's

     *     return type refers to a non-existent type declaration

     * @throws MalformedParameterizedTypeException if the

     *     underlying method's return typed refers to a parameterized

     *     type that cannot be instantiated for any reason

     * @since 1.5

     */

    public Type getGenericReturnType() {

      if (getGenericSignature() != null) {

        return getGenericInfo().getReturnType();

      } else { return getReturnType();}

    }

    /**

     * Returns an array of {@code Class} objects that represent the formal

     * parameter types, in declaration order, of the method

     * represented by this {@code Method} object.  Returns an array of length

     * 0 if the underlying method takes no parameters.

     *

     * @return the parameter types for the method this object

     * represents

     */

    public Class<?>[] getParameterTypes() {

        return (Class<?>[]) parameterTypes.clone();

    }

    /**

     * Returns an array of {@code Type} objects that represent the formal

     * parameter types, in declaration order, of the method represented by

     * this {@code Method} object. Returns an array of length 0 if the

     * underlying method takes no parameters.

     *

     * <p>If a formal parameter type is a parameterized type,

     * the {@code Type} object returned for it must accurately reflect

     * the actual type parameters used in the source code.

     *

     * <p>If a formal parameter type is a type variable or a parameterized

     * type, it is created. Otherwise, it is resolved.

     *

     * @return an array of Types that represent the formal

     *     parameter types of the underlying method, in declaration order

     * @throws GenericSignatureFormatError

     *     if the generic method signature does not conform to the format

     *     specified in the Java Virtual Machine Specification, 3rd edition

     * @throws TypeNotPresentException if any of the parameter

     *     types of the underlying method refers to a non-existent type

     *     declaration

     * @throws MalformedParameterizedTypeException if any of

     *     the underlying method's parameter types refer to a parameterized

     *     type that cannot be instantiated for any reason

     * @since 1.5

     */

    public Type[] getGenericParameterTypes() {

        if (getGenericSignature() != null)

            return getGenericInfo().getParameterTypes();

        else

            return getParameterTypes();

    }

    /**

     * Returns an array of {@code Class} objects that represent

     * the types of the exceptions declared to be thrown

     * by the underlying method

     * represented by this {@code Method} object.  Returns an array of length

     * 0 if the method declares no exceptions in its {@code throws} clause.

     *

     * @return the exception types declared as being thrown by the

     * method this object represents

     */

    public Class<?>[] getExceptionTypes() {

        return (Class<?>[]) exceptionTypes.clone();

    }

    /**

     * Returns an array of {@code Type} objects that represent the

     * exceptions declared to be thrown by this {@code Method} object.

     * Returns an array of length 0 if the underlying method declares

     * no exceptions in its {@code throws} clause.

     *

     * <p>If an exception type is a type variable or a parameterized

     * type, it is created. Otherwise, it is resolved.

     *

     * @return an array of Types that represent the exception types

     *     thrown by the underlying method

     * @throws GenericSignatureFormatError

     *     if the generic method signature does not conform to the format

     *     specified in the Java Virtual Machine Specification, 3rd edition

     * @throws TypeNotPresentException if the underlying method's

     *     {@code throws} clause refers to a non-existent type declaration

     * @throws MalformedParameterizedTypeException if

     *     the underlying method's {@code throws} clause refers to a

     *     parameterized type that cannot be instantiated for any reason

     * @since 1.5

     */

      public Type[] getGenericExceptionTypes() {

          Type[] result;

          if (getGenericSignature() != null &&

              ((result = getGenericInfo().getExceptionTypes()).length > 0))

              return result;

          else

              return getExceptionTypes();

      }

    /**

     * Compares this {@code Method} against the specified object.  Returns

     * true if the objects are the same.  Two {@code Methods} are the same if

     * they were declared by the same class and have the same name

     * and formal parameter types and return type.

     */

    public boolean equals(Object obj) {

        if (obj != null && obj instanceof Method) {

            Method other = (Method)obj;

            if ((getDeclaringClass() == other.getDeclaringClass())

                && (getName() == other.getName())) {

                if (!returnType.equals(other.getReturnType()))

                    return false;

                /* Avoid unnecessary cloning */

                Class<?>[] params1 = parameterTypes;

                Class<?>[] params2 = other.parameterTypes;

                if (params1.length == params2.length) {

                    for (int i = 0; i < params1.length; i++) {

                        if (params1[i] != params2[i])

                            return false;

                    }

                    return true;

                }

            }

        }

        return false;

    }

    /**

     * Returns a hashcode for this {@code Method}.  The hashcode is computed

     * as the exclusive-or of the hashcodes for the underlying

     * method's declaring class name and the method's name.

     */

    public int hashCode() {

        return getDeclaringClass().getName().hashCode() ^ getName().hashCode();

    }

    /**

     * Returns a string describing this {@code Method}.  The string is

     * formatted as the method access modifiers, if any, followed by

     * the method return type, followed by a space, followed by the

     * class declaring the method, followed by a period, followed by

     * the method name, followed by a parenthesized, comma-separated

     * list of the method's formal parameter types. If the method

     * throws checked exceptions, the parameter list is followed by a

     * space, followed by the word throws followed by a

     * comma-separated list of the thrown exception types.

     * For example:

     * <pre>

     *    public boolean java.lang.Object.equals(java.lang.Object)

     * </pre>

     *

     * <p>The access modifiers are placed in canonical order as

     * specified by "The Java Language Specification".  This is

     * {@code public}, {@code protected} or {@code private} first,

     * and then other modifiers in the following order:

     * {@code abstract}, {@code static}, {@code final},

     * {@code synchronized}, {@code native}, {@code strictfp}.

     */

    public String toString() {

        try {

            int mod = getModifiers() & Modifier.methodModifiers();

            if (mod != 0) {

            }

            Class<?>[] params = parameterTypes; // avoid clone

            for (int j = 0; j < params.length; j++) {

                sb.append(Field.getTypeName(params[j]));

                if (j < (params.length - 1))

            }

            Class<?>[] exceptions = exceptionTypes; // avoid clone

            if (exceptions.length > 0) {

                sb.append(" throws ");

                for (int k = 0; k < exceptions.length; k++) {

                    sb.append(exceptions[k].getName());

                    if (k < (exceptions.length - 1))

                }

            }

            return sb.toString();

        } catch (Exception e) {

            return "<" + e + ">";

        }

    }

    /**

     * Returns a string describing this {@code Method}, including

     * type parameters.  The string is formatted as the method access

     * modifiers, if any, followed by an angle-bracketed

     * comma-separated list of the method's type parameters, if any,

     * followed by the method's generic return type, followed by a

     * space, followed by the class declaring the method, followed by

     * a period, followed by the method name, followed by a

     * parenthesized, comma-separated list of the method's generic

     * formal parameter types.

     *

     * If this method was declared to take a variable number of

     * arguments, instead of denoting the last parameter as

     * "<tt><i>Type</i>[]</tt>", it is denoted as

     * "<tt><i>Type</i>...</tt>".

     *

     * A space is used to separate access modifiers from one another

     * and from the type parameters or return type.  If there are no

     * type parameters, the type parameter list is elided; if the type

     * parameter list is present, a space separates the list from the

     * class name.  If the method is declared to throw exceptions, the

     * parameter list is followed by a space, followed by the word

     * throws followed by a comma-separated list of the generic thrown

     * exception types.  If there are no type parameters, the type

     * parameter list is elided.

     *

     * <p>The access modifiers are placed in canonical order as

     * specified by "The Java Language Specification".  This is

     * {@code public}, {@code protected} or {@code private} first,

     * and then other modifiers in the following order:

     * {@code abstract}, {@code static}, {@code final},

     * {@code synchronized}, {@code native}, {@code strictfp}.

     *

     * @return a string describing this {@code Method},

     * include type parameters

     *

     * @since 1.5

     */

    public String toGenericString() {

        try {

            StringBuilder sb = new StringBuilder();

            int mod = getModifiers() & Modifier.methodModifiers();

            if (mod != 0) {

            }

            TypeVariable<?>[] typeparms = getTypeParameters();

            if (typeparms.length > 0) {

                boolean first = true;

                for(TypeVariable<?> typeparm: typeparms) {

                    if (!first)

                    // Class objects can't occur here; no need to test

                    // and call Class.getName().

                    sb.append(typeparm.toString());

                    first = false;

                }

                sb.append("> ");

            }

            Type genRetType = getGenericReturnType();

            sb.append( ((genRetType instanceof Class<?>)?

            Type[] params = getGenericParameterTypes();

            for (int j = 0; j < params.length; j++) {

                String param = (params[j] instanceof Class)?

                    Field.getTypeName((Class)params[j]):

                    (params[j].toString());

                if (isVarArgs() && (j == params.length - 1)) // replace T[] with T...

                    param = param.replaceFirst("\\[\\]$", "...");

                sb.append(param);

                if (j < (params.length - 1))

            }

            Type[] exceptions = getGenericExceptionTypes();

            if (exceptions.length > 0) {

                sb.append(" throws ");

                for (int k = 0; k < exceptions.length; k++) {

                    sb.append((exceptions[k] instanceof Class)?

                              ((Class)exceptions[k]).getName():

                              exceptions[k].toString());

                    if (k < (exceptions.length - 1))

                }

            }

            return sb.toString();

        } catch (Exception e) {

            return "<" + e + ">";