001: package com.calipso.reportgenerator.reportcalculator;
002:
003: import com.calipso.reportgenerator.reportcalculator.CubeFilter;
004: import com.calipso.reportgenerator.common.LanguageTraslator;
005: import com.calipso.common.DateEx;
006:
007: import java.util.*;
008: import java.text.SimpleDateFormat;
009: import java.text.DateFormat;
010: import java.text.ParseException;
011:
012: /**
013: * Filtro que evalúa si el valor de las dimensiones se encuentra en una lista de valores asociada
014: */
015: public class EnumerationCubeFilter extends CubeFilter {
016: private boolean including;
017: private HashMap valuesByDimension;
018:
019: /**
020: * Crea un nuevo filtro de enumeración inicializando la lista de valores
021: */
022: public EnumerationCubeFilter() {
023: valuesByDimension = new HashMap();
024: }
025:
026: /**
027: * Devuelve si el filtro debe devolver TRUE cuando el valor ESTÁ incluido o no
028: * @return
029: */
030: public boolean getIncluding() {
031: return including;
032: }
033:
034: /**
035: * Asigna si el filtro debe devolver TRUE cuando el valor ESTÁ incluido o no
036: * @param including
037: */
038:
039: public void setIncluding(boolean including) {
040: this .including = including;
041: }
042:
043: /**
044: * Crea un nuevo filtro de enumeración que devuelve verdadero si un valor no está incluido en la lista de valores
045: * @return
046: */
047: public static EnumerationCubeFilter excluding() {
048: EnumerationCubeFilter newCube;
049:
050: newCube = new EnumerationCubeFilter();
051: newCube.setIncluding(false);
052: return newCube;
053: }
054:
055: /**
056: * Crea un nuevo filtro de enumeración que devuelve verdadero si un valor está incluido en la lista de valores
057: * @return
058: */
059: public static EnumerationCubeFilter including() {
060: EnumerationCubeFilter newCube;
061:
062: newCube = new EnumerationCubeFilter();
063: newCube.setIncluding(true);
064: return newCube;
065: }
066:
067: /**
068: * Resuelve la evaluación del filtro
069: * @return
070: */
071: public boolean matches(Object[] row) {
072: if (including) {
073: return induclingMatches(row);
074: } else {
075: return excludingMatches(row);
076: }
077: }
078:
079: /**
080: * Evalua el filtro sobre row excluyendo los valores
081: * @param row
082: * @return
083: */
084: private boolean excludingMatches(Object[] row) {
085: Set entrySet;
086: Map.Entry entry;
087: Iterator iterator;
088: Set values;
089: Object value;
090:
091: entrySet = valuesByDimension.entrySet();
092: iterator = entrySet.iterator();
093: while (iterator.hasNext()) {
094: entry = (Map.Entry) iterator.next();
095: values = (Set) entry.getValue();
096: int index = ((Integer) entry.getKey()).intValue();
097: value = row[index];
098: if (contains(values, value)) {
099: return false;
100: }
101: }
102: return true;
103: }
104:
105: /**
106: * Evalua el filtro sobre row incluyendo los valores
107: * @param row
108: * @return
109: */
110: private boolean induclingMatches(Object[] row) {
111: Set entrySet;
112: Map.Entry entry;
113: Iterator iterator;
114: Set values;
115: Object value;
116:
117: entrySet = valuesByDimension.entrySet();
118: iterator = entrySet.iterator();
119: while (iterator.hasNext()) {
120: entry = (Map.Entry) iterator.next();
121: values = (Set) entry.getValue();
122: if (!values.isEmpty()) {
123: int index = ((Integer) entry.getKey()).intValue();
124: value = row[index];
125: if (!contains(values, value)) {
126: return false;
127: }
128: }
129: }
130: return true;
131: }
132:
133: private boolean contains(Set values, Object value) {
134: if (value instanceof SharedDate) {
135: Iterator iter = values.iterator();
136: while (iter.hasNext()) {
137: Date date = null;
138: Object o = iter.next();
139: if (!(o instanceof Date)) {
140: //DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
141: DateFormat dateFormat = SimpleDateFormat
142: .getDateInstance(DateFormat.SHORT,
143: LanguageTraslator.getLocale());
144: try {
145: date = dateFormat.parse(o.toString());
146: } catch (ParseException 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(
151: date));
152: if (sharedDate.compareTo(value) == 0)
153: return true;
154: } else {
155: date = (Date) o;
156: SharedDate sharedDate = new SharedDate(new DateEx(
157: date));
158: if (sharedDate.compareTo(value) == 0)
159: return true;
160: }
161: }
162: } else {
163: return values.contains(value);
164: }
165: return false;
166: }
167:
168: /**
169: * Agrega los valores para una dimensión
170: * @param measures
171: * @param dimension
172: */
173: public void addTo(Set measures, int dimension) {
174: valuesByDimension.put(new Integer(dimension), measures);
175: }
176:
177: /**
178: * Resuelve la representación en texto
179: * @return
180: */
181: public String toString() {
182: return "";
183: }
184:
185: /**
186: * Resuelve el texto de consulta Oql (inicialmente este tipo de filtro no se utiliza para consultas Oql)
187: * @return
188: */
189: public String getOqlText() {
190: return "";
191: }
192:
193: public boolean equals(Object obj) {
194: if (obj instanceof EnumerationCubeFilter) {
195: EnumerationCubeFilter filter = (EnumerationCubeFilter) obj;
196: return (including == filter.including)
197: && sameFilter(valuesByDimension,
198: filter.valuesByDimension);
199: }
200: return false;
201: }
202:
203: private boolean sameFilter(HashMap valuesByDimension,
204: HashMap valuesByDimension1) {
205: if (valuesByDimension.size() != valuesByDimension1.size())
206: return false;
207: Iterator iter = valuesByDimension.keySet().iterator();
208: while (iter.hasNext()) {
209: Integer key = (Integer) iter.next();
210: Set values = (Set) valuesByDimension.get(key);
211: Set values1 = (Set) valuesByDimension1.get(key);
212: if (!sameValues(values, values1))
213: return false;
214: }
215: return true;
216: }
217:
218: private boolean sameValues(Set values, Set values1) {
219: if ((values == null) && (values1 == null)) {
220: return true;
221: } else if (values == null) {
222: return false;
223: } else if (values1 == null) {
224: return false;
225: } else if (values.size() != values1.size())
226: return false;
227: if (values.size() == 0 && values1.size() == 0)
228: return true;
229: Iterator valuesIt = values.iterator();
230: Iterator values1It = values1.iterator();
231: while (valuesIt.hasNext()) {
232: Object o1 = valuesIt.next();
233: Object o2 = values1It.next();
234: if (o1.equals(o2)) {
235: return false;
236: }
237: // if((o1 instanceof SharedString && o2 instanceof SharedString) || o2 instanceof String) {
238: // if(!(((SharedString)o1).value().equals(((SharedString)o2).value()))) {
239: // return false;
240: // }
241: // }
242: }
243: return true;
244: }
245:
246: public boolean containsValue(int dimension, Object value) {
247: Collection values = ((Collection) valuesByDimension
248: .get(new Integer(dimension)));
249: if (values != null) {
250: return values.contains(value);
251: }
252: return false;
253: }
254:
255: public boolean hasDimension(int dimension) {
256: return valuesByDimension.containsKey(new Integer(dimension));
257: }
258:
259: public Iterator getDimensionValuesIterator() {
260: return valuesByDimension.entrySet().iterator();
261: }
262:
263: public boolean isEmpty() {
264: if (valuesByDimension.isEmpty()) {
265: return true;
266: } else {
267: for (Iterator iterator = valuesByDimension.values()
268: .iterator(); iterator.hasNext();) {
269: Collection collection = (Collection) iterator.next();
270: if (!collection.isEmpty()) {
271: return false;
272: }
273: }
274: return true;
275: }
276: }
277: }
|