应用二叉树解析 XML 表示的函数计算表达式

                
<xforms:model …>
 <xforms:instance>…</xforms:instance>
 …
 <xforms:bind calculate="../SubTotal + ../TaxAmount + ../Shipping" 
 nodeset="instance('INSTANCE')/P001/Total"></xforms:bind> 
 <xforms:bind calculate="if(../BudgetMeals !='',../BudgetMeals, '0')- ../ActualMeals"
 nodeset="instance('INSTANCE')/P001/VarianceMeals"></xforms:bind>
 <xforms:bind calculate="min(../aAccount , ../bAccount , ../ cAccount) " 
 nodeset="instance('INSTANCE')/P001/minAccount"></xforms:bind> 
 …
</xforms:model>

                
…
<calculation>
 <func name="IfThen">
 <func name="Less">
 <cell name="DateTo" /> 
 <cell name="DateFrom" /> 
 </func>
 <func name="Alert">
 <boolean value="False" /> 
 <string value="This date must come after the date you have entered in the Date 
 From field" /> 
 </func>
 </func>
 <plainText>If DateTo < DateFrom Then False With Alert
  "This date must come after the  date you have entered in the Date From field"
   End</plainText> 
</calculation>
<calculation>
 <func name="Min">
 <func name="Abs">
 <cell name="Summary" /> 
 </func>
 <func name="Subtract">
 <cell name="Demo1">
 <cell name="Demo2">
 </func>
 <number value="100" /> 
 </func>
 <plainText>Min(Abs(Summary),Demo1-Demo2, 100)</plainText> 
</calculation>
…

                
public class CalNode {
 public CalNode left;
 public CalNode right;
 private String value;
 private String type; // Three kinds of type: cell, func, const
 public CalNode(String type, String value) {
 this.type = type;
 this.value = value;
 }
 public CalNode(CalNode left, String type, String value, CalNode right) {
 this.left = left;
 this.type = type;
 this.value = value;
 this.right = right;
 }
 public String getValue() {
 return value;
 }
 public void setValue(String value) {
 this.value = value;
 }
 public String getType() {
 return type;
 }
}

                
private CalNode createCalBinTree(Node root) {
 String rootName = ParserHelper.validateSID(XMLUtil.getAttribute(
(Element) root, Constants.ATTR_NAME));
 //For <number value=""/> 
 and <string value="xxxx"/> 
 elements within <func>
 if (StringHelper.isEmpty(rootName)) { //isEmpty 方法判断是否为空
 rootName = ParserHelper.validateComputeContent(XMLUtil.getAttribute(
 (Element) root, Constants.ATTR_VALUE));
 }
 String type = root.getNodeName(); // 结点的类型
 if (!CalConstants.CELL.equals(type) && !CalConstants.FUNC.equals(type))
 type = CalConstants.CONST; // 如果类型不是 func 或 cell，则设置为 const
 CalNode rootNode = new CalNode(null, type, rootName, null); // 生成 CalNode 类的实例对象
 Node firstNode = root.getFirstChild(); // 拿到结点 root 的第一个孩子（DOM API）
 if (firstNode != null){ 
 // 递归遍历第一个孩子结点，生成 CalNode 的实例对象。
 CalNode firstCalNode = createCalBinTree(firstNode);
 rootNode.left = firstCalNode; // 把第一个孩子结点设置为该结点的左孩子结点
// 考虑该结点的其它孩子结点
 Node pNode = firstNode;
CalNode qCalNode = firstCalNode;
while (pNode.getNextSibling() != null) {
 Node nextNode = pNode.getNextSibling();
 if (nextNode != null){ 
 CalNode nextCalNode = createCalBinTree(nextNode); // 递归遍历其它孩子结点
 qCalNode.right = nextCalNode; // 设置为其上一个兄弟结点的右孩子结点
 //loop for org.w3c.dom.Node
 pNode = nextNode; 
 //loop for CalNode 
 qCalNode = nextCalNode;
 }
 }
 }
 return rootNode;
}

                
private TreeNode<Elem > 
 GoFarLeft(TreeNode<Elem> t, Stack<TreeNode<Elem> > S) { 
 if (t == null) 
 return null; 
 while (t.left != null){
 S.push(t);
 t = t.left;
 }
 return t;
}
// inorder iterative scan
private void Inorder_I(TreeNode<Elem> t, void visit(Elem c)){ 
 Stack<TreeNode<Elem>> S=new Stack<TreeNode<Elem>>();
 t = GoFarLeft(t,S);
 // continue until t is NULL
 while(t != null){
 visit(t.data); 
 if (t.right!=null)
 t = GoFarLeft(t.right,S);
 else if ( !S.isEmpty( )) 
 t = S.pop();
 else
 t = null; // we are done
 }
}

                
public void createXFormsBinding(CalNode rootNode, StringBuffer str) {
 // 参数 str 用来存放解析结果
 if (rootNode == null) { // 结点为空，返回
 return;
 }
 String foName = rootNode.getValue(); // 获取结点的值
 // 如果类型是 func , 并且是合法的函数
 if ( rootNode.getType().equals(CalConstants.FUNC) && 
 FunctionConstants.isValidFNFunction(foName)) {
 if (rootNode.left == null) {
 // 该结点的左孩子结点是空的时候，逻辑操作如下：
 if (FunctionConstants.NOW.equals(foName)) {
 str.append("now()"); 
 } else if (…) {
 …
 } 
 return;
 } else { // 该结点是带有参数的函数
 // 特殊函数的处理（如：IfThen 和 IFT）
 if (FunctionConstants.IFTHEN.equals(foName)
 || FunctionConstants.IFT.equals(foName)) {
 …
 return;
 }else if(…){ // 其它特殊的函数的处理逻辑
 …
 return;
 }else { // 非特殊函数的处理
 str.append(FunctionConstants.getMappedFunction(foName)
 + "("); //$NON-NLS-1$ // 加左括号
 // 递归调用，用以处理函数的参数
 createXFormsBinding(rootNode.left, str);
 }
 }
 // 右孩子信息
 CalNode p = rootNode.left;
 CalNode q = null;
 if(p!=null)
 q = rootNode.left.right;
 while (p != null && q != null) {
 str.append(","); //$NON-NLS-1$ // 参数用逗号分隔
 createXFormsBinding(q, str); // 递归调用，处理该参数
 q = q.right;
 }
 // 加右括号
 str.append(")"); //$NON-NLS-1$
 // 如果类型是 func , 并且是合法的操作符
 } else if (rootNode.getType().equals(CalConstants.FUNC) && 
 OperatorConstants.isValidFNOperator(foName)) {
 // 若没有左孩子结点，返回 
 if(rootNode.left==null){
 return;
 }
 // 如果是乘，除以及求模等操作符，需要进一步判断，根据需要对左右孩子树加括号
 if (OperatorConstants.DIV.equals(foName)
 || OperatorConstants.MULTIPLY.equals(foName)||…) {
 // 处理操作符的左孩子树
 if (OperatorConstants.isValidFNOperator(rootNode.left
 .getValue())&& …) {
 str.append("("); //$NON-NLS-1$
 createXFormsBinding(rootNode.left, str);
 str.append(")"); //$NON-NLS-1$
 } else {
 createXFormsBinding(rootNode.left, str);
 }
 // 取操作符的名字
 str.append(" " + 
 OperatorConstants.getMappedXFDLOperator(foName) + " ");
 // 处理操作符的右孩子树
 if (rootNode.left.right != null
 && OperatorConstants.isValidFNOperator(rootNode.left.right
 .getValue())&& …) {
 str.append("("); //$NON-NLS-1$
 createXFormsBinding(rootNode.left.right, str);
 str.append(")"); //$NON-NLS-1$
 } else {
 createXFormsBinding(rootNode.left.right, str);
 }
 }
 // 对 % 操作符的逻辑处理
 else if (OperatorConstants.PERCENT.equals(foName)) {
 …
 } 
 // 对其它特殊操作符的逻辑处理
 else if (OperatorConstants.XXX.equals(foName)||…) {
 …
 } 
 // 对非 func 类型进行处理（cell 类型以及表达式中的常量）
 else {
 if (rootNode.getType().equals(CalConstants.CELL)) {
 // 转成 XPATH 表达式的中结点
 str.append("../" + foName); //$NON-NLS-1$ 
 } else { // 表达式中的常量处理
 str.append("'" + foName + "'"); //$NON-NLS-1$ //$NON-NLS-2$
 }
 }
} 

                
<xforms:bind calculate=" min (abs(../Summary), ../Demo1 - ../Demo2, ‘100’ )" 
 nodeset="instance('INSTANCE')/P001/mvNode"></xforms:bind>