org.apache.commons.digester
public class: SetNextRule [javadoc |
source]
java.lang.Object
org.apache.commons.digester.Rule
org.apache.commons.digester.SetNextRule
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 #isExactMatch() for more details.
Note that while CallMethodRule uses commons-beanutils' data-conversion
functionality (ConvertUtils class) to convert parameter values into
the appropriate type for the parameter to the called method, this
rule does not. Needing to use ConvertUtils functionality when building
parent-child relationships is expected to be very rare; however if you
do need this then instead of using this rule, create a CallMethodRule
specifying targetOffset of 1 in the constructor.
| Field Summary |
|---|
| protected String | methodName | The method name to call on the parent object. |
| protected String | paramType | The Java class name of the parameter type expected by the method. |
| protected boolean | useExactMatch | Should we use exact matching. Default is no. |
| Constructor: |
|---|
 public SetNextRule(String methodName) {
this(methodName, null);
}
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. Parameters:
methodName - Method name of the parent method to call
|
public SetNextRule(Digester digester,
String methodName) {
this(methodName);
} 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. Parameters:
digester - The associated Digester
methodName - Method name of the parent method to call
|
public SetNextRule(String methodName,
String paramType) {
this.methodName = methodName;
this.paramType = paramType;
} Construct a "set next" rule with the specified method name. Parameters:
methodName - Method name of the parent method to call
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(Digester digester,
String methodName,
String paramType) {
this(methodName, paramType);
} Construct a "set next" rule with the specified method name. Parameters:
digester - The associated Digester
methodName - Method name of the parent method to call
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)
|
| Methods from org.apache.commons.digester.Rule: |
|---|
|
begin, begin, body, body, end, end, finish, getDigester, getNamespaceURI, setDigester, setNamespaceURI |
| Method from org.apache.commons.digester.SetNextRule Detail: |
|---|
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);
}
} Process the end of this element. |
public boolean isExactMatch() {
// --------------------------------------------------------- Public Methods
return useExactMatch;
} 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.
|
public void setExactMatch(boolean useExactMatch) {
this.useExactMatch = useExactMatch;
} |
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());
} Render a printable version of this Rule. |
Save This Page