--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.eclipse.jface.databinding/src/org/eclipse/jface/internal/databinding/viewers/ViewerElementMap.d	Tue Apr 14 11:35:29 2009 +0200
@@ -0,0 +1,434 @@
+/*******************************************************************************
+ * Copyright (c) 2008 Matthew Hall and others.
+ * 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:
+ *     Matthew Hall - initial API and implementation (bug 215531)
+ *     Matthew Hall - bug 228125
+ ******************************************************************************/
+
+module org.eclipse.jface.internal.databinding.viewers.ViewerElementMap;
+
+import java.lang.all;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.jface.util.Util;
+import org.eclipse.jface.viewers.IElementComparer;
+import org.eclipse.jface.viewers.StructuredViewer;
+
+/**
+ * A {@link Map} whose keys are elements in a {@link StructuredViewer}. The
+ * keys in the map are compared using an {@link IElementComparer} instead of
+ * {@link #equals(Object)}.
+ * <p>
+ * This class is <i>not</i> a strict implementation the {@link Map} interface.
+ * It intentionally violates the {@link Map} contract, which requires the use of
+ * {@link #equals(Object)} when comparing keys. This class is designed for use
+ * with {@link StructuredViewer} which uses {@link IElementComparer} for element
+ * comparisons.
+ * 
+ * @since 1.2
+ */
+public class ViewerElementMap : Map { 
+    private Map wrappedMap;
+    private IElementComparer comparer;
+
+    /**
+     * Constructs a ViewerElementMap using the given {@link IElementComparer}.
+     * 
+     * @param comparer
+     *            the {@link IElementComparer} used for comparing keys.
+     */
+    public this(IElementComparer comparer) {
+        Assert.isNotNull(comparer);
+        this.wrappedMap = new HashMap();
+        this.comparer = comparer;
+    }
+
+    /**
+     * Constructs a ViewerElementMap containing all the entries in the specified
+     * map.
+     * 
+     * @param map
+     *            the map whose entries are to be added to this map.
+     * @param comparer
+     *            the {@link IElementComparer} used for comparing keys.
+     */
+    public this(Map map, IElementComparer comparer) {
+        this(comparer);
+        Assert.isNotNull(map);
+        putAll(map);
+    }
+
+    public void clear() {
+        wrappedMap.clear();
+    }
+
+    public bool containsKey(Object key) {
+        return wrappedMap.containsKey(new ViewerElementWrapper(key, comparer));
+    }
+
+    public bool containsValue(Object value) {
+        return wrappedMap.containsValue(value);
+    }
+
+    public Set entrySet() {
+        final Set wrappedEntrySet = wrappedMap.entrySet();
+        return new class() Set {
+            public bool add(Object o) {
+                throw new UnsupportedOperationException();
+            }
+
+            public bool addAll(Collection c) {
+                throw new UnsupportedOperationException();
+            }
+
+            public void clear() {
+                wrappedEntrySet.clear();
+            }
+
+            public bool contains(Object o) {
+                for (Iterator iterator = iterator(); iterator.hasNext();)
+                    if (iterator.next().equals(o))
+                        return true;
+                return false;
+            }
+
+            public bool containsAll(Collection c) {
+                for (Iterator iterator = c.iterator(); iterator.hasNext();)
+                    if (!contains(iterator.next()))
+                        return false;
+                return true;
+            }
+
+            public bool isEmpty() {
+                return wrappedEntrySet.isEmpty();
+            }
+
+            public Iterator iterator() {
+                final Iterator wrappedIterator = wrappedEntrySet.iterator();
+                return new class() Iterator {
+                    public bool hasNext() {
+                        return wrappedIterator.hasNext();
+                    }
+
+                    public Object next() {
+                        Map.Entry wrappedEntry = cast(Map.Entry) wrappedIterator
+                                .next();
+                        return new class() Map.Entry {
+                            public Object getKey() {
+                                return (cast(ViewerElementWrapper) wrappedEntry.getKey())
+                                        .unwrap();
+                            }
+
+                            public Object getValue() {
+                                return wrappedEntry.getValue();
+                            }
+
+                            public Object setValue(Object value) {
+                                return wrappedEntry.setValue(value);
+                            }
+
+                            public bool equals(Object obj) {
+                                if (obj is this)
+                                    return true;
+                                if (obj is null || !(null !is cast(Map.Entry)obj))
+                                    return false;
+                                Map.Entry that = cast(Map.Entry) obj;
+                                return comparer.equals(this.getKey(), that
+                                        .getKey())
+                                        && Util.equals(this.getValue(), that
+                                                .getValue());
+                            }
+
+                            public int hashCode() {
+                                return wrappedEntry.hashCode();
+                            }
+                        };
+                    }
+
+                    public void remove() {
+                        wrappedIterator.remove();
+                    }
+                };
+            }
+
+            public bool remove(Object o) {
+                Map.Entry unwrappedEntry = cast(Map.Entry) o;
+                final ViewerElementWrapper wrappedKey = new ViewerElementWrapper(
+                        unwrappedEntry.getKey(), comparer);
+                Map.Entry wrappedEntry = new class() Map.Entry {
+                    public Object getKey() {
+                        return wrappedKey;
+                    }
+
+                    public Object getValue() {
+                        return unwrappedEntry.getValue();
+                    }
+
+                    public Object setValue(Object value) {
+                        throw new UnsupportedOperationException();
+                    }
+
+                    public bool equals(Object obj) {
+                        if (obj is this)
+                            return true;
+                        if (obj is null || !(null !is cast(Map.Entry)obj))
+                            return false;
+                        Map.Entry that = cast(Map.Entry) obj;
+                        return Util.equals(wrappedKey, that.getKey())
+                                && Util
+                                        .equals(this.getValue(), that
+                                                .getValue());
+                    }
+
+                    public int hashCode() {
+                        return wrappedKey.hashCode()
+                                ^ (getValue() is null ? 0 : getValue()
+                                        .hashCode());
+                    }
+                };
+                return wrappedEntrySet.remove(wrappedEntry);
+            }
+
+            public bool removeAll(Collection c) {
+                bool changed = false;
+                for (Iterator iterator = c.iterator(); iterator.hasNext();)
+                    changed |= remove(iterator.next());
+                return changed;
+            }
+
+            public bool retainAll(Collection c) {
+                bool changed = false;
+                Object[] toRetain = c.toArray();
+                outer: for (Iterator iterator = iterator(); iterator.hasNext();) {
+                    Object entry = iterator.next();
+                    for (int i = 0; i < toRetain.length; i++)
+                        if (entry.equals(toRetain[i]))
+                            continue outer;
+                    iterator.remove();
+                    changed = true;
+                }
+                return changed;
+            }
+
+            public int size() {
+                return wrappedEntrySet.size();
+            }
+
+            public Object[] toArray() {
+                return toArray(new Object[size()]);
+            }
+
+            public Object[] toArray(Object[] a) {
+                int size = size();
+                if (a.length < size) {
+                    a = cast(Object[]) Array.newInstance(a.getClass()
+                            .getComponentType(), size);
+                }
+                int i = 0;
+                for (Iterator iterator = iterator(); iterator.hasNext();) {
+                    a[i] = iterator.next();
+                    i++;
+                }
+                return a;
+            }
+
+            public bool equals(Object obj) {
+                if (obj is this)
+                    return true;
+                if (obj is null || !(null !is cast(Set)obj))
+                    return false;
+                Set that = cast(Set) obj;
+                return this.size() is that.size() && containsAll(that);
+            }
+
+            public int hashCode() {
+                return wrappedEntrySet.hashCode();
+            }
+        };
+    }
+
+    public Object get(Object key) {
+        return wrappedMap.get(new ViewerElementWrapper(key, comparer));
+    }
+
+    public bool isEmpty() {
+        return wrappedMap.isEmpty();
+    }
+
+    public Set keySet() {
+        final Set wrappedKeySet = wrappedMap.keySet();
+        return new class() Set {
+            public bool add(Object o) {
+                throw new UnsupportedOperationException();
+            }
+
+            public bool addAll(Collection c) {
+                throw new UnsupportedOperationException();
+            }
+
+            public void clear() {
+                wrappedKeySet.clear();
+            }
+
+            public bool contains(Object o) {
+                return wrappedKeySet.contains(new ViewerElementWrapper(o, comparer));
+            }
+
+            public bool containsAll(Collection c) {
+                for (Iterator iterator = c.iterator(); iterator.hasNext();)
+                    if (!wrappedKeySet.contains(new ViewerElementWrapper(iterator.next(), comparer)))
+                        return false;
+                return true;
+            }
+
+            public bool isEmpty() {
+                return wrappedKeySet.isEmpty();
+            }
+
+            public Iterator iterator() {
+                final Iterator wrappedIterator = wrappedKeySet.iterator();
+                return new class() Iterator {
+                    public bool hasNext() {
+                        return wrappedIterator.hasNext();
+                    }
+
+                    public Object next() {
+                        return (cast(ViewerElementWrapper) wrappedIterator.next()).unwrap();
+                    }
+
+                    public void remove() {
+                        wrappedIterator.remove();
+                    }
+                };
+            }
+
+            public bool remove(Object o) {
+                return wrappedKeySet.remove(new ViewerElementWrapper(o, comparer));
+            }
+
+            public bool removeAll(Collection c) {
+                bool changed = false;
+                for (Iterator iterator = c.iterator(); iterator.hasNext();)
+                    changed |= wrappedKeySet
+                            .remove(new ViewerElementWrapper(iterator.next(), comparer));
+                return changed;
+            }
+
+            public bool retainAll(Collection c) {
+                bool changed = false;
+                Object[] toRetain = c.toArray();
+                outer: for (Iterator iterator = iterator(); iterator.hasNext();) {
+                    Object element = iterator.next();
+                    for (int i = 0; i < toRetain.length; i++)
+                        if (comparer.equals(element, toRetain[i]))
+                            continue outer;
+                    // element not contained in collection, remove.
+                    remove(element);
+                    changed = true;
+                }
+                return changed;
+            }
+
+            public int size() {
+                return wrappedKeySet.size();
+            }
+
+            public Object[] toArray() {
+                return toArray(new Object[wrappedKeySet.size()]);
+            }
+
+            public Object[] toArray(Object[] a) {
+                int size = wrappedKeySet.size();
+                ViewerElementWrapper[] wrappedArray = cast(ViewerElementWrapper[]) wrappedKeySet
+                        .toArray(new ViewerElementWrapper[size]);
+                Object[] result = a;
+                if (a.length < size) {
+                    result = cast(Object[]) Array.newInstance(a.getClass()
+                            .getComponentType(), size);
+                }
+                for (int i = 0; i < size; i++)
+                    result[i] = wrappedArray[i].unwrap();
+                return result;
+            }
+
+            public bool equals(Object obj) {
+                if (obj is this)
+                    return true;
+                if (obj is null || !(null !is cast(Set)obj))
+                    return false;
+                Set that = cast(Set) obj;
+                return this.size() is that.size() && containsAll(that);
+            }
+
+            public int hashCode() {
+                return wrappedKeySet.hashCode();
+            }
+        };
+    }
+
+    public Object put(Object key, Object value) {
+        return wrappedMap.put(new ViewerElementWrapper(key, comparer), value);
+    }
+
+    public void putAll(Map other) {
+        for (Iterator iterator = other.entrySet().iterator(); iterator
+                .hasNext();) {
+            Map.Entry entry = cast(Map.Entry) iterator.next();
+            wrappedMap.put(new ViewerElementWrapper(entry.getKey(), comparer), entry.getValue());
+        }
+    }
+
+    public Object remove(Object key) {
+        return wrappedMap.remove(new ViewerElementWrapper(key, comparer));
+    }
+
+    public int size() {
+        return wrappedMap.size();
+    }
+
+    public Collection values() {
+        return wrappedMap.values();
+    }
+
+    public bool equals(Object obj) {
+        if (obj is this)
+            return true;
+        if (obj is null || !(null !is cast(Map)obj))
+            return false;
+        Map that = cast(Map) obj;
+        return this.entrySet().equals(that.entrySet());
+    }
+
+    public int hashCode() {
+        return wrappedMap.hashCode();
+    }
+
+    /**
+     * Returns a Map for mapping viewer elements as keys to values, using the
+     * given {@link IElementComparer} for key comparisons.
+     * 
+     * @param comparer
+     *            the element comparer to use in key comparisons. If null, the
+     *            returned map will compare keys according to the standard
+     *            contract for {@link Map} interface contract.
+     * @return a Map for mapping viewer elements as keys to values, using the
+     *         given {@link IElementComparer} for key comparisons.
+     */
+    public static Map withComparer(IElementComparer comparer) {
+        if (comparer is null)
+            return new HashMap();
+        return new ViewerElementMap(comparer);
+    }
+}