KickJava   Java API By Example, From Geeks To Geeks.

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


1 package com.calipso.reportgenerator.reportcalculator;
2
3 import com.calipso.reportgenerator.reportcalculator.SharedFloat;
4
5 import java.util.*;
6 import java.io.Serializable JavaDoc;
7
8 /**
9  * Representa un nodo del arbol <code>DataTree</code>
10  */
11
12 public class DataTreeNode implements Serializable JavaDoc{
13   private String JavaDoc value;
14   private List subItems;
15   private SharedFloat[] metrics;
16   //private CubeFloat[] accumulableMetrics;
17 private Map subNodes;
18   private DataTreeNode parent;
19   private int dimensionIndex;
20
21
22   /**
23    * Inicializa una instancia de <code>DataTreeNode</code>.
24    * @param parent nodo padre del actual
25    * @param value valor del nodo
26    * @param metricCount cantidad de metricas asociadas al nodo
27    * @param dimensionIndex indice del nodo
28    */
29   public DataTreeNode(DataTreeNode parent, String JavaDoc value, int metricCount, /*int accumulableMetricCount,*/ int dimensionIndex) {
30     this.parent = parent;
31     this.value = value;
32     this.subItems = new ArrayList();
33     this.metrics = new SharedFloat[metricCount];
34     //this.accumulableMetrics = new CubeFloat[accumulableMetricCount];
35 this.dimensionIndex = dimensionIndex;
36     initialize();
37   }
38
39   /**
40    * Inicializa el array metrics del nodo
41    */
42   private void initialize() {
43     for (int i = 0; i < metrics.length; i++){
44       metrics[i] = SharedFloat.newFrom(0);
45     }
46
47     /*for (int i = 0; i < accumulableMetrics.length; i++){
48       accumulableMetrics[i] = new CubeFloat(0);
49     } */
50
51   }
52
53   /**
54    * Retorna el indice del nodo.
55    * @return
56    */
57   public int getDimensionIndex() {
58     return dimensionIndex;
59   }
60
61   /**
62    * Asigna un indice al nodo.
63    * @param dimensionIndex
64    */
65   public void setDimensionIndex(int dimensionIndex) {
66     this.dimensionIndex = dimensionIndex;
67   }
68
69   /**
70    * Retorna el valor del nodo.
71    * @return
72    */
73   public String JavaDoc getValue() {
74     return value;
75   }
76
77   /**
78    * Devuelve una lista con instancias del tipo <code>DataTreeSubItem</code>
79    * del nodo actual.
80    * @return
81    */
82   public List getSubItems() {
83     return subItems;
84   }
85
86   /**
87    * Devuelve un array con los valores de las metricas del nodo.
88    * @return
89    */
90   public SharedFloat[] getMetrics() {
91     return metrics;
92   }
93
94   /*public CubeFloat[] getAccumulableMetrics() {
95     return accumulableMetrics;
96   } */
97
98   /**
99    * Devuelve un diccionario que contiene los subNodos del nodo actual.
100    * @return
101    */
102   public Map getSubNodes() {
103     if (subNodes == null) {
104       subNodes = new TreeMap();
105     }
106     return subNodes;
107   }
108
109   /**
110    * Devuelve un nodo hijo a partir del Key recibido por parametro.
111    * Si no existiera tal nodo, se crea uno nuevo, se agrega
112    * al diccionario de subNodos y se retorna.
113    * @param key
114    * @param dimensionIndex
115    * @return
116    */
117   public DataTreeNode getNodeFrom(Object JavaDoc key, int dimensionIndex) {
118     DataTreeNode node;
119     if (getSubNodes().containsKey(key)) {
120       node = (DataTreeNode) getSubNodes().get(key);
121     }
122     else {
123       node = new DataTreeNode(this, key.toString(), metrics.length, /*accumulableMetrics.length,*/ dimensionIndex );
124       getSubNodes().put(key, node);
125     }
126     return node;
127   }
128
129   /**
130    * Actualiza los valores de las metricas del nodo.
131    * Si el nodo tiene subNodos se recalculan los valores de las metricas en base
132    * a los actuales mas los ya acumulados, no asi en caso de que el nodo no tenga
133    * subnodos.
134    * @param index
135    * @param value
136    */
137   public void updateMetricValue(int index, SharedFloat value) {
138     metrics[index] = (metrics[index]).add(value);
139     // Para una metrica acumulada poner todo!
140 // accumIndex --> averiguar el indice de la que acumula esta métrica
141 /*CubeFloat newValue = new CubeFloat(((CubeFloat)getParent().getMetrics()[accumIndex]).floatValue());
142     newValue.add((Float) value);
143     ((CubeFloat)metrics[index]).add(newValue.floatValue());
144     */
145   }
146
147   /**
148    * Devuelve el nodo padre del nodo.
149    * @return
150    */
151   public DataTreeNode getParent() {
152     return parent;
153   }
154
155   /**
156    * Asigna el valor al nodo.
157    * @param value
158    */
159   public void setValue(String JavaDoc value) {
160     this.value = value;
161   }
162
163   /**
164    * Asigna una instancia de tipo <code>DataTreeSubItem</code>
165    * al nodo.
166    * @param subItem
167    */
168   public void addSubItem(DataTreeSubItem subItem) {
169     getSubItems().add(subItem);
170   }
171
172   /**
173    * Acumula el/los valor/es de la/s metrica/s acumulable/s correspondiente
174    * a cada <code>DataTreeSubItem</code>.
175    * @param adjAccumulableMetrics
176    */
177   public void calculateAccumulable(int[] adjAccumulableMetrics) {
178     Iterator subNodesIter = getSubNodes().values().iterator();
179     while (subNodesIter.hasNext()) {
180       DataTreeNode dataTreeNode = (DataTreeNode) subNodesIter.next();
181       dataTreeNode.calculateAccumulable(adjAccumulableMetrics);
182     }
183
184     SharedFloat[] accValues = new SharedFloat[adjAccumulableMetrics.length];
185     Iterator subItemsIter = getSubItems().iterator();
186     while (subItemsIter.hasNext()) {
187       DataTreeSubItem subItem = (DataTreeSubItem) subItemsIter.next();
188       for (int i = 0; i < accValues.length; i++) {
189         if (accValues[i] == null) {
190           accValues[i] = SharedFloat.newFrom(0);
191         }
192         accValues[i].add(subItem.getMetricValues()[adjAccumulableMetrics[i]]);
193       }
194       subItem.setAccumulableMetricValues(copyOf(accValues));
195       subItem.setAdjMetricIndexes(adjAccumulableMetrics);
196     }
197   }
198
199   /**
200    * Retorna una copia de los valores de las metricas que viene
201    * en el array recibido por parametro.
202    * @param source
203    * @return
204    */
205   private SharedFloat[] copyOf(SharedFloat[] source) {
206     SharedFloat[] result = new SharedFloat[source.length];
207     for (int i = 0; i < source.length; i++) {
208       result[i] = SharedFloat.newFrom(source[i].floatValue());
209     }
210     return result;
211   }
212
213   public DataTreeSubItem getSubItem(String JavaDoc[] noGroupDimValues) {
214     Iterator iterator = getSubItems().iterator();
215     while (iterator.hasNext()) {
216       DataTreeSubItem dataTreeSubItem = (DataTreeSubItem) iterator.next();
217       if(dataTreeSubItem.matches(noGroupDimValues)){
218         return dataTreeSubItem;
219       }
220     }
221     DataTreeSubItem subItem = new DataTreeSubItem(noGroupDimValues, getMetrics().length);
222     getSubItems().add(subItem);
223     return subItem;
224   }
225 }
226
Popular Tags