001: package com.calipso.reportgenerator.reportcalculator.expression;
002:
003: import java.util.HashSet;
004: import java.util.Iterator;
005: import java.util.Set;
006: import java.io.Serializable;
007:
008: /**
009: * Representa una expresión booleana.
010: * Cachea las variables que integra y tiene constructores
011: * especiales para cada una de sus subclases
012: */
013:
014: public class Expression implements Serializable {
015: Expression[] arguments;
016: Set referencesCache;
017:
018: protected void initialize() {
019: }
020:
021: /**
022: * Resuelve la igualdad entre expresiones
023: * @param o
024: * @return
025: */
026: public boolean equals(Object o) {
027: if (this == o)
028: return true;
029: if (!(o instanceof Expression))
030: return false;
031:
032: final Expression expression = (Expression) o;
033:
034: if (referencesCache != null ? !referencesCache
035: .equals(expression.referencesCache)
036: : expression.referencesCache != null)
037: return false;
038:
039: return true;
040: }
041:
042: /**
043: * Genera un código hash para la expresión
044: * @return
045: */
046: public int hashCode() {
047: return (referencesCache != null ? referencesCache.hashCode()
048: : 0);
049: }
050:
051: /**
052: * Devuelve los argumentos de la expresión
053: * @return
054: */
055: public Expression[] getArguments() {
056: return arguments;
057: }
058:
059: /**
060: * Especifica los argumentos de la expresión e invalida el cache de referencias
061: * @param arguments
062: */
063: public void setArguments(Expression[] arguments) {
064: invalidateCache();
065: this .arguments = arguments;
066: }
067:
068: /**
069: * Invalida el cache de referencias
070: */
071: private void invalidateCache() {
072: referencesCache = null;
073: }
074:
075: /**
076: * Llena el cache de referencias con las variables de todas las subexpresiones
077: * Devuelve un Set con Expresiones de tipo Variable para todas las variables de las
078: * sub expresiones
079: * @see VariableExp
080: * @return
081: */
082: public Set references() {
083: Iterator iterator;
084:
085: if (referencesCache == null) {
086: referencesCache = new HashSet();
087: iterator = variables().iterator();
088: while (iterator.hasNext()) {
089: referencesCache.add(((VariableExp) iterator.next())
090: .getReference());
091: }
092: }
093: return referencesCache;
094: }
095:
096: /**
097: * Devuelve las expresiones tipo Variable de todas las subexpresiones
098: * @return
099: */
100: protected Set variables() {
101: Set variablesCache;
102:
103: variablesCache = new HashSet();
104: for (int i = 0; i < arguments.length; i++) {
105: variablesCache.addAll(arguments[i].variables());
106: }
107: return variablesCache;
108: }
109:
110: /**
111: * Asigna un Set que contiene las referencias
112: * @param referencesCache
113: */
114: public void setReferencesCache(Set referencesCache) {
115: this .referencesCache = referencesCache;
116: }
117:
118: /**
119: * Crea una nueva expresión con la siguiente forma: this AND expresion
120: * @param expression
121: * @return
122: */
123:
124: public Expression newAnd(Expression expression) {
125: return expression.basicAnd(this );
126: }
127:
128: /**
129: * Crea una nueva expresión con la siguiente forma: this OR expression
130: * @param expression
131: * @return
132: */
133: public Expression newOr(Expression expression) {
134: return expression.basicOr(this );
135: }
136:
137: /**
138: * * Crea una expresión con la siguiente forma: this < expression
139: * @param expression
140: * @return
141: */
142:
143: public Expression newLessThan(Expression expression) {
144: return new LessThan(this , expression);
145: }
146:
147: /**
148: * Crea una expresión con la siguiente forma: this <= expression
149: * @param expression
150: * @return
151: */
152: public Expression newLessOrEquealTo(Expression expression) {
153: return new LessOrEqualTo(this , expression);
154: }
155:
156: /**
157: * Crea una expresión con la siguiente forma: this = expression
158: * @param expression
159: * @return
160: */
161: public Expression newEqualTo(Expression expression) {
162: return new EqualTo(this , expression);
163: }
164:
165: /**
166: * Crea una expresión con la siguiente forma: this > expression
167: * @param expression
168: * @return
169: */
170:
171: public Expression newGreaterThan(Expression expression) {
172: return new GreaterThan(this , expression);
173: }
174:
175: /**
176: * Crea una expresión con la siguiente forma: this >= expression
177: * @param expression
178: * @return
179: */
180:
181: public Expression newGreaterOrEqualTo(Expression expression) {
182: return new GreaterOrEqualTo(this , expression);
183: }
184:
185: /**
186: * Crea una nueva expresión negando la que se recibe como parámetro: NOT expresion
187: * @return
188: */
189: public Expression newNot() {
190: return new NotExp(this );
191: }
192:
193: /**
194: * Crea una nueva expresión con la siguiente forma: this COMIENZA_CON expression
195: * se utiliza para valores String
196: * @param expression
197: * @return
198: */
199: public Expression newBeginsWith(Expression expression) {
200: return new BeginsWithExp(this , expression);
201: }
202:
203: /**
204: * Crea una expresión con la siguiente forma: this TERMINA_CON expression
205: * se utiliza para valores String
206: * @param expression
207: * @return
208: */
209: public Expression newEndsWith(Expression expression) {
210: return new EndsWithExp(this , expression);
211: }
212:
213: /**
214: * Crea una expresión con la siguiente forma: this INCLUYE expression
215: * se utiliza para valores String
216: * @param expression
217: * @return
218: */
219: public Expression newIncludes(Expression expression) {
220: return new IncludesExp(this , expression);
221: }
222:
223: /**
224: * Resuelve la creación de la expresión AND
225: * @param expression
226: * @return
227: */
228: protected Expression basicAnd(Expression expression) {
229: return new AndExp(expression, this );
230: }
231:
232: /**
233: * Resuelve la creación de la expresión OR
234: * @param expression
235: * @return
236: */
237: protected Expression basicOr(Expression expression) {
238: return new OrExp(expression, this );
239: }
240:
241: /**
242: * Devuelve un texto que representa a la expresión (y todas sus subexpresiones)
243: * @return
244: */
245: public String toString() {
246: return basicAsString();
247: }
248:
249: /**
250: * Se utiliza para resolver las particularidades de la expresión AND en la representación de texto
251: * como ser, agregar paréntesis, etc
252: * @return
253: */
254: protected String asStringUnderAnd() {
255: return basicAsString();
256: }
257:
258: /**
259: * Se utiliza para resolver las particularidades de la expresión OR en la representación de texto
260: * como ser, agregar parentesis, etc
261: */
262: protected String asStringUnderOr() {
263: return basicAsString();
264: }
265:
266: /**
267: * Se utiliza para resolver las particularidades de la expresión NOT en la representación de texto
268: * como ser, agregar paréntesis, etc
269: */
270: protected String asStringUnderNot() {
271: return basicAsString();
272: }
273:
274: /**
275: * Método que sobreescriben las subclases para resolver la representación en texto
276: * @return
277: */
278:
279: protected String basicAsString() {
280: return "";
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: * Determina si la expresión es una constante (la expresión fue simplificada y se obtuvo un valor concreto)
295: * @return
296: */
297: public boolean isConstant() {
298: return false;
299: }
300:
301: /**
302: * Determina si la expresión es una constante con valor FALSE
303: * @return
304: */
305: public boolean isFalse() {
306: return false;
307: }
308:
309: /**
310: * Determina si la expresión es una Magnitud que puede utilizarse en expresiones del tipo LessThan, GreaterThan, etc
311: * @return
312: */
313: public boolean isMagnitude() {
314: return false;
315: }
316:
317: /**
318: * Determina si la expresión es una constante con valor TRUE
319: * @return
320: */
321: public boolean isTrue() {
322: return false;
323: }
324:
325: /**
326: * Determina si la expresión representa una variable (que será reemplazada por un valor cuando se evalue en un contexto)
327: * @return
328: */
329: public boolean isVariable() {
330: return false;
331: }
332:
333: /**
334: * Devuelve una expresión simplificada reemplazando las Variables con los valores correspondientes que se reciben
335: * del contexto
336: * @param context
337: * @return
338: */
339: public Expression simplifiedIn(Context context) {
340: return (Expression) ((new ExpressionSimplifier()).simplifyIn(
341: 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: }
|