Method(Method m) 
{
        data = m.data;
        isAccessible = m.isAccessible;
}

Copy constructor

Parameters:

m - original method

 Method(long id,
    Class clss,
    String name,
    String desc,
    int m) 
{
        data = new MethodData(id, clss, name, desc, m);
}

Only VM should call this constructor. String parameters must be interned.

api2vm:

 public boolean equals(Object obj) 
{
        if (obj instanceof Method) {
            Method another = (Method)obj;
            if (data.vm_member_id == another.data.vm_member_id){
                assert getDeclaringClass() == another.getDeclaringClass()
                && getName() == another.getName()
                && getReturnType() == another.getReturnType()
                && Arrays.equals(getParameterTypes(), another.getParameterTypes());
                return true;
            }
        }
        return false;
}

 public A getAnnotation(Class<A> annotationClass) 
{
        if(annotationClass == null) {
            throw new NullPointerException();
        }
        for (Annotation aa : data.getDeclaredAnnotations()) {
            if(aa.annotationType() == annotationClass) {
                return (A) aa;
            }
        }
        return null;
}

 public Annotation[] getDeclaredAnnotations() 
{
        Annotation a[] = data.getDeclaredAnnotations();
        Annotation aa[] = new Annotation[a.length];
        System.arraycopy(a, 0, aa, 0, a.length);
        return aa;
}

 public Class<?> getDeclaringClass() 
{
        return data.declaringClass;
}

 public Object getDefaultValue() 
{
        return VMGenericsAndAnnotations.getDefaultValue(data.vm_member_id);
}

 public Class<?>[] getExceptionTypes() 
{
        return (Class[])data.getExceptionTypes().clone();
}

 public Type[] getGenericExceptionTypes() throws GenericSignatureFormatError, TypeNotPresentException, MalformedParameterizedTypeException 
{
        if (data.genericExceptionTypes == null) {
            data.genericExceptionTypes = Parser.getGenericExceptionTypes(this, VMGenericsAndAnnotations.getSignature(data.vm_member_id));
        }
        return (Type[])data.genericExceptionTypes.clone();
}

 public Type[] getGenericParameterTypes() throws GenericSignatureFormatError, TypeNotPresentException, MalformedParameterizedTypeException 
{
        if (data.genericParameterTypes == null) {
            data.genericParameterTypes = Parser.getGenericParameterTypes(this, VMGenericsAndAnnotations.getSignature(data.vm_member_id));
        }
        return (Type[])data.genericParameterTypes.clone();
}

 public Type getGenericReturnType() throws GenericSignatureFormatError, TypeNotPresentException, MalformedParameterizedTypeException 
{
        if (data.genericReturnType == null) {
            data.genericReturnType = Parser.getGenericReturnTypeImpl(this, VMGenericsAndAnnotations
                    .getSignature(data.vm_member_id));            
        }
        return data.genericReturnType;
}

 long getId() 
{
        return data.vm_member_id;
}

Called by VM to obtain this method's handle.

 public int getModifiers() 
{
        return data.modifiers;
}

 public String getName() 
{
        return data.name;
}

 public Annotation[][] getParameterAnnotations() 
{
        Annotation a[][] = data.getParameterAnnotations();
        Annotation aa[][] = new Annotation[a.length][]; 
        for (int i = 0; i <  a.length; i++ ) {
            aa[i] = new Annotation[a[i].length];
            System.arraycopy(a[i], 0, aa[i], 0, a[i].length);
        }
        return aa;
}

 public Class<?>[] getParameterTypes() 
{
        return (Class[])data.getParameterTypes().clone();
}

 public Class<?> getReturnType() 
{
        return data.getReturnType();
}

 String getSignature() 
{
        return data.descriptor;
}

This method is required by serialization mechanism.

 public TypeVariable<Method>[] getTypeParameters() throws GenericSignatureFormatError 
{
        if (data.typeParameters == null) {
            data.typeParameters = Parser.getTypeParameters(this,
                    VMGenericsAndAnnotations.getSignature(data.vm_member_id));
        }
        return (TypeVariable< Method >[]) data.typeParameters.clone();
}

 public int hashCode() 
{
        return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
}

 public Object invoke(Object obj,
    Object args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException 
{
    	
        obj = checkObject(getDeclaringClass(), getModifiers(), obj);
        // check parameter validity
        checkInvokationArguments(data.getParameterTypes(), args);
        if (!isAccessible) {
            reflectExporter.checkMemberAccess(
                VMStack.getCallerClass(0), getDeclaringClass(),
                obj == null ? getDeclaringClass() : obj.getClass(),
                getModifiers()
            );
        }
        return VMReflection.invokeMethod(data.vm_member_id, obj, args);
}

 public boolean isBridge() 
{
        return (getModifiers() & ACC_BRIDGE) != 0;
}

 public boolean isSynthetic() 
{
        return (getModifiers() & ACC_SYNTHETIC) != 0;
}

 public boolean isVarArgs() 
{
        return (getModifiers() & ACC_VARARGS) != 0;
}

 public String toGenericString() 
{
        StringBuilder sb = new StringBuilder(80);
        // data initialization
        if (data.genericParameterTypes == null) {
            data.genericParameterTypes = Parser.getGenericParameterTypes(this, VMGenericsAndAnnotations.getSignature(data.vm_member_id));
        }
        if (data.genericExceptionTypes == null) {
            data.genericExceptionTypes = Parser.getGenericExceptionTypes(this, VMGenericsAndAnnotations.getSignature(data.vm_member_id));
        }
        // append modifiers if any
        int modifier = getModifiers();
        if (modifier != 0) {
            sb.append(Modifier.toString(modifier & ~(ACC_BRIDGE + ACC_VARARGS))).append(' ');
        }
        // append type parameters
        if (data.typeParameters != null && data.typeParameters.length  > 0) {
            sb.append('< ');
            for (int i = 0; i <  data.typeParameters.length; i++) {
                appendGenericType(sb, data.typeParameters[i]);
                if (i <  data.typeParameters.length - 1) {
                    sb.append(", ");
                }
            }
            sb.append(" > ");
        }
        // append return type
        appendGenericType(sb, getGenericReturnType());
        sb.append(' ');
        // append method name
        appendArrayType(sb, getDeclaringClass());
        sb.append("."+getName());
        // append parameters
        sb.append('(');
        appendArrayGenericType(sb, data.genericParameterTypes);
        sb.append(')');
        // append exeptions if any
        if (data.genericExceptionTypes.length  > 0) {
            sb.append(" throws ");
            appendArrayGenericType(sb, data.genericExceptionTypes);
        }
        return sb.toString();
}

 public String toString() 
{
        StringBuilder sb = new StringBuilder();
        // append modifiers if any
        int modifier = getModifiers();
        if (modifier != 0) {
            // BRIDGE & VARARGS recognized incorrectly
            final int MASK = ~(ACC_BRIDGE + ACC_VARARGS);
            sb.append(Modifier.toString(modifier & MASK)).append(' ');            
        }
        // append return type
        appendArrayType(sb, getReturnType());
        sb.append(' ');
        // append full method name
        sb.append(getDeclaringClass().getName()).append('.').append(getName());
        // append parameters
        sb.append('(');
        appendArrayType(sb, data.getParameterTypes());
        sb.append(')');
        // append exeptions if any
        Class[] exn = data.getExceptionTypes(); 
        if (exn.length  > 0) {
            sb.append(" throws ");
            appendSimpleType(sb, exn);
        }
        return sb.toString();
}