View Javadoc

1   /*
2    * Copyright 1999-2004 The Apache Software Foundation
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.commons.jxpath.ri.compiler;
17  
18  import org.apache.commons.jxpath.ri.Compiler;
19  import org.apache.commons.jxpath.ri.QName;
20  
21  /***
22   * @author Dmitri Plotnikov
23   * @version $Revision: 1.10 $ $Date: 2004/02/29 14:17:39 $
24   */
25  public class TreeCompiler implements Compiler {
26  
27      private static final QName QNAME_NAME = new QName(null, "name");
28  
29      public Object number(String value) {
30          return new Constant(new Double(value));
31      }
32  
33      public Object literal(String value) {
34          return new Constant(value);
35      }
36  
37      public Object qname(String prefix, String name) {
38          return new QName(prefix, name);
39      }
40  
41      public Object sum(Object[] arguments) {
42          return new CoreOperationAdd(toExpressionArray(arguments));
43      }
44  
45      public Object minus(Object left, Object right) {
46          return new CoreOperationSubtract(
47              (Expression) left,
48              (Expression) right);
49      }
50  
51      public Object multiply(Object left, Object right) {
52          return new CoreOperationMultiply((Expression) left, (Expression) right);
53      }
54  
55      public Object divide(Object left, Object right) {
56          return new CoreOperationDivide((Expression) left, (Expression) right);
57      }
58  
59      public Object mod(Object left, Object right) {
60          return new CoreOperationMod((Expression) left, (Expression) right);
61      }
62  
63      public Object lessThan(Object left, Object right) {
64          return new CoreOperationLessThan((Expression) left, (Expression) right);
65      }
66  
67      public Object lessThanOrEqual(Object left, Object right) {
68          return new CoreOperationLessThanOrEqual(
69              (Expression) left,
70              (Expression) right);
71      }
72  
73      public Object greaterThan(Object left, Object right) {
74          return new CoreOperationGreaterThan(
75              (Expression) left,
76              (Expression) right);
77      }
78  
79      public Object greaterThanOrEqual(Object left, Object right) {
80          return new CoreOperationGreaterThanOrEqual(
81              (Expression) left,
82              (Expression) right);
83      }
84  
85      public Object equal(Object left, Object right) {
86          if (isNameAttributeTest((Expression) left)) {
87              return new NameAttributeTest((Expression) left, (Expression) right);
88          }
89          else {
90              return new CoreOperationEqual(
91                  (Expression) left,
92                  (Expression) right);
93          }
94      }
95  
96      public Object notEqual(Object left, Object right) {
97          return new CoreOperationNotEqual(
98              (Expression) left,
99              (Expression) right);
100     }
101 
102     public Object minus(Object argument) {
103         return new CoreOperationNegate((Expression) argument);
104     }
105 
106     public Object variableReference(Object qName) {
107         return new VariableReference((QName) qName);
108     }
109 
110     public Object function(int code, Object[] args) {
111         return new CoreFunction(code, toExpressionArray(args));
112     }
113 
114     public Object function(Object name, Object[] args) {
115         return new ExtensionFunction((QName) name, toExpressionArray(args));
116     }
117 
118     public Object and(Object arguments[]) {
119         return new CoreOperationAnd(
120             toExpressionArray(arguments));
121     }
122 
123     public Object or(Object arguments[]) {
124         return new CoreOperationOr(
125             toExpressionArray(arguments));
126     }
127 
128     public Object union(Object[] arguments) {
129         return new CoreOperationUnion(
130             toExpressionArray(arguments));
131     }
132 
133     public Object locationPath(boolean absolute, Object[] steps) {
134         return new LocationPath(absolute, toStepArray(steps));
135     }
136 
137     public Object expressionPath(
138         Object expression,
139         Object[] predicates,
140         Object[] steps) 
141     {
142         return new ExpressionPath(
143             (Expression) expression,
144             toExpressionArray(predicates),
145             toStepArray(steps));
146     }
147 
148     public Object nodeNameTest(Object qname) {
149         return new NodeNameTest((QName) qname);
150     }
151 
152     public Object nodeTypeTest(int nodeType) {
153         return new NodeTypeTest(nodeType);
154     }
155 
156     public Object processingInstructionTest(String instruction) {
157         return new ProcessingInstructionTest(instruction);
158     }
159 
160     public Object step(int axis, Object nodeTest, Object[] predicates) {
161         return new Step(
162             axis,
163             (NodeTest) nodeTest,
164             toExpressionArray(predicates));
165     }
166 
167     private Expression[] toExpressionArray(Object[] array) {
168         Expression expArray[] = null;
169         if (array != null) {
170             expArray = new Expression[array.length];
171             for (int i = 0; i < expArray.length; i++) {
172                 expArray[i] = (Expression) array[i];
173             }
174         }
175         return expArray;
176     }
177 
178     private Step[] toStepArray(Object[] array) {
179         Step stepArray[] = null;
180         if (array != null) {
181             stepArray = new Step[array.length];
182             for (int i = 0; i < stepArray.length; i++) {
183                 stepArray[i] = (Step) array[i];
184             }
185         }
186         return stepArray;
187     }
188 
189     private boolean isNameAttributeTest(Expression arg) {
190         if (!(arg instanceof LocationPath)) {
191             return false;
192         }
193 
194         Step[] steps = ((LocationPath) arg).getSteps();
195         if (steps.length != 1) {
196             return false;
197         }
198         if (steps[0].getAxis() != Compiler.AXIS_ATTRIBUTE) {
199             return false;
200         }
201         NodeTest test = steps[0].getNodeTest();
202         if (!(test instanceof NodeNameTest)) {
203             return false;
204         }
205         if (!((NodeNameTest) test).getNodeName().equals(QNAME_NAME)) {
206             return false;
207         }
208         return true;
209     }
210 }