Rule implementation that calls a method on the (top-1) (parent) * object, passing the top object (child) as an argument. It is * commonly used to establish parent-child relationships.
* *This rule now supports more flexible method matching by default. * It is possible that this may break (some) code * written against release 1.1.1 or earlier. * See {@link #isExactMatch()} for more details.
* * @author Craig McClanahan * @author Scott Sanders * @version $Revision: 1.16 $ $Date: 2003/04/16 11:23:50 $ */ public class SetNextRule extends Rule { // ----------------------------------------------------------- Constructors /** * Construct a "set next" rule with the specified method name. The * method's argument type is assumed to be the class of the * child object. * * @param digester The associated Digester * @param methodName Method name of the parent method to call * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #SetNextRule(String methodName)} instead. */ public SetNextRule(Digester digester, String methodName) { this(methodName); } /** * Construct a "set next" rule with the specified method name. * * @param digester The associated Digester * @param methodName Method name of the parent method to call * @param paramType Java class of the parent method's argument * (if you wish to use a primitive type, specify the corresonding * Java wrapper class instead, such asjava.lang.Boolean
* for a boolean parameter)
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #SetNextRule(String methodName,String paramType)} instead.
*/
public SetNextRule(Digester digester, String methodName,
String paramType) {
this(methodName, paramType);
}
/**
* Construct a "set next" rule with the specified method name. The
* method's argument type is assumed to be the class of the
* child object.
*
* @param methodName Method name of the parent method to call
*/
public SetNextRule(String methodName) {
this(methodName, null);
}
/**
* Construct a "set next" rule with the specified method name.
*
* @param methodName Method name of the parent method to call
* @param paramType Java class of the parent method's argument
* (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 SetNextRule(String methodName,
String paramType) {
this.methodName = methodName;
this.paramType = paramType;
}
// ----------------------------------------------------- Instance Variables
/**
* The method name to call on the parent object.
*/
protected String methodName = null;
/**
* The Java class name of the parameter type expected by the method.
*/
protected String paramType = null;
/**
* Should we use exact matching. Default is no.
*/
protected boolean useExactMatch = false;
// --------------------------------------------------------- Public Methods
/**
* Is exact matching being used.
* *This rule uses org.apache.commons.beanutils.MethodUtils
* to introspect the relevent objects so that the right method can be called.
* Originally, MethodUtils.invokeExactMethod was used.
* This matches methods very strictly
* and so may not find a matching method when one exists.
* This is still the behaviour when exact matching is enabled.
When exact matching is disabled, MethodUtils.invokeMethod is used.
* This method finds more methods but is less precise when there are several methods
* with correct signatures.
* So, if you want to choose an exact signature you might need to enable this property.
The default setting is to disable exact matches.
* * @return true iff exact matching is enabled * @since Digester Release 1.1.1 */ public boolean isExactMatch() { return useExactMatch; } /** *Set whether exact matching is enabled.
* *See {@link #isExactMatch()}.
* * @param useExactMatch should this rule use exact method matching * @since Digester Release 1.1.1 */ public void setExactMatch(boolean useExactMatch) { this.useExactMatch = useExactMatch; } /** * Process the end of this element. */ public void end() throws Exception { // Identify the objects to be used Object child = digester.peek(0); Object parent = digester.peek(1); if (digester.log.isDebugEnabled()) { if (parent == null) { digester.log.debug("[SetNextRule]{" + digester.match + "} Call [NULL PARENT]." + methodName + "(" + child + ")"); } else { digester.log.debug("[SetNextRule]{" + digester.match + "} Call " + parent.getClass().getName() + "." + methodName + "(" + child + ")"); } } // Call the specified method Class paramTypes[] = new Class[1]; if (paramType != null) { paramTypes[0] = digester.getClassLoader().loadClass(paramType); } else { paramTypes[0] = child.getClass(); } if (useExactMatch) { MethodUtils.invokeExactMethod(parent, methodName, new Object[]{ child }, paramTypes); } else { MethodUtils.invokeMethod(parent, methodName, new Object[]{ child }, paramTypes); } } /** * Render a printable version of this Rule. */ public String toString() { StringBuffer sb = new StringBuffer("SetNextRule["); sb.append("methodName="); sb.append(methodName); sb.append(", paramType="); sb.append(paramType); sb.append("]"); return (sb.toString()); } }