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


1 package com.calipso.reportgenerator.reportcalculator.expression;
2
3 import java.util.HashSet ;
4 import java.util.Iterator ;
5 import java.util.Set ;
6 import java.io.Serializable ;
7
8 /**
9  * Representa una expresión booleana.
10  * Cachea las variables que integra y tiene constructores
11  * especiales para cada una de sus subclases
12  */
13
14 public class Expression implements Serializable {
15   Expression[] arguments;
16   Set referencesCache;
17
18   protected void initialize() {
19   }
20
21   /**
22    * Resuelve la igualdad entre expresiones
23    * @param o
24    * @return
25    */
26   public boolean equals(Object o) {
27     if (this == o) return true;
28     if (!(o instanceof Expression)) return false;
29
30     final Expression expression = (Expression) o;
31
32     if (referencesCache != null ? !referencesCache.equals(expression.referencesCache) : expression.referencesCache != null) return false;
33
34     return true;
35   }
36
37   /**
38    * Genera un código hash para la expresión
39    * @return
40    */
41   public int hashCode() {
42     return (referencesCache != null ? referencesCache.hashCode() : 0);
43   }
44
45   /**
46    * Devuelve los argumentos de la expresión
47    * @return
48    */
49   public Expression[] getArguments() {
50     return arguments;
51   }
52
53   /**
54    * Especifica los argumentos de la expresión e invalida el cache de referencias
55    * @param arguments
56    */
57   public void setArguments(Expression[] arguments) {
58     invalidateCache();
59     this.arguments = arguments;
60   }
61
62   /**
63    * Invalida el cache de referencias
64    */
65   private void invalidateCache() {
66     referencesCache = null;
67   }
68
69   /**
70    * Llena el cache de referencias con las variables de todas las subexpresiones
71    * Devuelve un Set con Expresiones de tipo Variable para todas las variables de las
72    * sub expresiones
73    * @see VariableExp
74    * @return
75    */
76   public Set references() {
77     Iterator iterator;
78
79     if (referencesCache == null) {
80       referencesCache = new HashSet ();
81       iterator = variables().iterator();
82       while (iterator.hasNext()) {
83         referencesCache.add(((VariableExp) iterator.next()).getReference());
84       }
85     }
86     return referencesCache;
87   }
88
89   /**
90    * Devuelve las expresiones tipo Variable de todas las subexpresiones
91    * @return
92    */
93   protected Set variables() {
94     Set variablesCache;
95
96     variablesCache = new HashSet ();
97     for (int i = 0; i < arguments.length; i++) {
98       variablesCache.addAll(arguments[i].variables());
99     }
100     return variablesCache;
101   }
102
103   /**
104    * Asigna un Set que contiene las referencias
105    * @param referencesCache
106    */
107   public void setReferencesCache(Set referencesCache) {
108     this.referencesCache = referencesCache;
109   }
110
111   /**
112    * Crea una nueva expresión con la siguiente forma: this AND expresion
113    * @param expression
114    * @return
115    */
116
117   public Expression newAnd(Expression expression) {
118     return expression.basicAnd(this);
119   }
120
121   /**
122    * Crea una nueva expresión con la siguiente forma: this OR expression
123    * @param expression
124    * @return
125    */
126   public Expression newOr(Expression expression) {
127     return expression.basicOr(this);
128   }
129
130
131   /**
132    * * Crea una expresión con la siguiente forma: this < expression
133    * @param expression
134    * @return
135    */
136
137   public Expression newLessThan(Expression expression) {
138     return new LessThan(this, expression);
139   }
140
141
142   /**
143    * Crea una expresión con la siguiente forma: this <= expression
144    * @param expression
145    * @return
146    */
147   public Expression newLessOrEquealTo(Expression expression) {
148     return new LessOrEqualTo(this, expression);
149   }
150
151
152   /**
153    * Crea una expresión con la siguiente forma: this = expression
154    * @param expression
155    * @return
156    */
157   public Expression newEqualTo(Expression expression) {
158     return new EqualTo(this, expression);
159   }
160
161   /**
162    * Crea una expresión con la siguiente forma: this > expression
163    * @param expression
164    * @return
165    */
166
167   public Expression newGreaterThan(Expression expression) {
168     return new GreaterThan(this, expression);
169   }
170
171   /**
172    * Crea una expresión con la siguiente forma: this >= expression
173    * @param expression
174    * @return
175    */
176
177   public Expression newGreaterOrEqualTo(Expression expression) {
178     return new GreaterOrEqualTo(this, expression);
179   }
180
181
182   /**
183    * Crea una nueva expresión negando la que se recibe como parámetro: NOT expresion
184    * @return
185    */
186   public Expression newNot() {
187     return new NotExp(this);
188   }
189
190   /**
191    * Crea una nueva expresión con la siguiente forma: this COMIENZA_CON expression
192    * se utiliza para valores String
193    * @param expression
194    * @return
195    */
196   public Expression newBeginsWith(Expression expression) {
197     return new BeginsWithExp(this, expression);
198   }
199
200   /**
201    * Crea una expresión con la siguiente forma: this TERMINA_CON expression
202    * se utiliza para valores String
203    * @param expression
204    * @return
205    */
206   public Expression newEndsWith(Expression expression) {
207     return new EndsWithExp(this, expression);
208   }
209
210   /**
211    * Crea una expresión con la siguiente forma: this INCLUYE expression
212    * se utiliza para valores String
213    * @param expression
214    * @return
215    */
216   public Expression newIncludes(Expression expression) {
217     return new IncludesExp(this, expression);
218   }
219
220   /**
221    * Resuelve la creación de la expresión AND
222    * @param expression
223    * @return
224    */
225   protected Expression basicAnd(Expression expression) {
226     return new AndExp(expression, this);
227   }
228
229
230   /**
231    * Resuelve la creación de la expresión OR
232    * @param expression
233    * @return
234    */
235   protected Expression basicOr(Expression expression) {
236     return new OrExp(expression, this);
237   }
238
239
240   /**
241    * Devuelve un texto que representa a la expresión (y todas sus subexpresiones)
242    * @return
243    */
244   public String toString() {
245     return basicAsString();
246   }
247
248   /**
249    * Se utiliza para resolver las particularidades de la expresión AND en la representación de texto
250    * como ser, agregar paréntesis, etc
251    * @return
252    */
253   protected String asStringUnderAnd() {
254     return basicAsString();
255   }
256
257   /**
258    * Se utiliza para resolver las particularidades de la expresión OR en la representación de texto
259    * como ser, agregar parentesis, etc
260    */
261   protected String asStringUnderOr() {
262     return basicAsString();
263   }
264
265   /**
266    * Se utiliza para resolver las particularidades de la expresión NOT en la representación de texto
267    * como ser, agregar paréntesis, etc
268    */
269   protected String asStringUnderNot() {
270     return basicAsString();
271   }
272
273   /**
274    * Método que sobreescriben las subclases para resolver la representación en texto
275    * @return
276    */
277
278   protected String basicAsString() {
279     return "";
280   }
281
282
283   /**
284    * Método necesario para la implementación del pattern Visitor que se utiliza para la simplificación de las expresiones
285    * @see ExpressionSimplifier
286    * @param visitor
287    * @return
288    */
289   public Object visitedBy(ExpressionVisitor visitor) {
290     return null;
291   }
292
293
294   /**
295    * Determina si la expresión es una constante (la expresión fue simplificada y se obtuvo un valor concreto)
296    * @return
297    */
298   public boolean isConstant() {
299     return false;
300   }
301
302   /**
303    * Determina si la expresión es una constante con valor FALSE
304    * @return
305    */
306   public boolean isFalse() {
307     return false;
308   }
309
310   /**
311    * Determina si la expresión es una Magnitud que puede utilizarse en expresiones del tipo LessThan, GreaterThan, etc
312    * @return
313    */
314   public boolean isMagnitude() {
315     return false;
316   }
317
318   /**
319    * Determina si la expresión es una constante con valor TRUE
320    * @return
321    */
322   public boolean isTrue() {
323     return false;
324   }
325
326   /**
327    * Determina si la expresión representa una variable (que será reemplazada por un valor cuando se evalue en un contexto)
328    * @return
329    */
330   public boolean isVariable() {
331     return false;
332   }
333
334   /**
335    * Devuelve una expresión simplificada reemplazando las Variables con los valores correspondientes que se reciben
336    * del contexto
337    * @param context
338    * @return
339    */
340   public Expression simplifiedIn(Context context) {
341     return (Expression) ((new ExpressionSimplifier()).simplifyIn(this, context));
342   }
343
344   /**
345    * Devuelve un valor boolean como resultado de la evaluación de la expresión con los valores del contexto
346    * Si el contexto no contiene valores para todas las variables y no se puede completar la simplificación
347    * el resultado es FALSE
348    * @param context
349    * @return
350    */
351   public boolean valueIn(Context context) {
352     return simplifiedIn(context).isTrue();
353   }
354 }

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags