001: package com.calipso.reportgenerator.reportcalculator;
002:
003: import com.calipso.reportgenerator.reportcalculator.SharedFloat;
004:
005: import java.util.*;
006: import java.io.Serializable;
007:
008: /**
009: * Representa un nodo del arbol <code>DataTree</code>
010: */
011:
012: public class DataTreeNode implements Serializable {
013: private String value;
014: private List subItems;
015: private SharedFloat[] metrics;
016: //private CubeFloat[] accumulableMetrics;
017: private Map subNodes;
018: private DataTreeNode parent;
019: private int dimensionIndex;
020:
021: /**
022: * Inicializa una instancia de <code>DataTreeNode</code>.
023: * @param parent nodo padre del actual
024: * @param value valor del nodo
025: * @param metricCount cantidad de metricas asociadas al nodo
026: * @param dimensionIndex indice del nodo
027: */
028: public DataTreeNode(DataTreeNode parent, String value,
029: int metricCount, /*int accumulableMetricCount,*/
030: int dimensionIndex) {
031: this .parent = parent;
032: this .value = value;
033: this .subItems = new ArrayList();
034: this .metrics = new SharedFloat[metricCount];
035: //this.accumulableMetrics = new CubeFloat[accumulableMetricCount];
036: this .dimensionIndex = dimensionIndex;
037: initialize();
038: }
039:
040: /**
041: * Inicializa el array metrics del nodo
042: */
043: private void initialize() {
044: for (int i = 0; i < metrics.length; i++) {
045: metrics[i] = SharedFloat.newFrom(0);
046: }
047:
048: /*for (int i = 0; i < accumulableMetrics.length; i++){
049: accumulableMetrics[i] = new CubeFloat(0);
050: } */
051:
052: }
053:
054: /**
055: * Retorna el indice del nodo.
056: * @return
057: */
058: public int getDimensionIndex() {
059: return dimensionIndex;
060: }
061:
062: /**
063: * Asigna un indice al nodo.
064: * @param dimensionIndex
065: */
066: public void setDimensionIndex(int dimensionIndex) {
067: this .dimensionIndex = dimensionIndex;
068: }
069:
070: /**
071: * Retorna el valor del nodo.
072: * @return
073: */
074: public String getValue() {
075: return value;
076: }
077:
078: /**
079: * Devuelve una lista con instancias del tipo <code>DataTreeSubItem</code>
080: * del nodo actual.
081: * @return
082: */
083: public List getSubItems() {
084: return subItems;
085: }
086:
087: /**
088: * Devuelve un array con los valores de las metricas del nodo.
089: * @return
090: */
091: public SharedFloat[] getMetrics() {
092: return metrics;
093: }
094:
095: /*public CubeFloat[] getAccumulableMetrics() {
096: return accumulableMetrics;
097: } */
098:
099: /**
100: * Devuelve un diccionario que contiene los subNodos del nodo actual.
101: * @return
102: */
103: public Map getSubNodes() {
104: if (subNodes == null) {
105: subNodes = new TreeMap();
106: }
107: return subNodes;
108: }
109:
110: /**
111: * Devuelve un nodo hijo a partir del Key recibido por parametro.
112: * Si no existiera tal nodo, se crea uno nuevo, se agrega
113: * al diccionario de subNodos y se retorna.
114: * @param key
115: * @param dimensionIndex
116: * @return
117: */
118: public DataTreeNode getNodeFrom(Object key, int dimensionIndex) {
119: DataTreeNode node;
120: if (getSubNodes().containsKey(key)) {
121: node = (DataTreeNode) getSubNodes().get(key);
122: } else {
123: node = new DataTreeNode(this , key.toString(),
124: metrics.length, /*accumulableMetrics.length,*/
125: dimensionIndex);
126: getSubNodes().put(key, node);
127: }
128: return node;
129: }
130:
131: /**
132: * Actualiza los valores de las metricas del nodo.
133: * Si el nodo tiene subNodos se recalculan los valores de las metricas en base
134: * a los actuales mas los ya acumulados, no asi en caso de que el nodo no tenga
135: * subnodos.
136: * @param index
137: * @param value
138: */
139: public void updateMetricValue(int index, SharedFloat value) {
140: metrics[index] = (metrics[index]).add(value);
141: // Para una metrica acumulada poner todo!
142: // accumIndex --> averiguar el indice de la que acumula esta métrica
143: /*CubeFloat newValue = new CubeFloat(((CubeFloat)getParent().getMetrics()[accumIndex]).floatValue());
144: newValue.add((Float) value);
145: ((CubeFloat)metrics[index]).add(newValue.floatValue());
146: */
147: }
148:
149: /**
150: * Devuelve el nodo padre del nodo.
151: * @return
152: */
153: public DataTreeNode getParent() {
154: return parent;
155: }
156:
157: /**
158: * Asigna el valor al nodo.
159: * @param value
160: */
161: public void setValue(String value) {
162: this .value = value;
163: }
164:
165: /**
166: * Asigna una instancia de tipo <code>DataTreeSubItem</code>
167: * al nodo.
168: * @param subItem
169: */
170: public void addSubItem(DataTreeSubItem subItem) {
171: getSubItems().add(subItem);
172: }
173:
174: /**
175: * Acumula el/los valor/es de la/s metrica/s acumulable/s correspondiente
176: * a cada <code>DataTreeSubItem</code>.
177: * @param adjAccumulableMetrics
178: */
179: public void calculateAccumulable(int[] adjAccumulableMetrics) {
180: Iterator subNodesIter = getSubNodes().values().iterator();
181: while (subNodesIter.hasNext()) {
182: DataTreeNode dataTreeNode = (DataTreeNode) subNodesIter
183: .next();
184: dataTreeNode.calculateAccumulable(adjAccumulableMetrics);
185: }
186:
187: SharedFloat[] accValues = new SharedFloat[adjAccumulableMetrics.length];
188: Iterator subItemsIter = getSubItems().iterator();
189: while (subItemsIter.hasNext()) {
190: DataTreeSubItem subItem = (DataTreeSubItem) subItemsIter
191: .next();
192: for (int i = 0; i < accValues.length; i++) {
193: if (accValues[i] == null) {
194: accValues[i] = SharedFloat.newFrom(0);
195: }
196: accValues[i]
197: .add(subItem.getMetricValues()[adjAccumulableMetrics[i]]);
198: }
199: subItem.setAccumulableMetricValues(copyOf(accValues));
200: subItem.setAdjMetricIndexes(adjAccumulableMetrics);
201: }
202: }
203:
204: /**
205: * Retorna una copia de los valores de las metricas que viene
206: * en el array recibido por parametro.
207: * @param source
208: * @return
209: */
210: private SharedFloat[] copyOf(SharedFloat[] source) {
211: SharedFloat[] result = new SharedFloat[source.length];
212: for (int i = 0; i < source.length; i++) {
213: result[i] = SharedFloat.newFrom(source[i].floatValue());
214: }
215: return result;
216: }
217:
218: public DataTreeSubItem getSubItem(String[] noGroupDimValues) {
219: Iterator iterator = getSubItems().iterator();
220: while (iterator.hasNext()) {
221: DataTreeSubItem dataTreeSubItem = (DataTreeSubItem) iterator
222: .next();
223: if (dataTreeSubItem.matches(noGroupDimValues)) {
224: return dataTreeSubItem;
225: }
226: }
227: DataTreeSubItem subItem = new DataTreeSubItem(noGroupDimValues,
228: getMetrics().length);
229: getSubItems().add(subItem);
230: return subItem;
231: }
232: }
|