*
* Note: This class returns and accepts types as Classes, even
* primitive types; there are Class types defined that represent each
* different primitive type. They are java.lang.Boolean.TYPE,
* java.lang.Byte.TYPE,, also available as boolean.class,
* byte.class, etc. These are not to be confused with the
* classes java.lang.Boolean, java.lang.Byte, etc., which are
* real classes.
*
* Also note that this is not a serializable class. It is entirely feasible
* to make it serializable using the Externalizable interface, but this is
* on Sun, not me.
*
* @author John Keiser
* @author Eric Blake
*
* If the method is static,
*
* Next, if this Method enforces access control, your runtime context is
* evaluated, and you may have an
*
* Finally, the method is invoked. If it completes normally, the return value
* will be null for a void method, a wrapped object for a primitive return
* method, or the actual return of an Object method. If it completes
* abruptly, the exception is wrapped in an
*
* Return an array of arrays representing the annotations on each
* of the method's parameters. The outer array is aligned against
* the parameters of the method and is thus equal in length to
* the number of parameters (thus having a length zero if there are none).
* Each array element in the outer array contains an inner array which
* holds the annotations. This array has a length of zero if the parameter
* has no annotations.
*
* The returned annotations are serialized. Changing the annotations has
* no affect on the return value of future calls to this method.
* Modifier
* class to interpret the values. A method can only have a subset of the
* following modifiers: public, private, protected, abstract, static,
* final, synchronized, native, and strictfp.
*
* @return an integer representing the modifiers to this Member
* @see Modifier
*/
public int getModifiers()
{
return m.getModifiersInternal() & METHOD_MODIFIERS;
}
/**
* Return true if this method is a bridge method. A bridge method
* is generated by the compiler in some situations involving
* generics and inheritance.
* @since 1.5
*/
public boolean isBridge()
{
return (m.getModifiersInternal() & Modifier.BRIDGE) != 0;
}
/**
* Return true if this method is synthetic, false otherwise.
* @since 1.5
*/
public boolean isSynthetic()
{
return (m.getModifiersInternal() & Modifier.SYNTHETIC) != 0;
}
/**
* Return true if this is a varargs method, that is if
* the method takes a variable number of arguments.
* @since 1.5
*/
public boolean isVarArgs()
{
return (m.getModifiersInternal() & Modifier.VARARGS) != 0;
}
/**
* Gets the return type of this method.
* @return the type of this method
*/
public Class getReturnType()
{
return (Class) m.getReturnType();
}
/**
* Get the parameter list for this method, in declaration order. If the
* method takes no parameters, returns a 0-length array (not null).
*
* @return a list of the types of the method's parameters
*/
public Class[] getParameterTypes()
{
return (Class[]) m.getParameterTypes();
}
/**
* Get the exception types this method says it throws, in no particular
* order. If the method has no throws clause, returns a 0-length array
* (not null).
*
* @return a list of the types in the method's throws clause
*/
public Class[] getExceptionTypes()
{
return (Class[]) m.getExceptionTypes();
}
/**
* Compare two objects to see if they are semantically equivalent.
* Two Methods are semantically equivalent if they have the same declaring
* class, name, parameter list, and return type.
*
* @param o the object to compare to
* @return true if they are equal; false if not
*/
public boolean equals(Object o)
{
return m.equals(o);
}
/**
* Get the hash code for the Method. The Method hash code is the hash code
* of its name XOR'd with the hash code of its class name.
*
* @return the hash code for the object
*/
public int hashCode()
{
return m.getDeclaringClass().getName().hashCode() ^ m.getName().hashCode();
}
/**
* Get a String representation of the Method. A Method's String
* representation is "<modifiers> <returntype>
* <methodname>(<paramtypes>) throws <exceptions>", where
* everything after ')' is omitted if there are no exceptions.
Example:
* public static int run(java.lang.Runnable,int)
*
* @return the String representation of the Method
*/
public String toString()
{
// 128 is a reasonable buffer initial size for constructor
CPStringBuilder sb = new CPStringBuilder(128);
Modifier.toString(getModifiers(), sb).append(' ');
sb.append(ClassHelper.getUserName(getReturnType())).append(' ');
sb.append(getDeclaringClass().getName()).append('.');
sb.append(getName()).append('(');
Class[] c = getParameterTypes();
if (c.length > 0)
{
sb.append(ClassHelper.getUserName(c[0]));
for (int i = 1; i < c.length; i++)
sb.append(',').append(ClassHelper.getUserName(c[i]));
}
sb.append(')');
c = getExceptionTypes();
if (c.length > 0)
{
sb.append(" throws ").append(c[0].getName());
for (int i = 1; i < c.length; i++)
sb.append(',').append(c[i].getName());
}
return sb.toString();
}
public String toGenericString()
{
// 128 is a reasonable buffer initial size for constructor
CPStringBuilder sb = new CPStringBuilder(128);
Modifier.toString(getModifiers(), sb).append(' ');
Constructor.addTypeParameters(sb, getTypeParameters());
sb.append(getGenericReturnType()).append(' ');
sb.append(getDeclaringClass().getName()).append('.');
sb.append(getName()).append('(');
Type[] types = getGenericParameterTypes();
if (types.length > 0)
{
sb.append(types[0]);
for (int i = 1; i < types.length; i++)
sb.append(',').append(types[i]);
}
sb.append(')');
types = getGenericExceptionTypes();
if (types.length > 0)
{
sb.append(" throws ").append(types[0]);
for (int i = 1; i < types.length; i++)
sb.append(',').append(types[i]);
}
return sb.toString();
}
/**
* Invoke the method. Arguments are automatically unwrapped and widened,
* and the result is automatically wrapped, if needed.o will be ignored. Otherwise,
* the method uses dynamic lookup as described in JLS 15.12.4.4. You cannot
* mimic the behavior of nonvirtual lookup (as in super.foo()). This means
* you will get a NullPointerException if o is
* null, and an IllegalArgumentException if it is incompatible
* with the declaring class of the method. If the method takes 0 arguments,
* you may use null or a 0-length array for args.IllegalAccessException if
* you could not acces this method in similar compiled code. If the method
* is static, and its class is uninitialized, you trigger class
* initialization, which may end in a
* ExceptionInInitializerError.InvocationTargetException.
*
* @param o the object to invoke the method on
* @param args the arguments to the method
* @return the return value of the method, wrapped in the appropriate
* wrapper if it is primitive
* @throws IllegalAccessException if the method could not normally be called
* by the Java code (i.e. it is not public)
* @throws IllegalArgumentException if the number of arguments is incorrect;
* if the arguments types are wrong even with a widening conversion;
* or if o is not an instance of the class or interface
* declaring this method
* @throws InvocationTargetException if the method throws an exception
* @throws NullPointerException if o is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static method triggered
* class initialization, which then failed
*/
public Object invoke(Object o, Object... args)
throws IllegalAccessException, InvocationTargetException
{
return m.invoke(o, args);
}
/**
* Returns an array of TypeVariable objects that represents
* the type variables declared by this constructor, in declaration order.
* An array of size zero is returned if this class has no type
* variables.
*
* @return the type variables associated with this class.
* @throws GenericSignatureFormatError if the generic signature does
* not conform to the format specified in the Virtual Machine
* specification, version 3.
* @since 1.5
*/
public TypeVariableType objects that represents
* the exception types declared by this method, in declaration order.
* An array of size zero is returned if this method declares no
* exceptions.
*
* @return the exception types declared by this method.
* @throws GenericSignatureFormatError if the generic signature does
* not conform to the format specified in the Virtual Machine
* specification, version 3.
* @since 1.5
*/
public Type[] getGenericExceptionTypes()
{
if (p == null)
{
String sig = m.getSignature();
if (sig == null)
return getExceptionTypes();
p = new MethodSignatureParser(this, sig);
}
return p.getGenericExceptionTypes();
}
/**
* Returns an array of Type objects that represents
* the parameter list for this method, in declaration order.
* An array of size zero is returned if this method takes no
* parameters.
*
* @return a list of the types of the method's parameters
* @throws GenericSignatureFormatError if the generic signature does
* not conform to the format specified in the Virtual Machine
* specification, version 3.
* @since 1.5
*/
public Type[] getGenericParameterTypes()
{
if (p == null)
{
String sig = m.getSignature();
if (sig == null)
return getParameterTypes();
p = new MethodSignatureParser(this, sig);
}
return p.getGenericParameterTypes();
}
/**
* Returns the return type of this method.
*
* @return the return type of this method
* @throws GenericSignatureFormatError if the generic signature does
* not conform to the format specified in the Virtual Machine
* specification, version 3.
* @since 1.5
*/
public Type getGenericReturnType()
{
if (p == null)
{
String sig = m.getSignature();
if (sig == null)
return getReturnType();
p = new MethodSignatureParser(this, sig);
}
return p.getGenericReturnType();
}
/**
* If this method is an annotation method, returns the default
* value for the method. If there is no default value, or if the
* method is not a member of an annotation type, returns null.
* Primitive types are wrapped.
*
* @throws TypeNotPresentException if the method returns a Class,
* and the class cannot be found
*
* @since 1.5
*/
public Object getDefaultValue()
{
return m.getDefaultValue();
}
/**
* null if no such annotation exists.
*
* @param annotationClass the type of annotation to look for.
* @return this element's annotation for the specified type, or
* null if no such annotation exists.
* @throws NullPointerException if the annotation class is null.
*/
public