1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
/*******************************************************************************
* Copyright (c) 2007, 2009 Oracle. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0, which accompanies this distribution
* and is available at http://www.eclipse.org/legal/epl-v10.html.
*
* Contributors:
* Oracle - initial API and implementation
******************************************************************************/
package org.eclipse.jpt.utility.internal.model.value;
import java.util.ArrayList;
import java.util.Iterator;
import org.eclipse.jpt.utility.internal.iterators.ReadOnlyIterator;
import org.eclipse.jpt.utility.model.event.ListAddEvent;
import org.eclipse.jpt.utility.model.event.ListChangeEvent;
import org.eclipse.jpt.utility.model.event.ListClearEvent;
import org.eclipse.jpt.utility.model.event.ListMoveEvent;
import org.eclipse.jpt.utility.model.event.ListRemoveEvent;
import org.eclipse.jpt.utility.model.event.ListReplaceEvent;
import org.eclipse.jpt.utility.model.listener.ListChangeListener;
import org.eclipse.jpt.utility.model.value.CollectionValueModel;
import org.eclipse.jpt.utility.model.value.ListValueModel;
/**
* An adapter that allows us to make a {@link ListValueModel} behave like
* a read-only {@link CollectionValueModel}, sorta.
* <p>
* We keep an internal collection somewhat in synch with the wrapped list.
* <p>
* <strong>NB:</strong> Since we only listen to the wrapped list when we have
* listeners ourselves and we can only stay in synch with the wrapped
* list while we are listening to it, results to various methods
* (e.g. {@link #size()}, {@link iterator()}) will be unpredictable whenever
* we do not have any listeners. This should not be too painful since,
* most likely, client objects will also be listeners.
*/
public class ListCollectionValueModelAdapter<E>
extends AbstractCollectionValueModel
implements CollectionValueModel<E>
{
/** The wrapped list value model. */
protected final ListValueModel<? extends E> listHolder;
/** A listener that forwards any events fired by the list holder. */
protected final ListChangeListener listChangeListener;
/**
* Our internal collection, which holds the same elements as
* the wrapped list.
*/
// we declare this an ArrayList so we can use #clone() and #ensureCapacity(int)
protected final ArrayList<E> collection;
// ********** constructors **********
/**
* Wrap the specified list value model.
*/
public ListCollectionValueModelAdapter(ListValueModel<? extends E> listHolder) {
super();
if (listHolder == null) {
throw new NullPointerException();
}
this.listHolder = listHolder;
this.listChangeListener = this.buildListChangeListener();
this.collection = new ArrayList<E>();
// postpone building the collection and listening to the underlying list
// until we have listeners ourselves...
}
// ********** initialization **********
/**
* The wrapped list has changed, forward an equivalent
* collection change event to our listeners.
*/
protected ListChangeListener buildListChangeListener() {
return new ListChangeListener() {
public void itemsAdded(ListAddEvent event) {
ListCollectionValueModelAdapter.this.itemsAdded(event);
}
public void itemsRemoved(ListRemoveEvent event) {
ListCollectionValueModelAdapter.this.itemsRemoved(event);
}
public void itemsReplaced(ListReplaceEvent event) {
ListCollectionValueModelAdapter.this.itemsReplaced(event);
}
public void itemsMoved(ListMoveEvent event) {
ListCollectionValueModelAdapter.this.itemsMoved(event);
}
public void listCleared(ListClearEvent event) {
ListCollectionValueModelAdapter.this.listCleared(event);
}
public void listChanged(ListChangeEvent event) {
ListCollectionValueModelAdapter.this.listChanged(event);
}
@Override
public String toString() {
return "list change listener"; //$NON-NLS-1$
}
};
}
// ********** CollectionValueModel implementation **********
public Iterator<E> iterator() {
// try to prevent backdoor modification of the list
return new ReadOnlyIterator<E>(this.collection);
}
public int size() {
return this.collection.size();
}
// ********** AbstractCollectionValueModel implementation **********
@Override
protected void engageModel() {
this.listHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.listChangeListener);
// synch our collection *after* we start listening to the list holder,
// since its value might change when a listener is added
this.buildCollection();
}
@Override
protected void disengageModel() {
this.listHolder.removeListChangeListener(ListValueModel.LIST_VALUES, this.listChangeListener);
// clear out the collection when we are not listening to the list holder
this.collection.clear();
}
// ********** behavior **********
protected void itemsAdded(ListAddEvent event) {
this.addItemsToCollection(this.getItems(event), this.collection, VALUES);
}
// minimized scope of suppressed warnings
@SuppressWarnings("unchecked")
protected Iterable<E> getItems(ListAddEvent event) {
return (Iterable<E>) event.getItems();
}
protected void itemsRemoved(ListRemoveEvent event) {
this.removeItemsFromCollection(this.getItems(event), this.collection, VALUES);
}
// minimized scope of suppressed warnings
@SuppressWarnings("unchecked")
protected Iterable<E> getItems(ListRemoveEvent event) {
return (Iterable<E>) event.getItems();
}
protected void itemsReplaced(ListReplaceEvent event) {
this.removeItemsFromCollection(this.getOldItems(event), this.collection, VALUES);
this.addItemsToCollection(this.getNewItems(event), this.collection, VALUES);
}
// minimized scope of suppressed warnings
@SuppressWarnings("unchecked")
protected Iterable<E> getOldItems(ListReplaceEvent event) {
return (Iterable<E>) event.getOldItems();
}
// minimized scope of suppressed warnings
@SuppressWarnings("unchecked")
protected Iterable<E> getNewItems(ListReplaceEvent event) {
return (Iterable<E>) event.getNewItems();
}
protected void itemsMoved(@SuppressWarnings("unused") ListMoveEvent event) {
// do nothing? moving items in a list has no net effect on a collection...
}
protected void listCleared(@SuppressWarnings("unused") ListClearEvent event) {
// put in empty check so we don't fire events unnecessarily
if ( ! this.collection.isEmpty()) {
this.collection.clear();
this.fireCollectionCleared(VALUES);
}
}
/**
* synchronize our internal collection with the wrapped list
* and fire the appropriate events
*/
protected void listChanged(@SuppressWarnings("unused") ListChangeEvent event) {
if (this.listHolder.size() == 0) {
if (this.collection.isEmpty()) {
// no change
} else {
this.clearCollection(this.collection, VALUES);
}
} else {
if (this.collection.isEmpty()) {
this.buildCollection();
this.fireItemsAdded(VALUES, this.collection);
} else {
this.collection.clear();
this.buildCollection();
this.fireCollectionChanged(VALUES, this.collection);
}
}
}
protected void buildCollection() {
// if the new list is empty, do nothing
int size = this.listHolder.size();
if (size != 0) {
this.buildCollection(size);
}
}
protected void buildCollection(int size) {
this.collection.ensureCapacity(size);
for (E each : this.listHolder) {
this.collection.add(each);
}
}
@Override
public void toString(StringBuilder sb) {
sb.append(this.collection);
}
}
|
