Add HashMap #map, #mapKeys, #mapValues + convert to/from j.u.Map

pawelkrupinski · ms-tg · commit f47f3ee96ca9 · 2012-12-19T14:13:16.000-05:00
diff --git a/core/src/main/java/fj/data/HashMap.java b/core/src/main/java/fj/data/HashMap.java
@@ -1,9 +1,6 @@
 package fj.data;
 
-import fj.Equal;
-import fj.F;
-import fj.Hash;
-import fj.P2;
+import fj.*;
 
 import java.util.Collection;
 import java.util.Iterator;
@@ -69,6 +66,13 @@ public HashMap(final Equal<K> e, final Hash<K> h) {
     this.h = h;
   }
 
+  public HashMap(java.util.Map<K, V> map, final Equal<K> e, final Hash<K> h) {
+    this(e, h);
+    for (K key : map.keySet()) {
+      set(key, map.get(key));
+    }
+  }
+
   /**
    * Construct a hash map with the given equality and hashing strategy.
    *
@@ -82,7 +86,11 @@ public HashMap(final Equal<K> e, final Hash<K> h, final int initialCapacity) {
     this.h = h;
   }
 
-  /**
+    public HashMap(java.util.Map<K, V> map) {
+        this(map, Equal.<K>anyEqual(), Hash.<K>anyHash());
+    }
+
+    /**
    * Construct a hash map with the given equality and hashing strategy.
    *
    * @param e               The equality strategy.
@@ -243,6 +251,43 @@ public Option<V> getDelete(final K k) {
     return fromNull(m.remove(new Key<K>(k, e, h)));
   }
 
+  public <A, B> HashMap<A, B> map(F<K, A> keyFunction,
+                                  F<V, B> valueFunction,
+                                  Equal<A> equal, Hash<A> hash) {
+    final HashMap<A, B> hashMap = new HashMap<A, B>(equal, hash);
+    for (K key : keys()) {
+      final A newKey = keyFunction.f(key);
+      final B newValue = valueFunction.f(get(key).some());
+      hashMap.set(newKey, newValue);
+    }
+    return hashMap;
+  }
+
+  public <A, B> HashMap<A, B> map(F<K, A> keyFunction,
+                                  F<V, B> valueFunction) {
+    return map(keyFunction, valueFunction, Equal.<A>anyEqual(), Hash.<A>anyHash());
+  }
+
+  public <A, B> HashMap<A, B> map(F<P2<K, V>, P2<A, B>> function, Equal<A> equal, Hash<A> hash) {
+    return from(toStream().map(function), equal, hash);
+  }
+
+  public <A, B> HashMap<A, B> map(F<P2<K, V>, P2<A, B>> function) {
+    return from(toStream().map(function));
+  }
+
+  public <A> HashMap<A, V> mapKeys(F<K, A> keyFunction, Equal<A> equal, Hash<A> hash) {
+    return map(keyFunction, Function.<V>identity(), equal, hash);
+  }
+
+  public <A> HashMap<A, V> mapKeys(F<K, A> function) {
+    return mapKeys(function, Equal.<A>anyEqual(), Hash.<A>anyHash());
+  }
+
+  public <B> HashMap<K, B> mapValues(F<V, B> function) {
+    return map(Function.<K>identity(), function, e, h);
+  }
+
   public List<P2<K, V>> toList() {
     return keys().map(new F<K, P2<K, V>>() {
       public P2<K, V> f(final K k) {
@@ -272,6 +317,14 @@ public Array<P2<K, V>> toArray() {
     return toList().toArray();
   }
 
+  public java.util.Map<K, V> toMap() {
+    final java.util.HashMap<K,V> result = new java.util.HashMap<K, V>();
+    for (K key : keys()) {
+      result.put(key, get(key).some());
+    }
+    return result;
+  }
+
   public static <K, V> HashMap<K, V> from(Iterable<P2<K, V>> entries) {
     return from(entries, Equal.<K>anyEqual(), Hash.<K>anyHash());
   }
diff --git a/core/src/test/fj/data/CheckHashMap.scala b/core/src/test/fj/data/CheckHashMap.scala
@@ -3,13 +3,15 @@ package data
 
 import org.scalacheck.Prop._
 import ArbitraryHashMap._
-import Equal.{intEqual, stringEqual, optionEqual}
-import Hash.intHash
+import Equal._
+import Hash._
+import Ord._
 import fj.data.Option._
 import scala.collection.JavaConversions._
 import org.scalacheck.{Arbitrary, Properties}
 import data.ArbitraryList._
 import org.scalacheck.Arbitrary._
+import java.util.Map
 
 object CheckHashMap extends Properties("HashMap") {
   implicit val equalInt: Equal[Int] = intEqual comap ((x: Int) => (x: java.lang.Integer))
@@ -69,4 +71,36 @@ object CheckHashMap extends Properties("HashMap") {
       .forall((e: (Int, Iterable[P2[Int, String]])) => e._2
       .exists((elem: P2[Int, String]) => optionEqual(stringEqual).eq(map.get(e._1), Option.some(elem._2))))
   })
+
+  property("map") = forAll((m: HashMap[Int, String]) => {
+    val keyFunction: F[Int, String] = (i: Int) => i.toString
+    val valueFunction: (String) => String = (s: String) => s + "a"
+    val mapped = m.map(keyFunction, valueFunction, stringEqual, stringHash)
+    val keysAreEqual = m.keys().map(keyFunction).toSet == mapped.keys.toSet
+    val appliedFunctionsToKeysAndValues: Boolean = m.keys().forall((key: Int) => {
+      val mappedValue = mapped.get(keyFunction.f(key))
+      val oldValueMapped = some(valueFunction.f(m.get(key).some()))
+      Equal.optionEqual(stringEqual).eq(mappedValue, oldValueMapped)
+    })
+
+    keysAreEqual && appliedFunctionsToKeysAndValues
+  })
+
+  property("toMap") = forAll((m: HashMap[Int, String]) => {
+    val toMap: Map[Int, String] = m.toMap
+    m.keys().forall((key: Int) => m.get(key).some() == toMap.get(key))
+  })
+
+  property("fromMap") = forAll((m: HashMap[Int, String]) => {
+    val map = new java.util.HashMap[Int, String]()
+    m.keys().foreach((key: Int) => {
+      map.put(key, m.get(key).some())
+      Unit.unit()
+    })
+    val fromMap: HashMap[Int, String] = new HashMap[Int, String](map)
+    val keysAreEqual = m.keys.toSet == fromMap.keys.toSet
+    val valuesAreEqual = m.keys().forall((key: Int) =>
+      optionEqual(stringEqual).eq(m.get(key), fromMap.get(key)))
+    keysAreEqual && valuesAreEqual
+  })
 }
