Rule implementation that calls a method on the top (parent)
* object, passing arguments collected from subsequent
* CallParamRule rules or from the body of this
* element.
* By using {@link #CallMethodRule(String methodName)}
* a method call can be made to a method which accepts no
* arguments.
* Incompatible method parameter types are converted
* using org.apache.commons.beanutils.ConvertUtils.
*
This rule now uses {@link MethodUtils#invokeMethod} by default.
* This increases the kinds of methods successfully and allows primitives
* to be matched by passing in wrapper classes.
* There are rare cases when {@link MethodUtils#invokeExactMethod}
* (the old defualt) is required.
* This method is much stricter in it's reflection.
* Setting the UseExactMatch to true reverts to the use of this
* method.
java.lang.Boolean
* for a boolean parameter)
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #CallMethodRule(String methodName,int paramCount, String [] paramTypes)} instead.
*/
public CallMethodRule(Digester digester, String methodName,
int paramCount, String paramTypes[]) {
this(methodName, paramCount, paramTypes);
}
/**
* Construct a "call method" rule with the specified method name.
*
* @param digester The associated Digester
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of ths element
* @param paramTypes The Java classes that represent the
* parameter types of the method arguments
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean.TYPE
* for a boolean parameter)
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #CallMethodRule(String methodName,int paramCount, Class [] paramTypes)} instead.
*/
public CallMethodRule(Digester digester, String methodName,
int paramCount, Class paramTypes[]) {
this(methodName, paramCount, paramTypes);
}
/**
* Construct a "call method" rule with the specified method name. The
* parameter types (if any) default to java.lang.String.
*
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of this element.
*/
public CallMethodRule(String methodName,
int paramCount) {
this.methodName = methodName;
this.paramCount = paramCount;
if (paramCount == 0) {
this.paramTypes = new Class[] { String.class };
} else {
this.paramTypes = new Class[paramCount];
for (int i = 0; i < this.paramTypes.length; i++) {
this.paramTypes[i] = String.class;
}
}
}
/**
* Construct a "call method" rule with the specified method name.
* The method should accept no parameters.
*
* @param methodName Method name of the parent method to call
*/
public CallMethodRule(String methodName) {
this(methodName, 0, (Class[]) null);
}
/**
* Construct a "call method" rule with the specified method name and
* parameter types. If paramCount is set to zero the rule
* will use the body of this element as the single argument of the
* method, unless paramTypes is null or empty, in this
* case the rule will call the specified method with no arguments.
*
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of ths element
* @param paramTypes The Java class names of the arguments
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean
* for a boolean parameter)
*/
public CallMethodRule(
String methodName,
int paramCount,
String paramTypes[]) {
this.methodName = methodName;
this.paramCount = paramCount;
if (paramTypes == null) {
this.paramTypes = new Class[paramCount];
for (int i = 0; i < this.paramTypes.length; i++) {
this.paramTypes[i] = "abc".getClass();
}
} else {
// copy the parameter class names into an array
// the classes will be loaded when the digester is set
this.paramClassNames = new String[paramTypes.length];
for (int i = 0; i < this.paramClassNames.length; i++) {
this.paramClassNames[i] = paramTypes[i];
}
}
}
/**
* Construct a "call method" rule with the specified method name and
* parameter types. If paramCount is set to zero the rule
* will use the body of this element as the single argument of the
* method, unless paramTypes is null or empty, in this
* case the rule will call the specified method with no arguments.
*
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of ths element
* @param paramTypes The Java classes that represent the
* parameter types of the method arguments
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean.TYPE
* for a boolean parameter)
*/
public CallMethodRule(
String methodName,
int paramCount,
Class paramTypes[]) {
this.methodName = methodName;
this.paramCount = paramCount;
if (paramTypes == null) {
this.paramTypes = new Class[paramCount];
for (int i = 0; i < this.paramTypes.length; i++) {
this.paramTypes[i] = "abc".getClass();
}
} else {
this.paramTypes = new Class[paramTypes.length];
for (int i = 0; i < this.paramTypes.length; i++) {
this.paramTypes[i] = paramTypes[i];
}
}
}
// ----------------------------------------------------- Instance Variables
/**
* The body text collected from this element.
*/
protected String bodyText = null;
/**
* The method name to call on the parent object.
*/
protected String methodName = null;
/**
* The number of parameters to collect from MethodParam rules.
* If this value is zero, a single parameter will be collected from the
* body of this element.
*/
protected int paramCount = 0;
/**
* The parameter types of the parameters to be collected.
*/
protected Class paramTypes[] = null;
/**
* The names of the classes of the parameters to be collected.
* This attribute allows creation of the classes to be postponed until the digester is set.
*/
private String paramClassNames[] = null;
/**
* Should MethodUtils.invokeExactMethod be used for reflection.
*/
protected boolean useExactMatch = false;
// --------------------------------------------------------- Public Methods
/**
* Should MethodUtils.invokeExactMethod
* be used for the reflection.
*/
public boolean getUseExactMatch() {
return useExactMatch;
}
/**
* Set whether MethodUtils.invokeExactMethod
* should be used for the reflection.
*/
public void setUseExactMatch(boolean useExactMatch)
{
this.useExactMatch = useExactMatch;
}
/**
* Set the associated digester.
* If needed, this class loads the parameter classes from their names.
*/
public void setDigester(Digester digester)
{
// call superclass
super.setDigester(digester);
// if necessary, load parameter classes
if (this.paramClassNames != null) {
this.paramTypes = new Class[paramClassNames.length];
for (int i = 0; i < this.paramClassNames.length; i++) {
try {
this.paramTypes[i] =
digester.getClassLoader().loadClass(this.paramClassNames[i]);
} catch (ClassNotFoundException e) {
// use the digester log
digester.getLogger().error("(CallMethodRule) Cannot load class " + this.paramClassNames[i], e);
this.paramTypes[i] = null; // Will cause NPE later
}
}
}
}
/**
* Process the start of this element.
*
* @param attributes The attribute list for this element
*/
public void begin(Attributes attributes) throws Exception {
// Push an array to capture the parameter values if necessary
if (paramCount > 0) {
Object parameters[] = new Object[paramCount];
for (int i = 0; i < parameters.length; i++) {
parameters[i] = null;
}
digester.pushParams(parameters);
}
}
/**
* Process the body text of this element.
*
* @param bodyText The body text of this element
*/
public void body(String bodyText) throws Exception {
if (paramCount == 0) {
this.bodyText = bodyText.trim();
}
}
/**
* Process the end of this element.
*/
public void end() throws Exception {
// Retrieve or construct the parameter values array
Object parameters[] = null;
if (paramCount > 0) {
parameters = (Object[]) digester.popParams();
if (digester.log.isTraceEnabled()) {
for (int i=0,size=parameters.length;i