KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > mondrian > rolap > agg > DenseSegmentDataset


1 /*
2 // $Id: //open/mondrian/src/main/mondrian/rolap/agg/DenseSegmentDataset.java#9 $
3 // This software is subject to the terms of the Common Public License
4 // Agreement, available at the following URL:
5 // http://www.opensource.org/licenses/cpl.html.
6 // Copyright (C) 2002-2002 Kana Software, Inc.
7 // Copyright (C) 2002-2007 Julian Hyde and others
8 // All Rights Reserved.
9 // You must accept the terms of that agreement to use this software.
10 //
11 // jhyde, 21 March, 2002
12 */
13 package mondrian.rolap.agg;
14
15 import mondrian.rolap.CellKey;
16
17 import java.util.Map JavaDoc;
18 import java.util.Iterator JavaDoc;
19
20 /**
21  * A <code>DenseSegmentDataset</code> is a means of storing segment values
22  * which is suitable when most of the combinations of keys have a value
23  * present.
24  *
25  * <p>The storage requirements are as follows. Table requires 1 word per
26  * cell.</p>
27  *
28  * @author jhyde
29  * @since 21 March, 2002
30  * @version $Id: //open/mondrian/src/main/mondrian/rolap/agg/DenseSegmentDataset.java#9 $
31  */
32 class DenseSegmentDataset implements SegmentDataset {
33     private final Segment segment;
34     private final Object JavaDoc[] values; // length == m[0] * ... * m[axes.length-1]
35
36     DenseSegmentDataset(Segment segment, Object JavaDoc[] values) {
37         this.segment = segment;
38         this.values = values;
39     }
40
41     public Object JavaDoc get(CellKey key) {
42         int offset = getOffset(key.getOrdinals());
43         return values[offset];
44     }
45
46     public double getBytes() {
47         // assume a slot, key, and value are each 4 bytes
48 return values.length * 12;
49     }
50
51     public void put(CellKey key, Object JavaDoc value) {
52         int offset = getOffset(key.getOrdinals());
53         values[offset] = value;
54     }
55
56     public Iterator JavaDoc<Map.Entry JavaDoc<CellKey, Object JavaDoc>> iterator() {
57         return new Itr();
58     }
59
60     boolean contains(Object JavaDoc[] keys) {
61         return getOffset(keys) >= 0;
62     }
63
64     Object JavaDoc get(Object JavaDoc[] keys) {
65         int offset = getOffset(keys);
66         return keys[offset];
67     }
68
69     void put(Object JavaDoc[] keys, Object JavaDoc value) {
70         int offset = getOffset(keys);
71         keys[offset] = value;
72     }
73
74     private int getOffset(int[] keys) {
75         int offset = 0;
76         for (int i = 0; i < keys.length; i++) {
77             Aggregation.Axis axis = segment.axes[i];
78             Object JavaDoc[] ks = axis.getKeys();
79             offset *= ks.length;
80             offset += keys[i];
81         }
82         return offset;
83     }
84
85     private int getOffset(Object JavaDoc[] keys) {
86         int offset = 0;
87 outer:
88         for (int i = 0; i < keys.length; i++) {
89             Aggregation.Axis axis = segment.axes[i];
90             Object JavaDoc[] ks = axis.getKeys();
91             offset *= ks.length;
92             Object JavaDoc value = keys[i];
93             for (int j = 0, axisLength = ks.length; j < axisLength; j++) {
94                 if (ks[j].equals(value)) {
95                     offset += j;
96                     continue outer;
97                 }
98             }
99             return -1; // not found
100 }
101         return offset;
102     }
103
104     void set(int k, Object JavaDoc o) {
105         values[k] = o;
106     }
107
108     /**
109      * Iterator over a DenseSegmentDataset.
110      *
111      * <p>This is a 'cheap' implementation
112      * which doesn't allocate a new Entry every step: it just returns itself.
113      * The Entry must therefore be used immediately, before calling
114      * {@link #next()} again.
115      */
116     private class Itr implements
117         Iterator JavaDoc<Map.Entry JavaDoc<CellKey, Object JavaDoc>>,
118         Map.Entry JavaDoc<CellKey, Object JavaDoc>
119     {
120         private int i = -1;
121         private final int[] ordinals;
122         private final CellKey key;
123
124         Itr() {
125             ordinals = new int[segment.axes.length];
126             ordinals[ordinals.length - 1] = -1;
127             key = CellKey.Generator.newRefCellKey(ordinals);
128         }
129
130         public boolean hasNext() {
131             return i < values.length - 1;
132         }
133
134         public Map.Entry JavaDoc<CellKey, Object JavaDoc> next() {
135             ++i;
136             int k = ordinals.length - 1;
137             while (k >= 0) {
138                 if (ordinals[k] < segment.axes[k].getKeys().length - 1) {
139                     ++ordinals[k];
140                     break;
141                 } else {
142                     ordinals[k] = 0;
143                     --k;
144                 }
145             }
146             return this;
147         }
148
149         // implement Iterator
150 public void remove() {
151             throw new UnsupportedOperationException JavaDoc();
152         }
153
154         // implement Entry
155 public CellKey getKey() {
156             return key;
157         }
158
159         // implement Entry
160 public Object JavaDoc getValue() {
161             return values[i];
162         }
163
164         // implement Entry
165 public Object JavaDoc setValue(Object JavaDoc value) {
166             throw new UnsupportedOperationException JavaDoc();
167         }
168     }
169 }
170
171 // End DenseSegmentDataset.java
172
Popular Tags