KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > calipso > reportgenerator > reportcalculator > EnumerationCubeFilter


1 package com.calipso.reportgenerator.reportcalculator;
2
3 import com.calipso.reportgenerator.reportcalculator.CubeFilter;
4 import com.calipso.reportgenerator.common.LanguageTraslator;
5 import com.calipso.common.DateEx;
6
7 import java.util.*;
8 import java.text.SimpleDateFormat JavaDoc;
9 import java.text.DateFormat JavaDoc;
10 import java.text.ParseException JavaDoc;
11
12 /**
13  * Filtro que evalúa si el valor de las dimensiones se encuentra en una lista de valores asociada
14  */

15 public class EnumerationCubeFilter extends CubeFilter {
16   private boolean including;
17   private HashMap valuesByDimension;
18
19   /**
20    * Crea un nuevo filtro de enumeración inicializando la lista de valores
21    */

22   public EnumerationCubeFilter() {
23     valuesByDimension = new HashMap();
24   }
25
26   /**
27    * Devuelve si el filtro debe devolver TRUE cuando el valor ESTÁ incluido o no
28    * @return
29    */

30   public boolean getIncluding() {
31     return including;
32   }
33
34   /**
35    * Asigna si el filtro debe devolver TRUE cuando el valor ESTÁ incluido o no
36    * @param including
37    */

38
39   public void setIncluding(boolean including) {
40     this.including = including;
41   }
42
43   /**
44    * Crea un nuevo filtro de enumeración que devuelve verdadero si un valor no está incluido en la lista de valores
45    * @return
46    */

47   public static EnumerationCubeFilter excluding() {
48     EnumerationCubeFilter newCube;
49
50     newCube = new EnumerationCubeFilter();
51     newCube.setIncluding(false);
52     return newCube;
53   }
54
55   /**
56    * Crea un nuevo filtro de enumeración que devuelve verdadero si un valor está incluido en la lista de valores
57    * @return
58    */

59   public static EnumerationCubeFilter including() {
60     EnumerationCubeFilter newCube;
61
62     newCube = new EnumerationCubeFilter();
63     newCube.setIncluding(true);
64     return newCube;
65   }
66
67
68   /**
69    * Resuelve la evaluación del filtro
70    * @return
71    */

72   public boolean matches(Object JavaDoc[] row) {
73     if (including) {
74       return induclingMatches(row);
75     }
76     else {
77       return excludingMatches(row);
78     }
79   }
80
81   /**
82    * Evalua el filtro sobre row excluyendo los valores
83    * @param row
84    * @return
85    */

86   private boolean excludingMatches(Object JavaDoc[] row) {
87     Set entrySet;
88     Map.Entry entry;
89     Iterator iterator;
90     Set values;
91     Object JavaDoc value;
92
93     entrySet = valuesByDimension.entrySet();
94     iterator = entrySet.iterator();
95     while (iterator.hasNext()) {
96       entry = (Map.Entry) iterator.next();
97       values = (Set) entry.getValue();
98       int index = ((Integer JavaDoc) entry.getKey()).intValue();
99       value = row[index];
100       if(contains(values, value)){
101         return false;
102       }
103     }
104     return true;
105   }
106
107   /**
108    * Evalua el filtro sobre row incluyendo los valores
109    * @param row
110    * @return
111    */

112   private boolean induclingMatches(Object JavaDoc[] row) {
113     Set entrySet;
114     Map.Entry entry;
115     Iterator iterator;
116     Set values;
117     Object JavaDoc value;
118
119     entrySet = valuesByDimension.entrySet();
120     iterator = entrySet.iterator();
121     while (iterator.hasNext()) {
122       entry = (Map.Entry) iterator.next();
123       values = (Set) entry.getValue();
124       if(!values.isEmpty()){
125         int index = ((Integer JavaDoc) entry.getKey()).intValue();
126         value = row[index];
127         if(!contains(values, value)){
128           return false;
129         }
130       }
131     }
132     return true;
133   }
134
135   private boolean contains(Set values, Object JavaDoc value) {
136     if (value instanceof SharedDate) {
137       Iterator iter = values.iterator();
138       while (iter.hasNext()) {
139         Date date = null;
140         Object JavaDoc o = iter.next();
141         if (!(o instanceof Date)) {
142           //DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
143
DateFormat JavaDoc dateFormat = SimpleDateFormat.getDateInstance(DateFormat.SHORT, LanguageTraslator.getLocale());
144           try {
145             date = dateFormat.parse(o.toString());
146           } catch (ParseException JavaDoc e) {
147             //Esta excepcion no debería ocurrir, porque se estan utilizando dos objetos de la aplicacion
148
e.printStackTrace();
149           }
150           SharedDate sharedDate = new SharedDate(new DateEx(date));
151           if (sharedDate.compareTo(value) == 0) return true;
152         }
153         else {
154           date = (Date) o;
155           SharedDate sharedDate = new SharedDate(new DateEx(date));
156           if (sharedDate.compareTo(value) == 0) return true;
157         }
158       }
159     }
160     else {
161       return values.contains(value);
162     }
163     return false;
164   }
165
166   /**
167    * Agrega los valores para una dimensión
168    * @param measures
169    * @param dimension
170    */

171   public void addTo(Set measures, int dimension) {
172     valuesByDimension.put(new Integer JavaDoc(dimension), measures);
173   }
174
175   /**
176    * Resuelve la representación en texto
177    * @return
178    */

179   public String JavaDoc toString() {
180     return "";
181   }
182
183   /**
184    * Resuelve el texto de consulta Oql (inicialmente este tipo de filtro no se utiliza para consultas Oql)
185    * @return
186    */

187   public String JavaDoc getOqlText() {
188     return "";
189   }
190
191   public boolean equals(Object JavaDoc obj) {
192     if (obj instanceof EnumerationCubeFilter) {
193       EnumerationCubeFilter filter = (EnumerationCubeFilter) obj;
194       return (including == filter.including) && sameFilter(valuesByDimension, filter.valuesByDimension);
195     }
196     return false;
197   }
198
199   private boolean sameFilter(HashMap valuesByDimension, HashMap valuesByDimension1) {
200     if (valuesByDimension.size() != valuesByDimension1.size()) return false;
201     Iterator iter = valuesByDimension.keySet().iterator();
202     while (iter.hasNext()) {
203       Integer JavaDoc key = (Integer JavaDoc) iter.next();
204       Set values = (Set) valuesByDimension.get(key);
205       Set values1 = (Set) valuesByDimension1.get(key);
206       if (!sameValues(values, values1)) return false;
207     }
208     return true;
209   }
210
211   private boolean sameValues(Set values, Set values1) {
212     if ((values == null) && (values1 == null)) {
213       return true;
214     }
215     else
216       if (values == null) {
217         return false;
218       }
219       else
220         if (values1 == null) {
221           return false;
222         }
223         else
224           if (values.size() != values1.size()) return false;
225     if (values.size() == 0 && values1.size() == 0) return true;
226     Iterator valuesIt = values.iterator();
227     Iterator values1It = values1.iterator();
228     while (valuesIt.hasNext()) {
229       Object JavaDoc o1 = valuesIt.next();
230       Object JavaDoc o2 = values1It.next();
231       if (o1.equals(o2)) {
232         return false;
233       }
234 // if((o1 instanceof SharedString && o2 instanceof SharedString) || o2 instanceof String) {
235
// if(!(((SharedString)o1).value().equals(((SharedString)o2).value()))) {
236
// return false;
237
// }
238
// }
239
}
240     return true;
241   }
242
243   public boolean containsValue(int dimension,Object JavaDoc value){
244     Collection values = ((Collection)valuesByDimension.get(new Integer JavaDoc(dimension)));
245     if(values!=null){
246       return values.contains(value);
247     }
248     return false;
249   }
250
251   public boolean hasDimension(int dimension) {
252     return valuesByDimension.containsKey(new Integer JavaDoc(dimension));
253   }
254
255   public Iterator getDimensionValuesIterator() {
256     return valuesByDimension.entrySet().iterator();
257   }
258
259   public boolean isEmpty() {
260     if(valuesByDimension.isEmpty()){
261       return true;
262     }else{
263       for (Iterator iterator = valuesByDimension.values().iterator(); iterator.hasNext();) {
264         Collection collection = (Collection) iterator.next();
265         if(!collection.isEmpty()){
266           return false;
267         }
268       }
269       return true;
270     }
271   }
272 }
273
Popular Tags