1:
31: package ;
32:
33: import ;
34: import ;
35: import ;
36: import ;
37: import ;
38:
39:
52: public final class GlobalView implements DataRow
53: {
54: private static final DataFlags[] EMPTY_DATA_FLAGS = new DataFlags[0];
55: private DataFlags[] oldData;
56: private LazyNameMap oldCache;
57: private DataFlags[] data;
58: private LazyNameMap nameCache;
59: private int length;
60:
61: private GlobalView()
62: {
63: }
64:
65: public static GlobalView createView()
66: {
67: final GlobalView gv = new GlobalView();
68: gv.nameCache = new LazyNameMap();
69: gv.oldCache = new LazyNameMap();
70: gv.data = new DataFlags[10];
71: gv.oldData = EMPTY_DATA_FLAGS;
72: return gv;
73: }
74:
75:
76: private void ensureCapacity(final int requestedSize)
77: {
78: final int capacity = this.data.length;
79: if (capacity > requestedSize)
80: {
81: return;
82: }
83: final int newSize = Math.max(capacity * 2, requestedSize + 10);
84:
85: final DataFlags[] newData = new DataFlags[newSize];
86: System.arraycopy(data, 0, newData, 0, length);
87:
88: this.data = newData;
89: }
90:
91:
99: public synchronized void putField(final String name,
100: final Object value,
101: final boolean update)
102: throws DataSourceException
103: {
104: if (name == null)
105: {
106: throw new NullPointerException("Name must not be null.");
107: }
108:
109: final LazyNameMap.NameCarrier nc = nameCache.get(name);
110: final DefaultDataFlags flagedValue = new DefaultDataFlags
111: (name, value, computeChange(name, value));
112: if (nc != null)
113: {
114: this.data[nc.getValue()] = flagedValue;
115: if (update == false)
116: {
117: nc.increase();
118: }
119: return;
120: }
121:
122:
123:
124: for (int i = 0; i < length; i++)
125: {
126: final DataFlags dataFlags = data[i];
127: if (dataFlags == null)
128: {
129: data[i] = flagedValue;
130: nameCache.setValue(name, i);
131: return;
132: }
133: }
134:
135:
136: ensureCapacity(length + 1);
137: data[length] = flagedValue;
138: nameCache.setValue(name, length);
139: this.length += 1;
140: }
141:
142: private boolean computeChange(final String name, final Object newValue)
143: throws DataSourceException
144: {
145: final LazyNameMap.NameCarrier onc = oldCache.get(name);
146: if (onc == null)
147: {
148:
149: return true;
150: }
151:
152: final DataFlags dataFlags = oldData[onc.getValue()];
153: if (dataFlags == null)
154: {
155: return true;
156: }
157: return ObjectUtilities.equal(dataFlags.getValue(), newValue) == false;
158: }
159:
160:
171: public Object get(final int col) throws DataSourceException
172: {
173: final DataFlags flag = getFlags(col);
174: if (flag == null)
175: {
176: return null;
177: }
178: return flag.getValue();
179: }
180:
181:
193: public Object get(final String col) throws DataSourceException
194: {
195: final DataFlags flag = getFlags(col);
196: if (flag == null)
197: {
198: return null;
199: }
200: return flag.getValue();
201: }
202:
203:
212: public String getColumnName(final int col)
213: {
214: final DataFlags flag = getFlags(col);
215: if (flag == null)
216: {
217: return null;
218: }
219: return flag.getName();
220: }
221:
222:
228: public int getColumnCount()
229: {
230: return length;
231: }
232:
233: public DataFlags getFlags(final String col)
234: {
235: final LazyNameMap.NameCarrier idx = nameCache.get(col);
236: if (idx != null)
237: {
238: final int idxVal = idx.getValue();
239: final DataFlags df = data[idxVal];
240: if (df != null)
241: {
242: return df;
243: }
244: }
245:
246: final LazyNameMap.NameCarrier oidx = oldCache.get(col);
247: if (oidx == null)
248: {
249: return null;
250: }
251:
252: final int oidxVal = oidx.getValue();
253: if (oidxVal < oldData.length)
254: {
255: return oldData[oidxVal];
256: }
257: return null;
258: }
259:
260: public DataFlags getFlags(final int col)
261: {
262: final DataFlags df = data[col];
263: if (df != null)
264: {
265: return df;
266: }
267: return oldData[col];
268: }
269:
270: public GlobalView derive()
271: {
272: final GlobalView gv = new GlobalView();
273: gv.oldCache = (LazyNameMap) oldCache.clone();
274: gv.data = (DataFlags[]) data.clone();
275: gv.oldData = (DataFlags[]) oldData.clone();
276: gv.length = length;
277: gv.nameCache = (LazyNameMap) nameCache.clone();
278: return gv;
279: }
280:
281: public GlobalView advance()
282: {
283: final GlobalView gv = new GlobalView();
284: gv.oldCache = (LazyNameMap) nameCache.clone();
285: gv.oldData = (DataFlags[]) data.clone();
286: gv.data = new DataFlags[gv.oldData.length];
287: gv.length = length;
288: gv.nameCache = new LazyNameMap();
289: return gv;
290: }
291:
292:
298: public synchronized void removeColumn(final String name)
299: {
300: final LazyNameMap.NameCarrier idx = nameCache.get(name);
301: if (idx == null)
302: {
303: return;
304: }
305: idx.decrease();
306: if (idx.getInstanceCount() < 1)
307: {
308: nameCache.remove(name);
309: data[idx.getValue()] = null;
310:
311:
312: }
313: }
314:
315: }