Make DoubleMap implement Map interface.

Depends-On: I69c5fd43b97244343b824aa7c2cf1d8bb71ba741

Change-Id: Ied8d9e0cf06819326a469e715c6925af8fd22b5a
Reviewed-on: http://gerrit.dmdirc.com/1851
Automatic-Compile: DMDirc Local Commits <dmdirc@googlemail.com>
Reviewed-by: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/util/DoubleMap.java

@@ -21,77 +21,143 @@
  */
 package com.dmdirc.util;
 
+import java.util.AbstractMap.SimpleEntry;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
 
 /**
  * An object that maps keys to values, and values back to keys. Currently
  * does no checking for duplicates. Does not allow null values.
- * 
+ *
  * @param <A> The first type of data to be mapped
- * @param <B> The second type of data to be mapped 
- * @author chris
+ * @param <B> The second type of data to be mapped
  */
-public class DoubleMap<A,B> {
-    
+public class DoubleMap<A,B> implements Map<A,B> {
+
     /** The keys in this map. */
     protected final List<A> keys = new ArrayList<A>();
     /** The values in this map. */
     protected final List<B> values = new ArrayList<B>();
-    
-    /**
-     * Adds the specified pair to this map.
-     * 
-     * @param key The key for the map
-     * @param value The value for the map
-     */
-    public void put(final A key, final B value) {
-        if (key == null || value == null) {
-            throw new NullPointerException();
-        }
-        
-        keys.add(key);
-        values.add(value);
-    }
-    
+
     /**
      * Retrieves the value associated with the specified key.
-     * 
-     * @param key The key to search for 
+     *
+     * @param key The key to search for
      * @return The value of the specified key
      */
     public B getValue(final A key) {
+        if (keys.indexOf(key) == -1) {
+            return null;
+        }
         return values.get(keys.indexOf(key));
     }
-    
+
     /**
      * Retrieves the key associated with the specified value.
-     * 
+     *
      * @param value The value to search for
      * @return The key of the specified value
      */
     public A getKey(final B value) {
+        if (values.indexOf(value) == -1) {
+            return null;
+        }
         return keys.get(values.indexOf(value));
     }
-    
-    /**
-     * Retrieves the set of keys in this double map.
-     * 
-     * @return This map's key set
-     */
+
+    /** {@inheritDoc} */
+    @Override
+    public B put(final A key, final B value) {
+        if (key == null || value == null) {
+            throw new NullPointerException();
+        }
+
+        keys.add(key);
+        values.add(value);
+
+        return value;
+    }
+
+    /** {@inheritDoc} */
+    @Override
     public Set<A> keySet() {
         return new HashSet<A>(keys);
     }
-    
-    /**
-     * Retrieves the set of values in this double map.
-     * 
-     * @return This map's value set
-     */
-    public Set<B> valueSet() {
-        return new HashSet<B>(values);
+
+    /** {@inheritDoc} */
+    @Override
+    public int size() {
+        return keys.size();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean isEmpty() {
+        return keys.isEmpty();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean containsKey(final Object key) {
+        return keys.contains((A) key);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean containsValue(final Object value) {
+        return values.contains((B) value);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public B get(final Object key) {
+        return getValue((A) key);
     }
 
+    /** {@inheritDoc} */
+    @Override
+    public B remove(final Object key) {
+        if (keys.indexOf(key) == -1) {
+            return null;
+        }
+        final B value = values.remove(keys.indexOf(key));
+        keys.remove(keys.indexOf(key));
+        return value;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void putAll(final Map<? extends A, ? extends B> m) {
+        for (Entry<? extends A, ? extends B> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void clear() {
+        keys.clear();
+        values.clear();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public Collection<B> values() {
+        return new ArrayList<B>(values);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public Set<Entry<A, B>> entrySet() {
+        final HashSet<Entry<A, B>> set = new HashSet<Entry<A, B>>();
+        for (A key : keys) {
+            set.add(new SimpleEntry(key, getValue(key)));
+        }
+        return set;
+    }
 }

test/com/dmdirc/util/DoubleMapTest.java

@@ -33,9 +33,9 @@ public class DoubleMapTest {
         dm.put("a", "b");
         
         assertEquals(1, dm.keySet().size());
-        assertEquals(1, dm.valueSet().size());
+        assertEquals(1, dm.values().size());
         assertTrue(dm.keySet().contains("a"));
-        assertTrue(dm.valueSet().contains("b"));
+        assertTrue(dm.values().contains("b"));
     }
     
     @Test(expected=NullPointerException.class)