package java.lang.reflect;

import sun.reflect.CallerSensitive;

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;

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

}

/**

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;

}

/**

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;

}

/**

public Class<?> getDeclaringClass() {

return clazz;

}

/**

public String getName() {

return name;

}

/**

public int getModifiers() {

return modifiers;

}

/**

public TypeVariable<Method>[] getTypeParameters() {

if (getGenericSignature() != null)

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

else

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

}

/**

public Class<?> getReturnType() {

return returnType;

}

/**

public Type getGenericReturnType() {

if (getGenericSignature() != null) {

return getGenericInfo().getReturnType();

} else { return getReturnType();}

}

/**

public Class<?>[] getParameterTypes() {

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

}

/**

public Type[] getGenericParameterTypes() {

if (getGenericSignature() != null)

return getGenericInfo().getParameterTypes();

else

return getParameterTypes();

}

/**

public Class<?>[] getExceptionTypes() {

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

}

/**

public Type[] getGenericExceptionTypes() {

Type[] result;

if (getGenericSignature() != null &&

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

return result;

else

return getExceptionTypes();

}

/**

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;

}

/**

public int hashCode() {

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

}

/**

public String toString() {

try {

StringBuilder sb = new StringBuilder();

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

if (mod != 0) {

sb.append(Modifier.toString(mod)).append(' ');

}

sb.append(Field.getTypeName(getReturnType())).append(' ');

sb.append(Field.getTypeName(getDeclaringClass())).append('.');

sb.append(getName()).append('(');

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

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

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

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

sb.append(',');

}

sb.append(')');

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

sb.append(',');

}

}

return sb.toString();

} catch (Exception e) {

return "<" + e + ">";

}

}

/**

public String toGenericString() {

try {

StringBuilder sb = new StringBuilder();

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

if (mod != 0) {

sb.append(Modifier.toString(mod)).append(' ');

}

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

if (typeparms.length > 0) {

boolean first = true;

sb.append('<');

for(TypeVariable<?> typeparm: typeparms) {

if (!first)

sb.append(',');

// 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<?>)?

Field.getTypeName((Class<?>)genRetType):genRetType.toString()))

.append(' ');

sb.append(Field.getTypeName(getDeclaringClass())).append('.');

sb.append(getName()).append('(');

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

sb.append(',');

}

sb.append(')');

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

sb.append(',');

}

}

return sb.toString();

} catch (Exception e) {

return "<" + e + ">";

}

}

/**

@CallerSensitive

public Object invoke(Object obj, Object... args)

throws IllegalAccessException, IllegalArgumentException,

InvocationTargetException

{

if (!override) {

if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {

// Until there is hotspot @CallerSensitive support

// can't call Reflection.getCallerClass() here

// Workaround for now: add a frame getCallerClass to

// make the caller at stack depth 2

Class<?> caller = getCallerClass();

checkAccess(caller, clazz, obj, modifiers);

}

}

MethodAccessor ma = methodAccessor; // read volatile

if (ma == null) {

ma = acquireMethodAccessor();

}

return ma.invoke(obj, args);

}

/*

@CallerSensitive

private Class<?> getCallerClass() {

// Reflection.getCallerClass() currently returns the frame at depth 2

// before the hotspot support is in.

return Reflection.getCallerClass();

}

/**

public boolean isBridge() {

return (getModifiers() & Modifier.BRIDGE) != 0;

}

/**

public boolean isVarArgs() {

return (getModifiers() & Modifier.VARARGS) != 0;

}

/**

public boolean isSynthetic() {

return Modifier.isSynthetic(getModifiers());

}

// NOTE that there is no synchronization used here. It is correct

// (though not efficient) to generate more than one MethodAccessor

// for a given Method. However, avoiding synchronization will

// probably make the implementation more scalable.

private MethodAccessor acquireMethodAccessor() {

// First check to see if one has been created yet, and take it

// if so

MethodAccessor tmp = null;

if (root != null) tmp = root.getMethodAccessor();

if (tmp != null) {

methodAccessor = tmp;

} else {

// Otherwise fabricate one and propagate it up to the root

tmp = reflectionFactory.newMethodAccessor(this);

setMethodAccessor(tmp);

}

return tmp;

}

// Returns MethodAccessor for this Method object, not looking up

// the chain to the root

MethodAccessor getMethodAccessor() {

return methodAccessor;

}

// Sets the MethodAccessor for this Method object and

// (recursively) its root

void setMethodAccessor(MethodAccessor accessor) {

methodAccessor = accessor;

// Propagate up

if (root != null) {

root.setMethodAccessor(accessor);

}

}

/**

public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {

if (annotationClass == null)

throw new NullPointerException();

return (T) declaredAnnotations().get(annotationClass);

}

/**

public Annotation[] getDeclaredAnnotations() {

return AnnotationParser.toArray(declaredAnnotations());

}

private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;

private synchronized Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {

if (declaredAnnotations == null) {

declaredAnnotations = AnnotationParser.parseAnnotations(

annotations, sun.misc.SharedSecrets.getJavaLangAccess().

getConstantPool(getDeclaringClass()),

getDeclaringClass());

}

return declaredAnnotations;

}

/**

public Object getDefaultValue() {

if (annotationDefault == null)

return null;

Class<?> memberType = AnnotationType.invocationHandlerReturnType(

getReturnType());

Object result = AnnotationParser.parseMemberValue(

memberType, ByteBuffer.wrap(annotationDefault),

sun.misc.SharedSecrets.getJavaLangAccess().

getConstantPool(getDeclaringClass()),

getDeclaringClass());

if (result instanceof sun.reflect.annotation.ExceptionProxy)

throw new AnnotationFormatError("Invalid default: " + this);

return result;

}

/**

public Annotation[][] getParameterAnnotations() {

int numParameters = parameterTypes.length;

if (parameterAnnotations == null)

return new Annotation[numParameters][0];

Annotation[][] result = AnnotationParser.parseParameterAnnotations(

parameterAnnotations,

sun.misc.SharedSecrets.getJavaLangAccess().

getConstantPool(getDeclaringClass()),

getDeclaringClass());

if (result.length != numParameters)

throw new java.lang.annotation.AnnotationFormatError(

"Parameter annotations don't match number of parameters");

return result;

}

}