Adding the missing ParMap and GenMap methods.

No review.

1 files changed, 96 insertions, 3 deletions

diff --git a/src/library/scala/collection/parallel/ParMapLike.scala b/src/library/scala/collection/parallel/ParMapLike.scala
index 5b855468c4..beb50a41e1 100644
--- a/src/library/scala/collection/parallel/ParMapLike.scala
+++ b/src/library/scala/collection/parallel/ParMapLike.scala
@@ -16,9 +16,9 @@ import scala.collection.MapLike
 import scala.collection.GenMapLike
 import scala.collection.Map
 import scala.collection.mutable.Builder
-
-
-
+import annotation.unchecked.uncheckedVariance
+import scala.collection.generic.IdleSignalling
+import scala.collection.generic.Signalling
 
 
 
@@ -53,6 +53,99 @@ self =>
     case None => default(key)
   }
 
+  def getOrElse[U >: V](key: K, default: => U): U = get(key) match {
+    case Some(v) => v
+    case None => default
+  }
+
+  def contains(key: K): Boolean = get(key).isDefined
+
+  def isDefinedAt(key: K): Boolean = contains(key)
+
+  private[this] def keysIterator(s: IterableSplitter[(K, V)] @uncheckedVariance): IterableSplitter[K] =
+    new IterableSplitter[K] {
+      i =>
+      val iter = s
+      var signalDelegate: Signalling = IdleSignalling
+      def hasNext = iter.hasNext
+      def next() = iter.next._1
+      def split = {
+        val ss = iter.split.map(keysIterator(_))
+        ss.foreach { _.signalDelegate = i.signalDelegate }
+        ss
+      }
+      def remaining = iter.remaining
+      def dup = keysIterator(iter.dup)
+    }
+
+  def keysIterator: IterableSplitter[K] = keysIterator(splitter)
+
+  private[this] def valuesIterator(s: IterableSplitter[(K, V)] @uncheckedVariance): IterableSplitter[V] =
+    new IterableSplitter[V] {
+      i =>
+      val iter = s
+      var signalDelegate: Signalling = IdleSignalling
+      def hasNext = iter.hasNext
+      def next() = iter.next._2
+      def split = {
+        val ss = iter.split.map(valuesIterator(_))
+        ss.foreach { _.signalDelegate = i.signalDelegate }
+        ss
+      }
+      def remaining = iter.remaining
+      def dup = valuesIterator(iter.dup)
+    }
+
+  def valuesIterator: IterableSplitter[V] = valuesIterator(splitter)
+
+  protected class DefaultKeySet extends ParSet[K] {
+    def contains(key : K) = self.contains(key)
+    def splitter = keysIterator(self.splitter)
+    def + (elem: K): ParSet[K] =
+      (ParSet[K]() ++ this + elem).asInstanceOf[ParSet[K]] // !!! concrete overrides abstract problem
+    def - (elem: K): ParSet[K] =
+      (ParSet[K]() ++ this - elem).asInstanceOf[ParSet[K]] // !!! concrete overrides abstract problem
+    override def size = self.size
+    override def foreach[S](f: K => S) = for ((k, v) <- self) f(k)
+    override def seq = self.seq.keySet
+  }
+
+  protected class DefaultValuesIterable extends ParIterable[V] {
+    def splitter = valuesIterator(self.splitter)
+    override def size = self.size
+    override def foreach[S](f: V => S) = for ((k, v) <- self) f(v)
+    def seq = self.seq.values
+  }
+
+  def keySet: ParSet[K] = new DefaultKeySet
+
+  def keys: ParIterable[K] = keySet
+
+  def values: ParIterable[V] = new DefaultValuesIterable
+
+  def filterKeys(p: K => Boolean): ParMap[K, V] = new ParMap[K, V] {
+    lazy val filtered = self.filter(kv => p(kv._1))
+    override def foreach[S](f: ((K, V)) => S): Unit = for (kv <- self) if (p(kv._1)) f(kv)
+    def splitter = filtered.splitter
+    override def contains(key: K) = self.contains(key) && p(key)
+    def get(key: K) = if (!p(key)) None else self.get(key)
+    def seq = self.seq.filterKeys(p)
+    def size = filtered.size
+    def + [U >: V](kv: (K, U)): ParMap[K, U] = ParMap[K, U]() ++ this + kv
+    def - (key: K): ParMap[K, V] = ParMap[K, V]() ++ this - key
+  }
+
+  def mapValues[S](f: V => S): ParMap[K, S] = new ParMap[K, S] {
+    override def foreach[Q](g: ((K, S)) => Q): Unit = for ((k, v) <- self) g((k, f(v)))
+    def splitter = self.splitter.map(kv => (kv._1, f(kv._2)))
+    override def size = self.size
+    override def contains(key: K) = self.contains(key)
+    def get(key: K) = self.get(key).map(f)
+    def seq = self.seq.mapValues(f)
+    def + [U >: S](kv: (K, U)): ParMap[K, U] = ParMap[K, U]() ++ this + kv
+    def - (key: K): ParMap[K, S] = ParMap[K, S]() ++ this - key
+  }
+
   // note - should not override toMap (could be mutable)
 }