|
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
|
|
85
|
53 private Map valueToElements;
|
|
78
|
54
|
|
|
55 // adds that need to go through the second map and thus will be picked up by
|
|
|
56 // secondMapListener.
|
|
85
|
57 private Set pendingAdds;
|
|
78
|
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.
|
|
85
|
62 private Map pendingRemoves;
|
|
78
|
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.
|
|
85
|
68 private Map pendingChanges;
|
|
78
|
69
|
|
85
|
70 private IMapChangeListener firstMapListener;
|
|
|
71 class FirstMapListener : IMapChangeListener {
|
|
78
|
72
|
|
|
73 public void handleMapChange(MapChangeEvent event) {
|
|
|
74 MapDiff diff = event.diff;
|
|
|
75 Set rangeSetAdditions = new HashSet();
|
|
|
76 Set rangeSetRemovals = new HashSet();
|
|
|
77 final Set adds = new HashSet();
|
|
|
78 final Set changes = new HashSet();
|
|
|
79 final Set removes = new HashSet();
|
|
|
80 final Map oldValues = new HashMap();
|
|
|
81
|
|
|
82 for (Iterator it = diff.getAddedKeys().iterator(); it.hasNext();) {
|
|
|
83 Object addedKey = it.next();
|
|
|
84 Object newValue = diff.getNewValue(addedKey);
|
|
|
85 addMapping(addedKey, newValue);
|
|
|
86 if (!rangeSet.contains(newValue)) {
|
|
|
87 pendingAdds.add(newValue);
|
|
|
88 rangeSetAdditions.add(newValue);
|
|
|
89 } else {
|
|
|
90 adds.add(addedKey);
|
|
|
91 wrappedMap.put(addedKey, secondMap.get(newValue));
|
|
|
92 }
|
|
|
93 }
|
|
|
94 for (Iterator it = diff.getChangedKeys().iterator(); it.hasNext();) {
|
|
|
95 Object changedKey = it.next();
|
|
|
96 Object oldValue = diff.getOldValue(changedKey);
|
|
|
97 Object newValue = diff.getNewValue(changedKey);
|
|
|
98 bool removed = removeMapping(changedKey, oldValue);
|
|
|
99 addMapping(changedKey, newValue);
|
|
|
100 bool added = !rangeSet.contains(newValue);
|
|
|
101 if (removed) {
|
|
|
102 pendingRemoves.put(oldValue, changedKey);
|
|
|
103 rangeSetRemovals.add(oldValue);
|
|
|
104 }
|
|
|
105 if (added) {
|
|
|
106 pendingAdds.add(newValue);
|
|
|
107 rangeSetAdditions.add(newValue);
|
|
|
108 }
|
|
|
109 if (added || removed) {
|
|
|
110 pendingChanges.put(oldValue, newValue);
|
|
|
111 pendingChanges.put(newValue, oldValue);
|
|
|
112 } else {
|
|
|
113 changes.add(changedKey);
|
|
|
114 oldValues.put(changedKey, oldValue);
|
|
|
115 wrappedMap.put(changedKey, secondMap.get(newValue));
|
|
|
116 }
|
|
|
117 }
|
|
|
118 for (Iterator it = diff.getRemovedKeys().iterator(); it.hasNext();) {
|
|
|
119 Object removedKey = it.next();
|
|
|
120 Object oldValue = diff.getOldValue(removedKey);
|
|
|
121 if (removeMapping(removedKey, oldValue)) {
|
|
|
122 pendingRemoves.put(oldValue, removedKey);
|
|
|
123 rangeSetRemovals.add(oldValue);
|
|
|
124 } else {
|
|
|
125 removes.add(removedKey);
|
|
|
126 oldValues.put(removedKey, secondMap.get(oldValue));
|
|
|
127 wrappedMap.remove(removedKey);
|
|
|
128 }
|
|
|
129 }
|
|
|
130
|
|
|
131 if (adds.size() > 0 || removes.size() > 0 || changes.size() > 0) {
|
|
|
132 fireMapChange(new class() MapDiff {
|
|
|
133
|
|
|
134 public Set getAddedKeys() {
|
|
|
135 return adds;
|
|
|
136 }
|
|
|
137
|
|
|
138 public Set getChangedKeys() {
|
|
|
139 return changes;
|
|
|
140 }
|
|
|
141
|
|
|
142 public Object getNewValue(Object key) {
|
|
|
143 return wrappedMap.get(key);
|
|
|
144 }
|
|
|
145
|
|
|
146 public Object getOldValue(Object key) {
|
|
|
147 return oldValues.get(key);
|
|
|
148 }
|
|
|
149
|
|
|
150 public Set getRemovedKeys() {
|
|
|
151 return removes;
|
|
|
152 }
|
|
|
153 });
|
|
|
154 }
|
|
|
155
|
|
|
156 if (rangeSetAdditions.size() > 0 || rangeSetRemovals.size() > 0) {
|
|
|
157 rangeSet.addAndRemove(rangeSetAdditions, rangeSetRemovals);
|
|
|
158 }
|
|
|
159 }
|
|
|
160 };
|
|
|
161
|
|
85
|
162 private IMapChangeListener secondMapListener;
|
|
|
163 class SecondMapListener : IMapChangeListener {
|
|
78
|
164
|
|
|
165 public void handleMapChange(MapChangeEvent event) {
|
|
|
166 MapDiff diff = event.diff;
|
|
|
167 final Set adds = new HashSet();
|
|
|
168 final Set changes = new HashSet();
|
|
|
169 final Set removes = new HashSet();
|
|
|
170 final Map oldValues = new HashMap();
|
|
|
171 final Map newValues = new HashMap();
|
|
|
172 Set addedKeys = new HashSet(diff.getAddedKeys());
|
|
|
173 Set removedKeys = new HashSet(diff.getRemovedKeys());
|
|
|
174
|
|
|
175 for (Iterator it = addedKeys.iterator(); it.hasNext();) {
|
|
|
176 Object addedKey = it.next();
|
|
|
177 Set elements = getElementsForValue(addedKey);
|
|
|
178 Object newValue = diff.getNewValue(addedKey);
|
|
|
179 if (pendingChanges.containsKey(addedKey)) {
|
|
|
180 Object oldKey = pendingChanges.remove(addedKey);
|
|
|
181 Object oldValue;
|
|
|
182 if (removedKeys.remove(oldKey)) {
|
|
|
183 oldValue = diff.getOldValue(oldKey);
|
|
|
184 } else {
|
|
|
185 oldValue = secondMap.get(oldKey);
|
|
|
186 }
|
|
|
187 pendingChanges.remove(oldKey);
|
|
|
188 pendingAdds.remove(addedKey);
|
|
|
189 pendingRemoves.remove(oldKey);
|
|
|
190 for (Iterator it2 = elements.iterator(); it2.hasNext();) {
|
|
|
191 Object element = it2.next();
|
|
|
192 changes.add(element);
|
|
|
193 oldValues.put(element, oldValue);
|
|
|
194 newValues.put(element, newValue);
|
|
|
195 wrappedMap.put(element, newValue);
|
|
|
196 }
|
|
|
197 } else if (pendingAdds.remove(addedKey)) {
|
|
|
198 for (Iterator it2 = elements.iterator(); it2.hasNext();) {
|
|
|
199 Object element = it2.next();
|
|
|
200 adds.add(element);
|
|
|
201 newValues.put(element, newValue);
|
|
|
202 wrappedMap.put(element, newValue);
|
|
|
203 }
|
|
|
204 } else {
|
|
|
205 Assert.isTrue(false, "unexpected case"); //$NON-NLS-1$
|
|
|
206 }
|
|
|
207 }
|
|
|
208 for (Iterator it = diff.getChangedKeys().iterator(); it.hasNext();) {
|
|
|
209 Object changedKey = it.next();
|
|
|
210 Set elements = getElementsForValue(changedKey);
|
|
|
211 for (Iterator it2 = elements.iterator(); it2.hasNext();) {
|
|
|
212 Object element = it2.next();
|
|
|
213 changes.add(element);
|
|
|
214 oldValues.put(element, diff.getOldValue(changedKey));
|
|
|
215 Object newValue = diff.getNewValue(changedKey);
|
|
|
216 newValues.put(element, newValue);
|
|
|
217 wrappedMap.put(element, newValue);
|
|
|
218 }
|
|
|
219 }
|
|
|
220 for (Iterator it = removedKeys.iterator(); it.hasNext();) {
|
|
|
221 Object removedKey = it.next();
|
|
|
222 Object element = pendingRemoves.remove(removedKey);
|
|
|
223 if (element !is null) {
|
|
|
224 if (pendingChanges.containsKey(removedKey)) {
|
|
|
225 Object newKey = pendingChanges.remove(removedKey);
|
|
|
226 pendingChanges.remove(newKey);
|
|
|
227 pendingAdds.remove(newKey);
|
|
|
228 pendingRemoves.remove(removedKey);
|
|
|
229 changes.add(element);
|
|
|
230 oldValues.put(element, diff.getOldValue(removedKey));
|
|
|
231 Object newValue = secondMap.get(newKey);
|
|
|
232 newValues.put(element, newValue);
|
|
|
233 wrappedMap.put(element, newValue);
|
|
|
234 } else {
|
|
|
235 removes.add(element);
|
|
|
236 Object oldValue = diff.getOldValue(removedKey);
|
|
|
237 oldValues.put(element, oldValue);
|
|
|
238 wrappedMap.remove(element);
|
|
|
239 }
|
|
|
240 } else {
|
|
|
241 Assert.isTrue(false, "unexpected case"); //$NON-NLS-1$
|
|
|
242 }
|
|
|
243 }
|
|
|
244
|
|
|
245 if (adds.size() > 0 || removes.size() > 0 || changes.size() > 0) {
|
|
|
246 fireMapChange(new class() MapDiff {
|
|
|
247
|
|
|
248 public Set getAddedKeys() {
|
|
|
249 return adds;
|
|
|
250 }
|
|
|
251
|
|
|
252 public Set getChangedKeys() {
|
|
|
253 return changes;
|
|
|
254 }
|
|
|
255
|
|
|
256 public Object getNewValue(Object key) {
|
|
|
257 return newValues.get(key);
|
|
|
258 }
|
|
|
259
|
|
|
260 public Object getOldValue(Object key) {
|
|
|
261 return oldValues.get(key);
|
|
|
262 }
|
|
|
263
|
|
|
264 public Set getRemovedKeys() {
|
|
|
265 return removes;
|
|
|
266 }
|
|
|
267 });
|
|
|
268 }
|
|
|
269 }
|
|
|
270 };
|
|
|
271
|
|
|
272 private IObservableMap firstMap;
|
|
|
273 private IObservableMap secondMap;
|
|
|
274
|
|
|
275 private static class WritableSetPlus : WritableSet {
|
|
|
276 void addAndRemove(Set additions, Set removals) {
|
|
|
277 wrappedSet.removeAll(removals);
|
|
|
278 wrappedSet.addAll(additions);
|
|
|
279 fireSetChange(Diffs.createSetDiff(additions, removals));
|
|
|
280 }
|
|
|
281 }
|
|
|
282
|
|
85
|
283 private WritableSetPlus rangeSet;
|
|
78
|
284
|
|
|
285 /**
|
|
|
286 * Creates a new composite map. Because the key set of the second map is
|
|
|
287 * determined by the value set of the given observable map
|
|
|
288 * <code>firstMap</code>, it cannot be passed in as an argument. Instead,
|
|
|
289 * the second map will be created by calling
|
|
|
290 * <code>secondMapFactory.createObservable(valueSet())</code>.
|
|
|
291 *
|
|
|
292 * @param firstMap
|
|
|
293 * the first map
|
|
|
294 * @param secondMapFactory
|
|
|
295 * a factory that creates the second map when given an observable
|
|
|
296 * set representing the value set of <code>firstMap</code>.
|
|
|
297 */
|
|
|
298 public this(IObservableMap firstMap,
|
|
|
299 IObservableFactory secondMapFactory) {
|
|
85
|
300 valueToElements = new HashMap();
|
|
|
301 pendingAdds = new HashSet();
|
|
|
302 pendingRemoves = new HashMap();
|
|
|
303 pendingChanges = new HashMap();
|
|
|
304 firstMapListener = new FirstMapListener();
|
|
|
305 secondMapListener = new SecondMapListener();
|
|
|
306 rangeSet = new WritableSetPlus();
|
|
78
|
307 super(firstMap.getRealm(), new HashMap());
|
|
|
308 this.firstMap = firstMap;
|
|
|
309 firstMap.addMapChangeListener(firstMapListener);
|
|
|
310 for (Iterator it = firstMap.entrySet().iterator(); it.hasNext();) {
|
|
|
311 Map.Entry entry = cast(Entry) it.next();
|
|
|
312 addMapping(entry.getKey(), entry.getValue());
|
|
|
313 rangeSet.add(entry.getValue());
|
|
|
314 }
|
|
|
315 this.secondMap = cast(IObservableMap) secondMapFactory
|
|
|
316 .createObservable(rangeSet);
|
|
|
317 secondMap.addMapChangeListener(secondMapListener);
|
|
|
318 for (Iterator it = firstMap.entrySet().iterator(); it.hasNext();) {
|
|
|
319 Map.Entry entry = cast(Entry) it.next();
|
|
|
320 wrappedMap.put(entry.getKey(), secondMap.get(entry.getValue()));
|
|
|
321 }
|
|
|
322 }
|
|
|
323
|
|
|
324 /**
|
|
|
325 * @param key
|
|
|
326 * @param value
|
|
|
327 */
|
|
|
328 private void addMapping(Object key, Object value) {
|
|
|
329 Object elementOrSet = valueToElements.get(value);
|
|
|
330 if (elementOrSet is null) {
|
|
|
331 valueToElements.put(value, key);
|
|
|
332 return;
|
|
|
333 }
|
|
|
334 if (!( null !is cast(Set)elementOrSet )) {
|
|
|
335 elementOrSet = new HashSet(Collections.singleton(elementOrSet));
|
|
|
336 valueToElements.put(value, elementOrSet);
|
|
|
337 }
|
|
|
338 Set set = cast(Set) elementOrSet;
|
|
|
339 set.add(key);
|
|
|
340 }
|
|
|
341
|
|
|
342 /**
|
|
|
343 * @param key
|
|
|
344 * @param value
|
|
|
345 */
|
|
|
346 private bool removeMapping(Object key, Object value) {
|
|
|
347 Object elementOrSet = valueToElements.get(value);
|
|
|
348 if ( null !is cast(Set)elementOrSet ) {
|
|
|
349 Set set = cast(Set) elementOrSet;
|
|
|
350 set.remove(key);
|
|
|
351 if (set.size() is 0) {
|
|
|
352 valueToElements.remove(value);
|
|
|
353 return true;
|
|
|
354 }
|
|
|
355 return false;
|
|
|
356 }
|
|
|
357 valueToElements.remove(value);
|
|
|
358 return true;
|
|
|
359 }
|
|
|
360
|
|
|
361 private Set getElementsForValue(Object value) {
|
|
|
362 Object elementOrSet = valueToElements.get(value);
|
|
|
363 if ( null !is cast(Set)elementOrSet ) {
|
|
|
364 return cast(Set) elementOrSet;
|
|
|
365 }
|
|
|
366 return elementOrSet is null ? Collections.EMPTY_SET : Collections
|
|
|
367 .singleton(elementOrSet);
|
|
|
368 }
|
|
|
369
|
|
|
370 public synchronized void dispose() {
|
|
|
371 super.dispose();
|
|
|
372 firstMap.removeMapChangeListener(firstMapListener);
|
|
|
373 firstMap = null;
|
|
|
374 secondMap = null;
|
|
|
375 }
|
|
|
376
|
|
|
377 }
|
