KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > calipso > reportgenerator > reportcalculator > expression > ExpressionSimplifier


1 package com.calipso.reportgenerator.reportcalculator.expression;
2
3 import com.calipso.reportgenerator.reportcalculator.*;
4
5 import java.util.*;
6
7 /**
8  * Visitor para obtener una expresión simplificada en base
9  * a un valuación dada en un Context
10  * Una expresión simplificada se obtiene reemplazando las variables por los valores que se obtienen del contexto y
11  * aplicando la operación correspondiente. Si el contexto contiene valores para todas las variables se puede llegar
12  * a un resultado (true/false), sino, solo pueden reemplazarse por un valor constante algunas sub expresiones y la
13  * expresión general se reduce, igualmente, evaluando una expresión con un contexto incompleto da como resultado false.
14  */

15
16 public class ExpressionSimplifier extends ExpressionVisitor {
17   private Context context;
18   private static Map comparators;
19
20
21   public static Map getComparators(){
22     if (comparators == null){
23       comparators = new HashMap();
24       fillComparators(comparators);
25     }
26     return comparators;
27   }
28
29   private static void fillComparators(Map comparators){
30     comparators.put(String JavaDoc.class, new StringComparator());
31     comparators.put(SharedFloat.class, new FloatComparator());
32 // comparators.put(CubeFloat.class, new CubeFloatComparator());
33
comparators.put(Date.class, new DateComparator());
34     comparators.put(SharedString.class, new SharedStringComparator());
35     comparators.put(SharedDate.class, new SharedDateComparator());
36     comparators.put(SharedInteger.class, new SharedIntegerComparator());
37   }
38
39   /**
40    * Resuelve el operador AND simplificando las subexpresiones
41    * @param expression
42    * @return
43    */

44   public Object JavaDoc processAnd(AndExp expression) {
45     return ((Expression) visit(expression.getLeft())).newAnd((Expression) visit(expression.getRight()));
46   }
47
48
49   /**
50    * Las expresiones constantes no necesitan simplificarse
51    * @param expression
52    * @return
53    */

54   public Object JavaDoc processConstant(Expression expression) {
55     return expression;
56   }
57
58   /**
59    * Resuelve si los valores de las expresiones simplificadas son iguales
60    * @param expression
61    * @return
62    */

63   public Object JavaDoc processEqualTo(EqualTo expression) {
64     Expression simpleLeft;
65     Expression simpleRight;
66     boolean value;
67     Expression result;
68
69     simpleLeft = (Expression) visit(expression.getLeft());
70     simpleRight = (Expression) visit(expression.getRight());
71
72     if (simpleLeft.isConstant() && simpleRight.isConstant()) {
73       //value = ((ConstantExp) simpleLeft).value.equals(((ConstantExp) simpleRight).value);
74
value = compare(((ConstantExp) simpleLeft).value, ((ConstantExp) simpleRight).value) == 0;
75       result = ConstantExp.forValue(new Boolean JavaDoc(value));
76     }
77     else {
78       result = simpleLeft.newEqualTo(simpleRight);
79     }
80     return result;
81   }
82
83   private int compare(Object JavaDoc value1, Object JavaDoc value2){
84     Comparator comparator = getComparator(value1.getClass());
85     return comparator.compare(value1, value2);
86   }
87
88   private Comparator getComparator(Class JavaDoc aClass) {
89     return (Comparator) getComparators().get(aClass);
90   }
91
92
93   /**
94    * Resuelve si el valor de una expresión simplificada es Mayor o Igual que el valor simplificado de la otra
95    * @param expression
96    * @return
97    */

98   public Object JavaDoc processGreaterOrEqualTo(GreaterOrEqualTo expression) {
99     Expression simpleLeft;
100     Expression simpleRight;
101     boolean value;
102     Expression result;
103
104     simpleLeft = (Expression) visit(expression.getLeft());
105     simpleRight = (Expression) visit(expression.getRight());
106
107     if (simpleLeft.isConstant() && simpleRight.isConstant()) {
108       int comparisson = compare(((ConstantExp) simpleLeft).value, ((ConstantExp) simpleRight).value);
109       //int comparisson = ((ConstantExp) simpleLeft).value.toString().compareTo(((ConstantExp) simpleRight).value.toString());
110
value = comparisson >= 0;
111       //value = true; //((ConstantExp) simpleLeft).value >= ((ConstantExp) simpleRight).value;
112
result = ConstantExp.forValue(new Boolean JavaDoc(value));
113     }
114     else {
115       result = simpleLeft.newGreaterOrEqualTo(simpleRight);
116     }
117     return result;
118   }
119
120   /**
121    * Resuelve si el valor de una expresión simplificada es Mayor que el valor simplificado de la otra
122    * @param expression
123    * @return
124    */

125
126   public Object JavaDoc processGreaterThan(GreaterThan expression) {
127     Expression simpleLeft;
128     Expression simpleRight;
129     boolean value;
130     Expression result;
131
132     simpleLeft = (Expression) visit(expression.getLeft());
133     simpleRight = (Expression) visit(expression.getRight());
134
135     if (simpleLeft.isConstant() && simpleRight.isConstant()) {
136       int comparisson = compare(((ConstantExp) simpleLeft).value, ((ConstantExp) simpleRight).value);
137       //int comparisson = ((ConstantExp) simpleLeft).value.toString().compareTo(((ConstantExp) simpleRight).value.toString());
138
value = comparisson > 0;
139
140       //value = true; //((ConstantExp) simpleLeft).value > ((ConstantExp) simpleRight).value;
141
result = ConstantExp.forValue(new Boolean JavaDoc(value));
142     }
143     else {
144       result = simpleLeft.newGreaterThan(simpleRight);
145     }
146     return result;
147   }
148
149
150   /**
151    * Resuelve si el valor de una expresión simplificada es Menor o Igual que el valor simplificado de la otra
152    * @param expression
153    * @return
154    */

155   public Object JavaDoc processLessOrEqualTo(LessOrEqualTo expression) {
156     Expression simpleLeft;
157     Expression simpleRight;
158     boolean value;
159     Expression result;
160
161     simpleLeft = (Expression) visit(expression.getLeft());
162     simpleRight = (Expression) visit(expression.getRight());
163
164     if (simpleLeft.isConstant() && simpleRight.isConstant()) {
165       //int comparisson = ((ConstantExp) simpleLeft).value.toString().compareTo(((ConstantExp) simpleRight).value.toString());
166
int comparisson = compare(((ConstantExp) simpleLeft).value, ((ConstantExp) simpleRight).value);
167       value = comparisson <= 0;
168       //value = true; //((ConstantExp) simpleLeft).value < ((ConstantExp) simpleRight).value;
169
result = ConstantExp.forValue(new Boolean JavaDoc(value));
170     }
171     else {
172       result = simpleLeft.newLessOrEquealTo(simpleRight);
173     }
174     return result;
175   }
176
177   /**
178    * Resuelve si el valor de una expresión simplificada es Menor que el valor simplificado de la otra
179    * @param expression
180    * @return
181    */

182   public Object JavaDoc processLessThan(LessThan expression) {
183     Expression simpleLeft;
184     Expression simpleRight;
185     boolean value;
186     Expression result;
187
188     simpleLeft = (Expression) visit(expression.getLeft());
189     simpleRight = (Expression) visit(expression.getRight());
190
191     if (simpleLeft.isConstant() && simpleRight.isConstant()) {
192       //int comparisson = ((ConstantExp) simpleLeft).value.toString().compareTo(((ConstantExp) simpleRight).value.toString());
193
int comparisson = compare(((ConstantExp) simpleLeft).value, ((ConstantExp) simpleRight).value);
194       value = comparisson < 0;
195       //value = true; //((ConstantExp) simpleLeft).value <= ((ConstantExp) simpleRight).value;
196
result = ConstantExp.forValue(new Boolean JavaDoc(value));
197     }
198     else {
199       result = simpleLeft.newLessThan(simpleRight);
200     }
201     return result;
202   }
203
204
205   /**
206    * Resuelve el operador NOT sobre el valor resultante de simplificar la subexpresión
207    * @param expression
208    * @return
209    */

210   public Object JavaDoc processNot(NotExp expression) {
211     return ((Expression) visit(expression.internalExp())).newNot();
212   }
213
214
215   /**
216    * Resuelve el operador OR simplificando las subexpresiones
217    * @param expression
218    * @return
219    */

220   public Object JavaDoc processOr(OrExp expression) {
221     return ((Expression) visit(expression.getLeft())).newOr((Expression) visit(expression.getRight()));
222   }
223
224
225   /**
226    * Si el valor de referencia de la expresión variable se encuentra en el contexto, reemplaza esta expresión
227    * por una expresión constante con el valor correspondiente
228    * @param expression
229    * @return
230    */

231   public Object JavaDoc processVariable(VariableExp expression) {
232     Object JavaDoc value;
233
234     value = context.valueFor(expression.reference);
235     if (value == null) {
236       return expression;
237     }
238     return ConstantExp.forValue(value);
239   }
240
241
242   /**
243    * Resuelve el operador Includes simplificando las subexpresiones
244    * @param expression
245    * @return
246    */

247   public Object JavaDoc processIncludes(IncludesExp expression) {
248     Expression simpleLeft;
249     Expression simpleRight;
250     boolean value;
251     Expression result;
252     String JavaDoc string;
253     String JavaDoc regExp;
254
255     simpleLeft = (Expression) visit(expression.getLeft());
256     simpleRight = (Expression) visit(expression.getRight());
257
258     if (simpleLeft.isConstant() && simpleRight.isConstant()) {
259       regExp = (String JavaDoc) ((ConstantExp) simpleRight).value;
260       string = (String JavaDoc) ((ConstantExp) simpleLeft).value;
261       value = string.indexOf(regExp) != -1;
262       result = ConstantExp.forValue(new Boolean JavaDoc(value));
263     }
264     else {
265       result = simpleLeft.newIncludes(simpleRight);
266     }
267     return result;
268   }
269
270
271   /**
272    * Resuelve el operador beginsWith simplificando las subexpresiones
273    * @param expression
274    * @return
275    */

276   public Object JavaDoc processBeginsWith(BeginsWithExp expression) {
277     Expression simpleLeft;
278     Expression simpleRight;
279     boolean value;
280     Expression result;
281     String JavaDoc string;
282     String JavaDoc prefix;
283
284     simpleLeft = (Expression) visit(expression.getLeft());
285     simpleRight = (Expression) visit(expression.getRight());
286
287     if (simpleLeft.isConstant() && simpleRight.isConstant()) {
288       prefix = (String JavaDoc) ((ConstantExp) simpleRight).value;
289       string = (String JavaDoc) ((ConstantExp) simpleLeft).value;
290       value = string.startsWith(prefix);
291       result = ConstantExp.forValue(new Boolean JavaDoc(value));
292     }
293     else {
294       result = simpleLeft.newBeginsWith(simpleRight);
295     }
296     return result;
297   }
298
299   /**
300    * Resuelve el operador endsWith simplificando las subexpresiones*
301    * @param expression
302    * @return
303    */

304   public Object JavaDoc processEndsWith(EndsWithExp expression) {
305     Expression simpleLeft;
306     Expression simpleRight;
307     boolean value;
308     Expression result;
309     String JavaDoc string;
310     String JavaDoc suffix;
311
312     simpleLeft = (Expression) visit(expression.getLeft());
313     simpleRight = (Expression) visit(expression.getRight());
314
315     if (simpleLeft.isConstant() && simpleRight.isConstant()) {
316       suffix = (String JavaDoc) ((ConstantExp) simpleRight).value;
317       string = (String JavaDoc) ((ConstantExp) simpleLeft).value;
318       value = string.endsWith(suffix);
319       result = ConstantExp.forValue(new Boolean JavaDoc(value));
320     }
321     else {
322       result = simpleLeft.newEndsWith(simpleRight);
323     }
324     return result;
325   }
326
327   /**
328    * Método por el que se inicia la simplificación de la "super" expresión en base a un contexto
329    * @param expression
330    * @param aContext
331    * @return
332    */

333   public Object JavaDoc simplifyIn(Expression expression, Context aContext) {
334     context = aContext;
335     return visit(expression);
336   }
337
338   /**
339    * Resuelve el operador In evaluando sus valores
340    * @param inExp
341    * @return
342    */

343   public Object JavaDoc processIn(InExp inExp){
344     Collection values = inExp.getValues();
345     if(values == null || values.isEmpty()){
346       return new TrueExp();
347     }
348     Expression simple = (Expression) visit(inExp.getArgument());
349     if(simple.isConstant()){
350       return ConstantExp.forValue(new Boolean JavaDoc(inExp.getValues().contains(((ConstantExp)simple).getValue())));
351     }
352     return inExp;
353   }
354
355 }
Popular Tags