|
1
23
24 package org.objectweb.medor.filter.postfix;
25
26 import org.objectweb.jorm.type.api.PType;
27 import org.objectweb.medor.api.MedorException;
28 import org.objectweb.medor.expression.api.BinaryLogicalOperator;
29 import org.objectweb.medor.expression.api.BinaryOperator;
30 import org.objectweb.medor.expression.api.Comparator;
31 import org.objectweb.medor.expression.api.Expression;
32 import org.objectweb.medor.expression.api.ExpressionException;
33 import org.objectweb.medor.expression.api.Operand;
34 import org.objectweb.medor.expression.api.Operator;
35 import org.objectweb.medor.expression.api.ParameterOperand;
36 import org.objectweb.medor.expression.api.TypingException;
37 import org.objectweb.medor.expression.api.UnaryArithmeticOperator;
38 import org.objectweb.medor.expression.api.UnaryLogicalOperator;
39 import org.objectweb.medor.expression.api.UnaryOperator;
40 import org.objectweb.medor.expression.api.VariableOperand;
41 import org.objectweb.medor.expression.api.BinaryArithmeticOperator;
42 import org.objectweb.medor.expression.lib.Not;
43 import org.objectweb.medor.expression.lib.IndexedLocate;
44 import org.objectweb.medor.expression.lib.Sqrt;
45 import org.objectweb.medor.expression.lib.Length;
46 import org.objectweb.medor.expression.lib.FirstLocate;
47 import org.objectweb.medor.filter.api.BelongOperator;
48 import org.objectweb.medor.filter.api.ExpressionHelper;
49 import org.objectweb.medor.query.api.QueryNode;
50 import org.objectweb.medor.tuple.api.Tuple;
51 import org.objectweb.medor.tuple.api.TupleCollection;
52 import org.objectweb.medor.type.lib.QTypeTuple;
53
54 import java.util.ArrayList  ;
55 import java.util.LinkedList ;
56 import java.util.Stack ;
57
58
62 public class PostfixExpressionHelper implements ExpressionHelper {
63
64 int MAX_OPERAND_ON_OPERATOR = 3;
65
66 public Expression[] toStack(Expression e)
67 throws ExpressionException, TypingException {
68 return (Expression[])
69 toStack(e, new ArrayList ()).toArray(new Expression[0]);
70 }
71
72 public Expression join(Expression[] stack)
73 throws ExpressionException, TypingException {
74
75 Expression[] temp = new Expression[MAX_OPERAND_ON_OPERATOR];
76 int operandIdx = 0;
77 for (int i = stack.length; i >= 0; i--) {
78 if (stack[i] instanceof Operand) {
79 if (operandIdx == MAX_OPERAND_ON_OPERATOR) {
80 throw new ExpressionException(
81 "Malformed stack: too many operand:" + (operandIdx + 1));
82 }
83 temp[operandIdx] = stack[i];
84 operandIdx++;
85 } else if (stack[i] instanceof Operator) {
86 Operator op = (Operator) stack[i];
87 if (operandIdx != op.getOperandNumber()) {
88 throw new ExpressionException(
89 "Malformed stack: wrong operand number:" + stack[i]);
90 }
91 for(int j=0; i<op.getOperandNumber(); i++) {
92 op.setExpression(j, temp[j]);
93 }
94 temp[0] = op;
95 operandIdx = 1;
96 } else {
97 throw new ExpressionException(
98 "Malformed stack: Unknown expression element: " + stack[i]);
99 }
100 }
101 return temp[0];
102 }
103
104 public Expression substituteParameters(ParameterOperand[] pos, Expression e)
105 throws ExpressionException, TypingException {
106
107 if (e instanceof ParameterOperand) {
108 ParameterOperand p = (ParameterOperand) e;
109 int j = 0;
110 while (j < pos.length) {
111 if (pos[j].getName().equalsIgnoreCase(p.getName())) {
112 return pos[j];
113 }
114 j++;
115 }
116 throw new ExpressionException("Parameter not defined");
117 } else if (e instanceof Operator) {
118 Operator op = (Operator) e;
119 for(int i=0; i<op.getOperandNumber(); i++) {
120 op.setExpression(i, substituteParameters(pos, op.getExpression(i)));
121 }
122 return op;
123 }
124 return e;
125 }
126
127 public Expression[] substituteParameters(ParameterOperand[] pos,
128 Expression[] stack)
129 throws ExpressionException, TypingException {
130
131 for (int i = 0; (i < stack.length); i++) {
132 if (stack[i] instanceof ParameterOperand) {
133 ParameterOperand p = (ParameterOperand) stack[i];
134 int j = 0;
135 while (j < pos.length) {
136 if (pos[j].getName().equalsIgnoreCase(p.getName())) {
137 stack[i] = pos[j];
138 break;
139 }
140 j++;
141 }
142 if (j == pos.length) {
143 throw new ExpressionException("Parameter not defined");
144 }
145 }
146 }
147 return stack;
148 }
149
150 public void fixIndexes(QueryNode node, Expression e) {
151 }
152
153 public Operand evaluate(Expression[] stack, ParameterOperand[] parameters, Tuple t)
154 throws MedorException, ExpressionException, IllegalStateException {
155 try {
156 Stack expressionResult = new Stack ();
157 int cpt = 0;
158 boolean result;
159 PType type;
160 Comparator c;
161 BinaryLogicalOperator bLogicop;
162 BinaryArithmeticOperator bAritOp;
163 Not notop;
164 Sqrt sqrt;
165 Length length;
166 UnaryArithmeticOperator uAritOp;
167 Operand ve1,ve2,ve3;
168 VariableOperand vop;
170 while (cpt < stack.length) {
171 if (stack[cpt] instanceof Operand) {
172 stack[cpt].evaluate(parameters, t);
174 expressionResult.push(stack[cpt]);
175 } else if (stack[cpt] instanceof Operator) {
176 vop = (VariableOperand) stack[cpt].compileExpression();
179 if (((Operator) stack[cpt]).getOperandNumber() == 3) {
180 ve3 = (Operand) expressionResult.pop();
181 ve2 = (Operand) expressionResult.pop();
182 ve1 = (Operand) expressionResult.pop();
183 if (stack[cpt] instanceof IndexedLocate) {
184 IndexedLocate locate = (IndexedLocate) stack[cpt];
185 vop.setValue(locate.evaluate(ve1.getString(), ve2.getString(), ve3.getInt()));
186 } else
187 throw new MedorException("Unknown Expression element");
188 } else if (stack[cpt] instanceof BinaryOperator) {
189 ve2 = (Operand) expressionResult.pop();
190 ve1 = (Operand) expressionResult.pop();
191 if (stack[cpt] instanceof Comparator) {
192 c = (Comparator) stack[cpt];
193 type = stack[cpt].getType();
194 switch (type.getTypeCode()) {
195 case QTypeTuple.TYPECODE_INT:
196 case QTypeTuple.TYPECODE_OBJINT:
197 vop.setValue(c.evaluate(ve1.getInt(), ve2.getInt()));
198 break;
199 case QTypeTuple.TYPECODE_SHORT:
200 case QTypeTuple.TYPECODE_OBJSHORT:
201 vop.setValue(c.evaluate(ve1.getShort(), ve2.getShort()));
202 break;
203 case QTypeTuple.TYPECODE_BYTE:
204 case QTypeTuple.TYPECODE_OBJBYTE:
205 vop.setValue(c.evaluate(ve1.getByte(), ve2.getByte()));
206 break;
207 case QTypeTuple.TYPECODE_LONG:
208 case QTypeTuple.TYPECODE_OBJLONG:
209 vop.setValue(c.evaluate(ve1.getLong(), ve2.getLong()));
210 break;
211 case QTypeTuple.TYPECODE_DOUBLE:
212 case QTypeTuple.TYPECODE_OBJDOUBLE:
213 vop.setValue(c.evaluate(ve1.getDouble(), ve2.getDouble()));
214 break;
215 case QTypeTuple.TYPECODE_FLOAT:
216 case QTypeTuple.TYPECODE_OBJFLOAT:
217 vop.setValue(c.evaluate(ve1.getFloat(), ve2.getFloat()));
218 break;
219 case QTypeTuple.TYPECODE_STRING:
220 vop.setValue(c.evaluate(ve1.getString(), ve2.getString()));
221 break;
222 case QTypeTuple.TYPECODE_CHAR:
223 case QTypeTuple.TYPECODE_OBJCHAR:
224 vop.setValue(c.evaluate(ve1.getChar(), ve2.getChar()));
225 break;
226 case QTypeTuple.TYPECODE_DATE:
227 vop.setValue(c.evaluate(ve1.getDate(), ve2.getDate()));
228 break;
229
243 }
244 } else if (stack[cpt] instanceof BinaryLogicalOperator) {
245 bLogicop = (BinaryLogicalOperator) stack[cpt];
246 result = bLogicop.evaluate(ve1.getBoolean(),
247 ve2.getBoolean());
248 vop.setValue(result);
249
250 } else if (stack[cpt] instanceof BinaryArithmeticOperator) {
251 bAritOp = (BinaryArithmeticOperator) stack[cpt];
252 type = bAritOp.getType();
256 switch (type.getTypeCode()) {
257 case QTypeTuple.TYPECODE_INT:
258 case QTypeTuple.TYPECODE_OBJINT:
259 vop.setValue(bAritOp.evaluate(ve1.getInt(), ve2.getInt()));
260 break;
261 case QTypeTuple.TYPECODE_SHORT:
262 case QTypeTuple.TYPECODE_OBJSHORT:
263 vop.setValue(bAritOp.evaluate(ve1.getShort(), ve2.getShort()));
264 break;
265 case QTypeTuple.TYPECODE_BYTE:
266 case QTypeTuple.TYPECODE_OBJBYTE:
267 vop.setValue(bAritOp.evaluate(ve1.getByte(), ve2.getByte()));
268 break;
269 case QTypeTuple.TYPECODE_LONG:
270 case QTypeTuple.TYPECODE_OBJLONG:
271 vop.setValue(bAritOp.evaluate(ve1.getLong(), ve2.getLong()));
272 break;
273 case QTypeTuple.TYPECODE_DOUBLE:
274 case QTypeTuple.TYPECODE_OBJDOUBLE:
275 vop.setValue(bAritOp.evaluate(ve1.getDouble(), ve2.getDouble()));
276 break;
277 case QTypeTuple.TYPECODE_FLOAT:
278 case QTypeTuple.TYPECODE_OBJFLOAT:
279 vop.setValue(bAritOp.evaluate(ve1.getFloat(), ve2.getFloat()));
280 break;
281 case QTypeTuple.TYPECODE_STRING:
282 vop.setValue(bAritOp.evaluate(ve1.getString(), ve2.getString()));
283 break;
284 case QTypeTuple.TYPECODE_CHAR:
285 case QTypeTuple.TYPECODE_OBJCHAR:
286 vop.setValue(bAritOp.evaluate(ve1.getChar(), ve2.getChar()));
287 break;
288 case QTypeTuple.TYPECODE_DATE:
289 vop.setValue(bAritOp.evaluate(ve1.getDate(), ve2.getDate()));
290 break;
291 }
292 } else if (stack[cpt] instanceof BelongOperator) {
293 BelongOperator in = (BelongOperator) stack[cpt];
294 vop.setValue(in.evaluate((Tuple)ve1.getObject(),
295 (TupleCollection)ve2.getObject()));
296 } else if (stack[cpt] instanceof FirstLocate) {
297 FirstLocate locate = (FirstLocate) stack[cpt];
298 vop.setValue(locate.evaluate(ve1.getString(), ve2.getString()));
299 } else
300 throw new MedorException("Uknowen Expression element");
301 cpt++;
302 } else if (stack[cpt] instanceof UnaryOperator) {
303 ve1 = (Operand) expressionResult.pop();
304 if (stack[cpt] instanceof UnaryArithmeticOperator) {
305 uAritOp = (UnaryArithmeticOperator) stack[cpt];
306 type = uAritOp.getType();
307 switch (type.getTypeCode()) {
308 case QTypeTuple.TYPECODE_INT:
309 case QTypeTuple.TYPECODE_OBJINT:
310 vop.setValue(uAritOp.evaluate(ve1.getInt()));
311 break;
312 case QTypeTuple.TYPECODE_SHORT:
313 case QTypeTuple.TYPECODE_OBJSHORT:
314 vop.setValue(uAritOp.evaluate(ve1.getShort()));
315 break;
316 case QTypeTuple.TYPECODE_BYTE:
317 case QTypeTuple.TYPECODE_OBJBYTE:
318 vop.setValue(uAritOp.evaluate(ve1.getByte()));
319 break;
320 case QTypeTuple.TYPECODE_LONG:
321 case QTypeTuple.TYPECODE_OBJLONG:
322 vop.setValue(uAritOp.evaluate(ve1.getLong()));
323 break;
324 case QTypeTuple.TYPECODE_DOUBLE:
325 case QTypeTuple.TYPECODE_OBJDOUBLE:
326 vop.setValue(uAritOp.evaluate(ve1.getDouble()));
327 break;
328 case QTypeTuple.TYPECODE_FLOAT:
329 case QTypeTuple.TYPECODE_OBJFLOAT:
330 vop.setValue(uAritOp.evaluate(ve1.getFloat()));
331 break;
332 }
333 } else if (stack[cpt] instanceof UnaryLogicalOperator) {
334 notop = (Not) stack[cpt];
335 vop.setValue(notop.evaluate(ve1.getBoolean()));
336 } else if (stack[cpt] instanceof Sqrt) {
337 sqrt = (Sqrt) stack[cpt];
338 vop.setValue(sqrt.evaluate(ve1.getDouble()));
339 } else if (stack[cpt] instanceof Length) {
340 length = (Length) stack[cpt];
341 vop.setValue(length.evaluate(ve1.getString()));
342 } else
343 throw new MedorException("Unknown Expression element");
344 } else
345 throw new MedorException("Unknown Expression element");
346 expressionResult.push(vop);
347 }
348 cpt++;
349 }
350 return (Operand) expressionResult.pop();
351 } catch (NullPointerException e) {
352 throw new IllegalStateException ("Expression Error: may be not Compiled");
353 }
354 }
355
356 public ArrayList toStack(Expression e, ArrayList al)
357 throws ExpressionException, TypingException {
358 if (e instanceof Operator) {
359 for(int i=0; i< ((Operator) e).getOperandNumber(); i++) {
360 toStack(((Operator) e).getExpression(i), al);
361 }
362 } else if (!(e instanceof Operand)) {
363 throw new ExpressionException(
364 "Malformed stack: Unknown expression element: " + e);
365 }
366 al.add(e);
367 return al;
368 }
369
370 public int getNumberOfNode(Expression e) throws ExpressionException {
371 if (e instanceof Operand) {
372 return 1;
373 } else if (e instanceof Operator) {
374 int result = 1;
375 for (int i= 0; i< ((Operator) e).getOperandNumber(); i++)
376 result += getNumberOfNode(((Operator) e).getExpression(i));
377 return result;
378 } else {
379 throw new ExpressionException(
380 "Malformed stack: Unknown expression element: " + e);
381 }
382 }
383
384
387 public boolean verifyNoNull(Expression e) {
388
389 if (e instanceof Operator) {
390 boolean res = true;
391 for (int i=0 ; i<((Operator) e).getOperandNumber() && res; i++) {
392 res = verifyNoNull(((Operator) e).getExpression(i));
393 }
394 return res;
395 } else {
396 return e != null;
397 }
398 }
399
400 public String [] getParameterNames(Expression
401
402 e) throws ExpressionException, TypingException {
403 LinkedList nameList = new LinkedList ();
404 Expression[] stack = this.toStack(e);
405 for (int i = 0; (i < stack.length); i++) {
406 if (stack[i] instanceof ParameterOperand) {
407 nameList.add(((ParameterOperand) stack[i]).getName());
408 }
409 }
410 return (String []) nameList.toArray(new String [nameList.size()]);
411 }
412 }
413 |
Popular Tags |
Java API By Example, From Geeks To Geeks.