A Statement captures the execution of an object method. It stores * the object, the method to call, and the arguments to the method and * provides the ability to execute the method on the object, using the * provided arguments.
* * @author Jerry Quinn (jlquinn@optonline.net) * @author Robert Schuster (robertschuster@fsfe.org) * @since 1.4 */ public class Statement { private Object target; private String methodName; private Object[] arguments; /** * One or the other of these will get a value after execute is * called once, but not both. */ private transient Method method; private transient Constructor ctor; /** *Constructs a statement representing the invocation of * object.methodName(arg[0], arg[1], ...);
* *If the argument array is null it is replaced with an * array of zero length.
* * @param target The object to invoke the method on. * @param methodName The object method to invoke. * @param arguments An array of arguments to pass to the method. */ public Statement(Object target, String methodName, Object[] arguments) { this.target = target; this.methodName = methodName; this.arguments = (arguments != null) ? arguments : new Object[0]; } /** * Execute the statement. * *Finds the specified method in the target object and calls it with * the arguments given in the constructor.
* *The most specific method according to the JLS(15.11) is used when * there are multiple methods with the same name.
* *Execute performs some special handling for methods and * parameters: *
The Sun spec doesn't deal with overloading between int and * Integer carefully. If there are two methods, one that takes an * Integer and the other taking an int, the method chosen is not * specified, and can depend on the order in which the methods are * declared in the source file.
* * @throws Exception if an exception occurs while locating or * invoking the method. */ public void execute() throws Exception { doExecute(); } private static Class wrappers[] = { Boolean.class, Byte.class, Character.class, Double.class, Float.class, Integer.class, Long.class, Short.class }; private static Class natives[] = { Boolean.TYPE, Byte.TYPE, Character.TYPE, Double.TYPE, Float.TYPE, Integer.TYPE, Long.TYPE, Short.TYPE }; /** Given a wrapper class, return the native class for it. *For example, if c is Integer,
* Integer.TYPE is returned.
true if all args can be assigned to
* params, false otherwise.
*
* Arrays are guaranteed to be the same length.
*/ private boolean compatible(Class[] params, Class[] args) { for (int i = 0; i < params.length; i++) { // Argument types are derived from argument values. If one of them was // null then we cannot deduce its type. However null can be assigned to // any type. if (args[i] == null) continue; // Treat Integer like int if appropriate Class nativeType = unwrap(args[i]); if (nativeType != null && params[i].isPrimitive() && params[i].isAssignableFrom(nativeType)) continue; if (params[i].isAssignableFrom(args[i])) continue; return false; } return true; } /** * Returnstrue if the method arguments in first are
* more specific than the method arguments in second, i.e. all
* arguments in first can be assigned to those in
* second.
*
* A method is more specific if all parameters can also be fed to * the less specific method, because, e.g. the less specific method * accepts a base class of the equivalent argument for the more * specific one.
* * @param first aClass[] value
* @param second a Class[] value
* @return a boolean value
*/
private boolean moreSpecific(Class[] first, Class[] second)
{
for (int j=0; j < first.length; j++)
{
if (second[j].isAssignableFrom(first[j]))
continue;
return false;
}
return true;
}
final Object doExecute() throws Exception
{
Class klazz = (target instanceof Class)
? (Class) target : target.getClass();
Object args[] = (arguments == null) ? new Object[0] : arguments;
Class argTypes[] = new Class[args.length];
// Retrieve type or use null if the argument is null. The null argument
// type is later used in compatible().
for (int i = 0; i < args.length; i++)
argTypes[i] = (args[i] != null) ? args[i].getClass() : null;
if (target.getClass().isArray())
{
// FIXME: invoke may have to be used. For now, cast to Number
// and hope for the best. If caller didn't behave, we go boom
// and throw the exception.
if (methodName.equals("get") && argTypes.length == 1)
return Array.get(target, ((Number)args[0]).intValue());
if (methodName.equals("set") && argTypes.length == 2)
{
Object obj = Array.get(target, ((Number)args[0]).intValue());
Array.set(target, ((Number)args[0]).intValue(), args[1]);
return obj;
}
throw new NoSuchMethodException("No matching method for statement " + toString());
}
// If we already cached the method, just use it.
if (method != null)
return method.invoke(target, args);
else if (ctor != null)
return ctor.newInstance(args);
// Find a matching method to call. JDK seems to go through all
// this to find the method to call.
// if method name or length don't match, skip
// Need to go through each arg
// If arg is wrapper - check if method arg is matchable builtin
// or same type or super
// - check that method arg is same or super
if (methodName.equals("new") && target instanceof Class)
{
Constructor ctors[] = klazz.getConstructors();
for (int i = 0; i < ctors.length; i++)
{
// Skip methods with wrong number of args.
Class ptypes[] = ctors[i].getParameterTypes();
if (ptypes.length != args.length)
continue;
// Check if method matches
if (!compatible(ptypes, argTypes))
continue;
// Use method[i] if it is more specific.
// FIXME: should this check both directions and throw if
// neither is more specific?
if (ctor == null)
{
ctor = ctors[i];
continue;
}
Class mptypes[] = ctor.getParameterTypes();
if (moreSpecific(ptypes, mptypes))
ctor = ctors[i];
}
if (ctor == null)
throw new InstantiationException("No matching constructor for statement " + toString());
return ctor.newInstance(args);
}
Method methods[] = klazz.getMethods();
for (int i = 0; i < methods.length; i++)
{
// Skip methods with wrong name or number of args.
if (!methods[i].getName().equals(methodName))
continue;
Class ptypes[] = methods[i].getParameterTypes();
if (ptypes.length != args.length)
continue;
// Check if method matches
if (!compatible(ptypes, argTypes))
continue;
// Use method[i] if it is more specific.
// FIXME: should this check both directions and throw if
// neither is more specific?
if (method == null)
{
method = methods[i];
continue;
}
Class mptypes[] = method.getParameterTypes();
if (moreSpecific(ptypes, mptypes))
method = methods[i];
}
if (method == null)
throw new NoSuchMethodException("No matching method for statement " + toString());
// If we were calling Class.forName(String) we intercept and call the
// forName-variant that allows a ClassLoader argument. We take the
// system classloader (aka application classloader) here to make sure
// that application defined classes can be resolved. If we would not
// do that the Class.forName implementation would use the class loader
// of java.beans.Statement which is Statement.
*/
public String toString()
{
CPStringBuilder result = new CPStringBuilder();
String targetName;
if (target != null)
targetName = target.getClass().getSimpleName();
else
targetName = "null";
result.append(targetName);
result.append(".");
result.append(methodName);
result.append("(");
String sep = "";
for (int i = 0; i < arguments.length; i++)
{
result.append(sep);
result.append(
( arguments[i] == null ) ? "null" :
( arguments[i] instanceof String ) ? "\"" + arguments[i] + "\"" :
arguments[i].getClass().getSimpleName());
sep = ", ";
}
result.append(");");
return result.toString();
}
}