|
78
|
1 /*******************************************************************************
|
|
|
2 * Copyright (c) 2006, 2008 IBM Corporation and others.
|
|
|
3 * All rights reserved. This program and the accompanying materials
|
|
|
4 * are made available under the terms of the Eclipse Public License v1.0
|
|
|
5 * which accompanies this distribution, and is available at
|
|
|
6 * http://www.eclipse.org/legal/epl-v10.html
|
|
|
7 *
|
|
|
8 * Contributors:
|
|
|
9 * IBM Corporation - initial API and implementation
|
|
|
10 *******************************************************************************/
|
|
|
11 module org.eclipse.core.databinding.observable.map.CompositeMap;
|
|
81
|
12 import org.eclipse.core.databinding.observable.map.MapDiff;
|
|
|
13 import org.eclipse.core.databinding.observable.map.ObservableMap;
|
|
|
14 import org.eclipse.core.databinding.observable.map.MapChangeEvent;
|
|
|
15 import org.eclipse.core.databinding.observable.map.IMapChangeListener;
|
|
|
16 import org.eclipse.core.databinding.observable.map.IObservableMap;
|
|
78
|
17
|
|
|
18 import java.lang.all;
|
|
|
19
|
|
|
20 import java.util.Collections;
|
|
|
21 import java.util.HashMap;
|
|
|
22 import java.util.HashSet;
|
|
|
23 import java.util.Iterator;
|
|
|
24 import java.util.Map;
|
|
|
25 import java.util.Set;
|
|
|
26
|
|
|
27 import org.eclipse.core.databinding.observable.Diffs;
|
|
|
28 import org.eclipse.core.databinding.observable.Realm;
|
|
|
29 import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
|
|
|
30 import org.eclipse.core.databinding.observable.set.WritableSet;
|
|
|
31 import org.eclipse.core.runtime.Assert;
|
|
|
32
|
|
|
33 /**
|
|
|
34 * A read-only observable map formed by the composition of two observable maps.
|
|
|
35 * If map1 maps keys a:A to values b1:B, and map2 maps keys b2:B to values c:C,
|
|
|
36 * the composite map maps keys a:A to values c:C. For example, map1 could map
|
|
|
37 * Order objects to their corresponding Customer objects, and map2 could map
|
|
|
38 * Customer objects to their "last name" property of type String. The composite
|
|
|
39 * map of map1 and map2 would then map Order objects to their customers' last
|
|
|
40 * names.
|
|
|
41 *
|
|
|
42 * <p>
|
|
|
43 * This class is thread safe. All state accessing methods must be invoked from
|
|
|
44 * the {@link Realm#isCurrent() current realm}. Methods for adding and removing
|
|
|
45 * listeners may be invoked from any thread.
|
|
|
46 * </p>
|
|
|
47 *
|
|
|
48 * @since 1.1
|
|
|
49 *
|
|
|
50 */
|
|
|
51 public class CompositeMap : ObservableMap {
|
|
|
52
|
|
|
53 private Map valueToElements = new HashMap();
|
|
|
54
|
|
|
55 // adds that need to go through the second map and thus will be picked up by
|
|
|
56 // secondMapListener.
|
|
|
57 private Set pendingAdds = new HashSet();
|
|
|
58
|
|
|
59 // Removes that need to go through the second map and thus will be picked up
|
|
|
60 // by
|
|
|
61 // secondMapListener. Maps from value being removed to key being removed.
|
|
|
62 private Map pendingRemoves = new HashMap();
|
|
|
63
|
|
|
64 // Changes that need to go through the second map and thus will be picked up
|
|
|
65 // by
|
|
|
66 // secondMapListener. Maps from old value to new value and new value to old
|
|
|
67 // value.
|
|
|
68 private Map pendingChanges = new HashMap();
|
|
|
69
|
|
|
70 private IMapChangeListener firstMapListener = new class() IMapChangeListener {
|
|
|
71
|
|
|
72 public void handleMapChange(MapChangeEvent event) {
|
|
|
73 MapDiff diff = event.diff;
|
|
|
74 Set rangeSetAdditions = new HashSet();
|
|
|
75 Set rangeSetRemovals = new HashSet();
|
|
|
76 final Set adds = new HashSet();
|
|
|
77 final Set changes = new HashSet();
|
|
|
78 final Set removes = new HashSet();
|
|
|
79 final Map oldValues = new HashMap();
|
|
|
80
|
|
|
81 for (Iterator it = diff.getAddedKeys().iterator(); it.hasNext();) {
|
|
|
82 Object addedKey = it.next();
|
|
|
83 Object newValue = diff.getNewValue(addedKey);
|
|
|
84 addMapping(addedKey, newValue);
|
|
|
85 if (!rangeSet.contains(newValue)) {
|
|
|
86 pendingAdds.add(newValue);
|
|
|
87 rangeSetAdditions.add(newValue);
|
|
|
88 } else {
|
|
|
89 adds.add(addedKey);
|
|
|
90 wrappedMap.put(addedKey, secondMap.get(newValue));
|
|
|
91 }
|
|
|
92 }
|
|
|
93 for (Iterator it = diff.getChangedKeys().iterator(); it.hasNext();) {
|
|
|
94 Object changedKey = it.next();
|
|
|
95 Object oldValue = diff.getOldValue(changedKey);
|
|
|
96 Object newValue = diff.getNewValue(changedKey);
|
|
|
97 bool removed = removeMapping(changedKey, oldValue);
|
|
|
98 addMapping(changedKey, newValue);
|
|
|
99 bool added = !rangeSet.contains(newValue);
|
|
|
100 if (removed) {
|
|
|
101 pendingRemoves.put(oldValue, changedKey);
|
|
|
102 rangeSetRemovals.add(oldValue);
|
|
|
103 }
|
|
|
104 if (added) {
|
|
|
105 pendingAdds.add(newValue);
|
|
|
106 rangeSetAdditions.add(newValue);
|
|
|
107 }
|
|
|
108 if (added || removed) {
|
|
|
109 pendingChanges.put(oldValue, newValue);
|
|
|
110 pendingChanges.put(newValue, oldValue);
|
|
|
111 } else {
|
|
|
112 changes.add(changedKey);
|
|
|
113 oldValues.put(changedKey, oldValue);
|
|
|
114 wrappedMap.put(changedKey, secondMap.get(newValue));
|
|
|
115 }
|
|
|
116 }
|
|
|
117 for (Iterator it = diff.getRemovedKeys().iterator(); it.hasNext();) {
|
|
|
118 Object removedKey = it.next();
|
|
|
119 Object oldValue = diff.getOldValue(removedKey);
|
|
|
120 if (removeMapping(removedKey, oldValue)) {
|
|
|
121 pendingRemoves.put(oldValue, removedKey);
|
|
|
122 rangeSetRemovals.add(oldValue);
|
|
|
123 } else {
|
|
|
124 removes.add(removedKey);
|
|
|
125 oldValues.put(removedKey, secondMap.get(oldValue));
|
|
|
126 wrappedMap.remove(removedKey);
|
|
|
127 }
|
|
|
128 }
|
|
|
129
|
|
|
130 if (adds.size() > 0 || removes.size() > 0 || changes.size() > 0) {
|
|
|
131 fireMapChange(new class() MapDiff {
|
|
|
132
|
|
|
133 public Set getAddedKeys() {
|
|
|
134 return adds;
|
|
|
135 }
|
|
|
136
|
|
|
137 public Set getChangedKeys() {
|
|
|
138 return changes;
|
|
|
139 }
|
|
|
140
|
|
|
141 public Object getNewValue(Object key) {
|
|
|
142 return wrappedMap.get(key);
|
|
|
143 }
|
|
|
144
|
|
|
145 public Object getOldValue(Object key) {
|
|
|
146 return oldValues.get(key);
|
|
|
147 }
|
|
|
148
|
|
|
149 public Set getRemovedKeys() {
|
|
|
150 return removes;
|
|
|
151 }
|
|
|
152 });
|
|
|
153 }
|
|
|
154
|
|
|
155 if (rangeSetAdditions.size() > 0 || rangeSetRemovals.size() > 0) {
|
|
|
156 rangeSet.addAndRemove(rangeSetAdditions, rangeSetRemovals);
|
|
|
157 }
|
|
|
158 }
|
|
|
159 };
|
|
|
160
|
|
|
161 private IMapChangeListener secondMapListener = new class() IMapChangeListener {
|
|
|
162
|
|
|
163 public void handleMapChange(MapChangeEvent event) {
|
|
|
164 MapDiff diff = event.diff;
|
|
|
165 final Set adds = new HashSet();
|
|
|
166 final Set changes = new HashSet();
|
|
|
167 final Set removes = new HashSet();
|
|
|
168 final Map oldValues = new HashMap();
|
|
|
169 final Map newValues = new HashMap();
|
|
|
170 Set addedKeys = new HashSet(diff.getAddedKeys());
|
|
|
171 Set removedKeys = new HashSet(diff.getRemovedKeys());
|
|
|
172
|
|
|
173 for (Iterator it = addedKeys.iterator(); it.hasNext();) {
|
|
|
174 Object addedKey = it.next();
|
|
|
175 Set elements = getElementsForValue(addedKey);
|
|
|
176 Object newValue = diff.getNewValue(addedKey);
|
|
|
177 if (pendingChanges.containsKey(addedKey)) {
|
|
|
178 Object oldKey = pendingChanges.remove(addedKey);
|
|
|
179 Object oldValue;
|
|
|
180 if (removedKeys.remove(oldKey)) {
|
|
|
181 oldValue = diff.getOldValue(oldKey);
|
|
|
182 } else {
|
|
|
183 oldValue = secondMap.get(oldKey);
|
|
|
184 }
|
|
|
185 pendingChanges.remove(oldKey);
|
|
|
186 pendingAdds.remove(addedKey);
|
|
|
187 pendingRemoves.remove(oldKey);
|
|
|
188 for (Iterator it2 = elements.iterator(); it2.hasNext();) {
|
|
|
189 Object element = it2.next();
|
|
|
190 changes.add(element);
|
|
|
191 oldValues.put(element, oldValue);
|
|
|
192 newValues.put(element, newValue);
|
|
|
193 wrappedMap.put(element, newValue);
|
|
|
194 }
|
|
|
195 } else if (pendingAdds.remove(addedKey)) {
|
|
|
196 for (Iterator it2 = elements.iterator(); it2.hasNext();) {
|
|
|
197 Object element = it2.next();
|
|
|
198 adds.add(element);
|
|
|
199 newValues.put(element, newValue);
|
|
|
200 wrappedMap.put(element, newValue);
|
|
|
201 }
|
|
|
202 } else {
|
|
|
203 Assert.isTrue(false, "unexpected case"); //$NON-NLS-1$
|
|
|
204 }
|
|
|
205 }
|
|
|
206 for (Iterator it = diff.getChangedKeys().iterator(); it.hasNext();) {
|
|
|
207 Object changedKey = it.next();
|
|
|
208 Set elements = getElementsForValue(changedKey);
|
|
|
209 for (Iterator it2 = elements.iterator(); it2.hasNext();) {
|
|
|
210 Object element = it2.next();
|
|
|
211 changes.add(element);
|
|
|
212 oldValues.put(element, diff.getOldValue(changedKey));
|
|
|
213 Object newValue = diff.getNewValue(changedKey);
|
|
|
214 newValues.put(element, newValue);
|
|
|
215 wrappedMap.put(element, newValue);
|
|
|
216 }
|
|
|
217 }
|
|
|
218 for (Iterator it = removedKeys.iterator(); it.hasNext();) {
|
|
|
219 Object removedKey = it.next();
|
|
|
220 Object element = pendingRemoves.remove(removedKey);
|
|
|
221 if (element !is null) {
|
|
|
222 if (pendingChanges.containsKey(removedKey)) {
|
|
|
223 Object newKey = pendingChanges.remove(removedKey);
|
|
|
224 pendingChanges.remove(newKey);
|
|
|
225 pendingAdds.remove(newKey);
|
|
|
226 pendingRemoves.remove(removedKey);
|
|
|
227 changes.add(element);
|
|
|
228 oldValues.put(element, diff.getOldValue(removedKey));
|
|
|
229 Object newValue = secondMap.get(newKey);
|
|
|
230 newValues.put(element, newValue);
|
|
|
231 wrappedMap.put(element, newValue);
|
|
|
232 } else {
|
|
|
233 removes.add(element);
|
|
|
234 Object oldValue = diff.getOldValue(removedKey);
|
|
|
235 oldValues.put(element, oldValue);
|
|
|
236 wrappedMap.remove(element);
|
|
|
237 }
|
|
|
238 } else {
|
|
|
239 Assert.isTrue(false, "unexpected case"); //$NON-NLS-1$
|
|
|
240 }
|
|
|
241 }
|
|
|
242
|
|
|
243 if (adds.size() > 0 || removes.size() > 0 || changes.size() > 0) {
|
|
|
244 fireMapChange(new class() MapDiff {
|
|
|
245
|
|
|
246 public Set getAddedKeys() {
|
|
|
247 return adds;
|
|
|
248 }
|
|
|
249
|
|
|
250 public Set getChangedKeys() {
|
|
|
251 return changes;
|
|
|
252 }
|
|
|
253
|
|
|
254 public Object getNewValue(Object key) {
|
|
|
255 return newValues.get(key);
|
|
|
256 }
|
|
|
257
|
|
|
258 public Object getOldValue(Object key) {
|
|
|
259 return oldValues.get(key);
|
|
|
260 }
|
|
|
261
|
|
|
262 public Set getRemovedKeys() {
|
|
|
263 return removes;
|
|
|
264 }
|
|
|
265 });
|
|
|
266 }
|
|
|
267 }
|
|
|
268 };
|
|
|
269
|
|
|
270 private IObservableMap firstMap;
|
|
|
271 private IObservableMap secondMap;
|
|
|
272
|
|
|
273 private static class WritableSetPlus : WritableSet {
|
|
|
274 void addAndRemove(Set additions, Set removals) {
|
|
|
275 wrappedSet.removeAll(removals);
|
|
|
276 wrappedSet.addAll(additions);
|
|
|
277 fireSetChange(Diffs.createSetDiff(additions, removals));
|
|
|
278 }
|
|
|
279 }
|
|
|
280
|
|
|
281 private WritableSetPlus rangeSet = new WritableSetPlus();
|
|
|
282
|
|
|
283 /**
|
|
|
284 * Creates a new composite map. Because the key set of the second map is
|
|
|
285 * determined by the value set of the given observable map
|
|
|
286 * <code>firstMap</code>, it cannot be passed in as an argument. Instead,
|
|
|
287 * the second map will be created by calling
|
|
|
288 * <code>secondMapFactory.createObservable(valueSet())</code>.
|
|
|
289 *
|
|
|
290 * @param firstMap
|
|
|
291 * the first map
|
|
|
292 * @param secondMapFactory
|
|
|
293 * a factory that creates the second map when given an observable
|
|
|
294 * set representing the value set of <code>firstMap</code>.
|
|
|
295 */
|
|
|
296 public this(IObservableMap firstMap,
|
|
|
297 IObservableFactory secondMapFactory) {
|
|
|
298 super(firstMap.getRealm(), new HashMap());
|
|
|
299 this.firstMap = firstMap;
|
|
|
300 firstMap.addMapChangeListener(firstMapListener);
|
|
|
301 for (Iterator it = firstMap.entrySet().iterator(); it.hasNext();) {
|
|
|
302 Map.Entry entry = cast(Entry) it.next();
|
|
|
303 addMapping(entry.getKey(), entry.getValue());
|
|
|
304 rangeSet.add(entry.getValue());
|
|
|
305 }
|
|
|
306 this.secondMap = cast(IObservableMap) secondMapFactory
|
|
|
307 .createObservable(rangeSet);
|
|
|
308 secondMap.addMapChangeListener(secondMapListener);
|
|
|
309 for (Iterator it = firstMap.entrySet().iterator(); it.hasNext();) {
|
|
|
310 Map.Entry entry = cast(Entry) it.next();
|
|
|
311 wrappedMap.put(entry.getKey(), secondMap.get(entry.getValue()));
|
|
|
312 }
|
|
|
313 }
|
|
|
314
|
|
|
315 /**
|
|
|
316 * @param key
|
|
|
317 * @param value
|
|
|
318 */
|
|
|
319 private void addMapping(Object key, Object value) {
|
|
|
320 Object elementOrSet = valueToElements.get(value);
|
|
|
321 if (elementOrSet is null) {
|
|
|
322 valueToElements.put(value, key);
|
|
|
323 return;
|
|
|
324 }
|
|
|
325 if (!( null !is cast(Set)elementOrSet )) {
|
|
|
326 elementOrSet = new HashSet(Collections.singleton(elementOrSet));
|
|
|
327 valueToElements.put(value, elementOrSet);
|
|
|
328 }
|
|
|
329 Set set = cast(Set) elementOrSet;
|
|
|
330 set.add(key);
|
|
|
331 }
|
|
|
332
|
|
|
333 /**
|
|
|
334 * @param key
|
|
|
335 * @param value
|
|
|
336 */
|
|
|
337 private bool removeMapping(Object key, Object value) {
|
|
|
338 Object elementOrSet = valueToElements.get(value);
|
|
|
339 if ( null !is cast(Set)elementOrSet ) {
|
|
|
340 Set set = cast(Set) elementOrSet;
|
|
|
341 set.remove(key);
|
|
|
342 if (set.size() is 0) {
|
|
|
343 valueToElements.remove(value);
|
|
|
344 return true;
|
|
|
345 }
|
|
|
346 return false;
|
|
|
347 }
|
|
|
348 valueToElements.remove(value);
|
|
|
349 return true;
|
|
|
350 }
|
|
|
351
|
|
|
352 private Set getElementsForValue(Object value) {
|
|
|
353 Object elementOrSet = valueToElements.get(value);
|
|
|
354 if ( null !is cast(Set)elementOrSet ) {
|
|
|
355 return cast(Set) elementOrSet;
|
|
|
356 }
|
|
|
357 return elementOrSet is null ? Collections.EMPTY_SET : Collections
|
|
|
358 .singleton(elementOrSet);
|
|
|
359 }
|
|
|
360
|
|
|
361 public synchronized void dispose() {
|
|
|
362 super.dispose();
|
|
|
363 firstMap.removeMapChangeListener(firstMapListener);
|
|
|
364 firstMap = null;
|
|
|
365 secondMap = null;
|
|
|
366 }
|
|
|
367
|
|
|
368 }
|
