Java > Open Source Codes > com > calipso > reportgenerator > common > ReportMetricSpec


1 package com.calipso.reportgenerator.common;
2
3 import com.calipso.reportgenerator.reportdefinitions.MetricSourceDefinition;
4 import com.calipso.reportgenerator.reportdefinitions.MetricDefinition;
5 import com.calipso.reportgenerator.reportdefinitions.types.CalculationType;
6 import com.calipso.reportgenerator.reportcalculator.arithmetic.ArithmeticExpression;
7 import com.calipso.reportgenerator.reportcalculator.SharedString;
8 import com.calipso.reportgenerator.reportcalculator.SharedFloat;
9 import com.calipso.reportgenerator.common.LanguageTraslator;
10 import com.calipso.reportgenerator.common.ReportFieldSpec;
11
12 import java.util.*;
13 import java.math.BigDecimal ;
14
15 /**
16  */
17 public class ReportMetricSpec extends ReportFieldSpec {
18
19   private boolean visible;
20   private CalculationType aggregateType;
21   private String aggregateFunction;
22   private String groupFooterFunction;
23   private CalculationType groupFooterType;
24   private ArithmeticExpression arithmeticExpression;
25   private Map variableIndexes;
26   private boolean accumulable;
27   private boolean externalCalculated;
28
29   /**
30    * Constructor de la super clase
31    * @param name
32    */
33   public ReportMetricSpec(String name) {
34     super(name);
35   }
36
37
38   /**
39    * Inicializa los valores de los atributos a partir de un MeticSourceDefinition
40    * @param metricSourceDefinition
41    * @param isMultilanguaje
42    * @param localization
43    */
44   public void fillFrom(MetricSourceDefinition metricSourceDefinition, boolean isMultilanguaje, Map localization) {
45     setCaption(resolveCaption(isMultilanguaje, localization, metricSourceDefinition.getDescription()));
46     setCalculated(metricSourceDefinition.getCalculated());
47     setExternalData(metricSourceDefinition.getExternalData());
48     setAggregateFunction(metricSourceDefinition.getAggregateFunction());
49     setAggregateType(metricSourceDefinition.getAggregateType());
50     setGroupFooterFunction(metricSourceDefinition.getGroupFooterFunction());
51     setGroupFooterType(metricSourceDefinition.getGroupFooterType());
52     setExternalCalculated(metricSourceDefinition.getExternalCalculated());
53     setInReportDefinition(true);
54   }
55
56   /**
57    * Inicializa los valores de los atributos a partir de un MetricDefinition
58    * @param metricDefinition
59    * @param isMultilanguaje
60    * @param localization
61    */
62   public void fillFrom(MetricDefinition metricDefinition, boolean isMultilanguaje, Map localization) {
63     if (metricDefinition.getDescription() != null && !("").equals(metricDefinition.getDescription())) {
64       setCaption(resolveCaption(isMultilanguaje, localization, metricDefinition.getDescription()));
65     }
66     setVisible(metricDefinition.getVisible());
67     setAccumulable(metricDefinition.getAccumulable());
68   }
69   /**
70    * Devuelve verdadero si debe existir una métrica de valores acumulados segun los valores de esta métrica
71    * Se utiliza en los reportes del tipo acumulado.
72    * @return accumulable
73    */
74   public boolean getAccumulable() {
75     return accumulable;
76   }
77
78   /**
79    * Especificaverdadero si debe existir una métrica de valores acumulados segun los valores de esta métrica
80    * @param accumulable
81    */
82   public void setAccumulable(boolean accumulable) {
83     this.accumulable = accumulable;
84   }
85
86   /**
87    * Devuelve verdadero si esta métrica debe aparecer visible en la consulta por defecto
88    * @return visible
89    */
90   public boolean getVisible() {
91     return visible;
92   }
93
94   /**
95    * Especifica si esta métrica debe aparecer visible en la consulta por defecto
96    * @param visible
97    */
98   public void setVisible(boolean visible) {
99     this.visible = visible;
100   }
101
102   /**
103    * Devuelve la función de agregación (por defecto sumatoria)
104    * @return función de agregación
105    */
106   public String getAggregateFunction() {
107     return aggregateFunction;
108   }
109
110   /**
111    * Asigna la función con la que se calculan los valores de las métricas calculadas
112     * @param aggregateFunction
113    */
114   public void setAggregateFunction(String aggregateFunction) {
115     this.aggregateFunction = aggregateFunction;
116   }
117
118
119   /**
120    *
121    * @return aggregateType
122    */
123   public CalculationType getAggregateType() {
124     return aggregateType;
125   }
126
127   public void setAggregateType(CalculationType aggregateType) {
128     this.aggregateType = aggregateType;
129   }
130
131   public String getGroupFooterFunction() {
132     return groupFooterFunction;
133   }
134
135   public void setGroupFooterFunction(String groupFooterFunction) {
136     this.groupFooterFunction = groupFooterFunction;
137   }
138
139   public CalculationType getGroupFooterType() {
140     return groupFooterType;
141   }
142
143   public void setGroupFooterType(CalculationType groupFooterType) {
144     this.groupFooterType = groupFooterType;
145   }
146
147   /**
148    * Devuelve verdadero si el valor de esta métrica debe ser calculado por proveedor externo del IDataSource
149    * @return externalCalculated
150    */
151   public boolean getExternalCalculated() {
152     return externalCalculated;
153   }
154
155   /**
156    * Especifica si el valor de esta métrica debe ser calculado por proveedor externo del IDataSource
157    * @param externalCalculated
158    */
159   private void setExternalCalculated(boolean externalCalculated) {
160     this.externalCalculated = externalCalculated;
161   }
162
163   /**
164    * Devuelve la expresión aritmética en base a la que se deben calcular los valores de la métrica calculada
165    * @return expresión aritmética
166    */
167   protected ArithmeticExpression getExpression() {
168     if (arithmeticExpression == null) {
169       arithmeticExpression = ArithmeticExpression.newFrom(getAggregateFunction());
170       variableIndexes = variableIndexesFrom(arithmeticExpression);
171     }
172     return arithmeticExpression;
173   }
174
175   /**
176    * Contiene los indices de la/las métricas que intercienen en la expresión de cálculo
177    * @return indices
178    */
179   public Map getVariableIndexes() {
180     return variableIndexes;
181   }
182
183   /**
184    * Resulve los indices de la/las métricas que intercienen en la expresión de cálculo
185    * @param arithmeticExpression
186    * @return indices
187    */
188   private Map variableIndexesFrom(ArithmeticExpression arithmeticExpression) {
189     Collection variables = new ArrayList();
190     arithmeticExpression.getVariables(variables);
191     Iterator iterator = variables.iterator();
192     Map indexes = new HashMap();
193     while (iterator.hasNext()) {
194       String variable = (String ) iterator.next();
195       indexes.put(variable, new Integer (getDataSourceIndexFromName(variable)));
196     }
197     return indexes;
198   }
199
200   /**
201    * Resuelve el valor de la métrica directamente del IDataSource en las métricas comunes y aplicando la expresion de cálculo
202    * en las métricas calculadas
203    * @param rowValues
204    * @return valor de la métrica
205    */
206   public Object getValue(Object [] rowValues) throws InfoException {
207     if (getCalculated()) {
208       Float aFloat = new Float (getExpression().value(getContext(rowValues)));
209       if ((aFloat.equals(new Float (Float.NaN))) || (aFloat.equals(new Float (Float.POSITIVE_INFINITY))) || (aFloat.equals(new Float (Float.NEGATIVE_INFINITY)))){
210         return null;
211       }else{
212         return SharedFloat.newFrom(aFloat);
213       }
214     }
215     else {
216       return floatFrom(rowValues[getReportSourceIndex()]);
217     }
218   }
219
220   public Float getValue(Map context){
221     return new Float (getExpression().value(context));
222   }
223
224   /**
225    * Devuelve el contexto con el que se evalúa la expresión del cálculo con los valores de un Row del IDataSource
226    * @param rowValues
227    * @return contexto
228    */
229   private Map getContext(Object [] rowValues) throws InfoException {
230     Map context = new HashMap();
231     fillContext(rowValues, context);
232     return context;
233   }
234
235   /**
236    * Llena el contexto con el que se evalúa la expresión del cálculo con los valores de un Row del IDataSource
237    * @param values
238    * @param context
239    */
240   private void fillContext(Object [] values, Map context) throws InfoException {
241     Set entries = getVariableIndexes().entrySet();
242     Iterator iterator = entries.iterator();
243     while (iterator.hasNext()) {
244       Map.Entry entry = (Map.Entry) iterator.next();
245       context.put(entry.getKey(), floatFrom(values[((Integer ) entry.getValue()).intValue()]));
246     }
247   }
248
249   /**
250    * devuelve un valor Float a partir del objeto obtenido del IDataSource
251    * @param value
252    * @return Float
253    */
254   private Object floatFrom(Object value) throws InfoException {
255     if(value instanceof Float ){
256       return SharedFloat.newFrom((Float ) value);
257     }else if (value instanceof SharedFloat){
258       return value;//new Float(((SharedFloat)value).floatValue());
259 } else if ((value instanceof String )||(value instanceof SharedString)){
260       String strValue = value.toString();
261       if (strValue.equalsIgnoreCase("")){
262         strValue = "0";
263       }
264       return SharedFloat.newFrom(Float.valueOf(strValue.trim()));
265     } else if(value instanceof Integer ) {
266       return SharedFloat.newFrom(Float.valueOf(value.toString()));
267     } else if(value instanceof Long ) {
268       return SharedFloat.newFrom(Float.valueOf(value.toString()));
269     } else if(value instanceof BigDecimal ) {
270       return SharedFloat.newFrom(((BigDecimal )value).floatValue());
271     } else if(value instanceof Double ) {
272       return SharedFloat.newFrom(((Double )value).floatValue());
273     }else if(value instanceof java.sql.Date ) {
274       return SharedFloat.newFrom(Float.valueOf((value).toString()));
275     }else if(value == null) {
276       return null;
277     }
278
279     throw new InfoException(LanguageTraslator.traslate("279"));
280   }
281 }
282

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags