1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package javax.faces.component.behavior;
20
21 import java.util.ArrayList;
22 import java.util.Collection;
23 import java.util.Iterator;
24 import java.util.List;
25 import java.util.ListIterator;
26
27 import javax.faces.component.PartialStateHolder;
28 import javax.faces.component.StateHolder;
29 import javax.faces.component.UIComponentBase;
30 import javax.faces.context.FacesContext;
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48 class _DeltaList<T> implements List<T>, PartialStateHolder
49 {
50
51 private List<T> _delegate;
52 private boolean _initialStateMarked;
53
54 public _DeltaList()
55 {
56 }
57
58 public _DeltaList(List<T> delegate)
59 {
60 _delegate = delegate;
61 }
62
63 public void add(int index, T element)
64 {
65 clearInitialState();
66 _delegate.add(index, element);
67 }
68
69 public boolean add(T e)
70 {
71 clearInitialState();
72 return _delegate.add(e);
73 }
74
75 public boolean addAll(Collection<? extends T> c)
76 {
77 clearInitialState();
78 return _delegate.addAll(c);
79 }
80
81 public boolean addAll(int index, Collection<? extends T> c)
82 {
83 clearInitialState();
84 return _delegate.addAll(index, c);
85 }
86
87 public void clear()
88 {
89 clearInitialState();
90 _delegate.clear();
91 }
92
93 public boolean contains(Object o)
94 {
95 return _delegate.contains(o);
96 }
97
98 public boolean containsAll(Collection<?> c)
99 {
100 return _delegate.containsAll(c);
101 }
102
103 public boolean equals(Object o)
104 {
105 return _delegate.equals(o);
106 }
107
108 public T get(int index)
109 {
110 return _delegate.get(index);
111 }
112
113 public int hashCode()
114 {
115 return _delegate.hashCode();
116 }
117
118 public int indexOf(Object o)
119 {
120 return _delegate.indexOf(o);
121 }
122
123 public boolean isEmpty()
124 {
125 return _delegate.isEmpty();
126 }
127
128 public Iterator<T> iterator()
129 {
130 return _delegate.iterator();
131 }
132
133 public int lastIndexOf(Object o)
134 {
135 return _delegate.lastIndexOf(o);
136 }
137
138 public ListIterator<T> listIterator()
139 {
140 return _delegate.listIterator();
141 }
142
143 public ListIterator<T> listIterator(int index)
144 {
145 return _delegate.listIterator(index);
146 }
147
148 public T remove(int index)
149 {
150 clearInitialState();
151 return _delegate.remove(index);
152 }
153
154 public boolean remove(Object o)
155 {
156 clearInitialState();
157 return _delegate.remove(o);
158 }
159
160 public boolean removeAll(Collection<?> c)
161 {
162 clearInitialState();
163 return _delegate.removeAll(c);
164 }
165
166 public boolean retainAll(Collection<?> c)
167 {
168 clearInitialState();
169 return _delegate.retainAll(c);
170 }
171
172 public T set(int index, T element)
173 {
174 clearInitialState();
175 return _delegate.set(index, element);
176 }
177
178 public int size()
179 {
180 return _delegate == null ? 0 : _delegate.size();
181 }
182
183 public List<T> subList(int fromIndex, int toIndex)
184 {
185 return _delegate.subList(fromIndex, toIndex);
186 }
187
188 public Object[] toArray()
189 {
190 return _delegate.toArray();
191 }
192
193 public <T> T[] toArray(T[] a)
194 {
195 return _delegate.toArray(a);
196 }
197
198 public boolean isTransient()
199 {
200 return false;
201 }
202
203 public void setTransient(boolean newTransientValue)
204 {
205 throw new UnsupportedOperationException();
206 }
207
208 public void restoreState(FacesContext context, Object state)
209 {
210 if (state == null)
211 {
212 return;
213 }
214
215 if (initialStateMarked())
216 {
217
218 Object[] lst = (Object[]) state;
219 int j = 0;
220 int i = 0;
221 while (i < lst.length)
222 {
223 if (lst[i] instanceof _AttachedDeltaWrapper)
224 {
225
226 ((StateHolder)_delegate.get(j)).restoreState(context, ((_AttachedDeltaWrapper) lst[i]).getWrappedStateObject());
227 j++;
228 }
229 else if (lst[i] != null)
230 {
231
232 _delegate.set(j, (T) UIComponentBase.restoreAttachedState(context, lst[i]));
233 j++;
234 }
235 else
236 {
237 _delegate.remove(j);
238 }
239 i++;
240 }
241 if (i != j)
242 {
243
244
245 clearInitialState();
246 }
247 }
248 else
249 {
250
251 Object[] lst = (Object[]) state;
252 _delegate = new ArrayList<T>(lst.length);
253 for (int i = 0; i < lst.length; i++)
254 {
255 T value = (T) UIComponentBase.restoreAttachedState(context, lst[i]);
256 if (value != null)
257 {
258 _delegate.add(value);
259 }
260 }
261 }
262 }
263
264 public Object saveState(FacesContext context)
265 {
266 if (initialStateMarked())
267 {
268 Object [] lst = new Object[_delegate.size()];
269 boolean nullDelta = true;
270 for (int i = 0; i < _delegate.size(); i++)
271 {
272 Object value = _delegate.get(i);
273 if (value instanceof PartialStateHolder)
274 {
275
276 PartialStateHolder holder = (PartialStateHolder) value;
277 if (!holder.isTransient())
278 {
279 Object attachedState = holder.saveState(context);
280 if (attachedState != null)
281 {
282 nullDelta = false;
283 }
284 lst[i] = new _AttachedDeltaWrapper(value.getClass(),
285 attachedState);
286 }
287 }
288 else
289 {
290
291 lst[i] = UIComponentBase.saveAttachedState(context, value);
292 if (value instanceof StateHolder || value instanceof List)
293 {
294 nullDelta = false;
295 }
296 }
297 }
298 if (nullDelta)
299 {
300 return null;
301 }
302 return lst;
303 }
304 else
305 {
306 Object [] lst = new Object[_delegate.size()];
307 for (int i = 0; i < _delegate.size(); i++)
308 {
309 lst[i] = UIComponentBase.saveAttachedState(context, _delegate.get(i));
310 }
311 return lst;
312 }
313 }
314
315 public void clearInitialState()
316 {
317
318 if (_initialStateMarked)
319 {
320 _initialStateMarked = false;
321 if (_delegate != null)
322 {
323 for (T value : _delegate)
324 {
325 if (value instanceof PartialStateHolder)
326 {
327 ((PartialStateHolder)value).clearInitialState();
328 }
329 }
330 }
331 }
332 }
333
334 public boolean initialStateMarked()
335 {
336 return _initialStateMarked;
337 }
338
339 public void markInitialState()
340 {
341 _initialStateMarked = true;
342 if (_delegate != null)
343 {
344 int size = _delegate.size();
345 for (int i = 0; i < size; i++)
346 {
347 T value = _delegate.get(i);
348 if (value instanceof PartialStateHolder)
349 {
350 ((PartialStateHolder)value).markInitialState();
351 }
352 }
353 }
354 }
355 }