An attempt at reintegrating MapProxy.

5 files changed, 118 insertions, 61 deletions

diff --git a/src/library/scala/collection/MapProxy.scala b/src/library/scala/collection/MapProxy.scala
index 1c3dd14e36..0e55211651 100644
--- a/src/library/scala/collection/MapProxy.scala
+++ b/src/library/scala/collection/MapProxy.scala
@@ -1,4 +1,3 @@
-/* TODO: Reintegrate
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
 **    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
@@ -9,10 +8,8 @@
 
 // $Id$
 
-
 package scala.collection
 
-
 /** This is a simple wrapper class for <a href="Map.html"
  *  target="contentFrame"><code>scala.collection.Map</code></a>.
  *  It is most useful for assembling customized map abstractions
@@ -21,27 +18,4 @@ package scala.collection
  *  @author  Matthias Zenger
  *  @version 1.0, 21/07/2003
  */
-trait MapProxy[A, +B] extends Map[A, B] with CollectionProxy[(A, B)] {
-
-  override def self: Map[A, B]
-
-  override def size = self.size
-  override def get(key: A) = self.get(key)
-  override def getOrElse[B2 >: B](key: A, default: => B2) = self.getOrElse(key, default)
-
-  override def isEmpty = self.isEmpty
-  override def apply(key: A) = self.apply(key)
-  override def contains(key: A) = self.contains(key)
-  override def isDefinedAt(key: A) = self.isDefinedAt(key)
-  override def keys = self.keys
-  override def keySet = self.keySet
-  override def values = self.values
-  override def equals(that: Any) = self equals that
-  override def hashCode() = self.hashCode()
-  override def toString() = self.toString()
-  override def default(key: A) = self.default(key)
-  override def projection = self.projection
-  override def filterKeys(p: A => Boolean) = self filterKeys p
-  override def mapElements[C](f: B => C) = self mapElements f
-}
-*/
+trait MapProxy[A, +B] extends Map[A, B] with generic.MapProxyTemplate[A, B, Map[A, B]]
\ No newline at end of file
diff --git a/src/library/scala/collection/generic/IterableProxyTemplate.scala b/src/library/scala/collection/generic/IterableProxyTemplate.scala
index d154d33621..15a0b19f05 100644
--- a/src/library/scala/collection/generic/IterableProxyTemplate.scala
+++ b/src/library/scala/collection/generic/IterableProxyTemplate.scala
@@ -22,11 +22,21 @@ import collection.mutable.Buffer
  *  @author  Martin Odersky
  *  @version 2.8
  */
-trait IterableProxyTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] extends IterableTemplate[A, This] with TraversableProxyTemplate[A, This] {
+trait IterableProxyTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
+    extends IterableTemplate[A, This]
+    with TraversableProxyTemplate[A, This]
+{
   override def iterator: Iterator[A] = self.iterator
+  override def foreach[U](f: A => U): Unit = self.foreach(f)
+  override def isEmpty: Boolean = self.isEmpty
+  override def foldRight[B](z: B)(op: (A, B) => B): B = self.foldRight(z)(op)
+  override def reduceRight[B >: A](op: (A, B) => B): B = self.reduceRight(op)
+  override def toIterable: Iterable[A] = self.toIterable
+  override def head: A = self.head
   override def takeRight(n: Int): This = self.takeRight(n)
   override def dropRight(n: Int): This = self.dropRight(n)
   override def sameElements[B >: A](that: Iterable[B]): Boolean = self.sameElements(that)
+  override def toStream: Stream[A] = self.toStream
   override def view = self.view
   override def view(from: Int, until: Int) = self.view(from, until)
 }
diff --git a/src/library/scala/collection/generic/MapProxyTemplate.scala b/src/library/scala/collection/generic/MapProxyTemplate.scala
new file mode 100644
index 0000000000..4d98440220
--- /dev/null
+++ b/src/library/scala/collection/generic/MapProxyTemplate.scala
@@ -0,0 +1,44 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.collection.generic
+
+// Methods could be printed by  cat MapTemplate.scala | egrep '^  (override )?def'
+
+/** This trait implements a proxy for iterable objects. It forwards
+ *  all calls to a different iterable object
+ *
+ *  @author  Martin Odersky
+ *  @version 2.8
+ */
+trait MapProxyTemplate[A, +B, +This <: MapTemplate[A, B, This] with Map[A, B]]
+      extends MapTemplate[A, B, This]
+      with IterableProxyTemplate[(A, B), This]
+{
+  override def self: This
+
+  override def get(key: A): Option[B] = self.get(key)
+  override def iterator: Iterator[(A, B)] = self.iterator
+  override def isEmpty: Boolean = self.isEmpty
+  override def getOrElse[B1 >: B](key: A, default: => B1): B1 = self.getOrElse(key, default)
+  override def apply(key: A): B = self.apply(key)
+  override def contains(key: A): Boolean = self.contains(key)
+  override def isDefinedAt(key: A) = self.isDefinedAt(key)
+  override def keySet: Set[A] = self.keySet
+  override def keysIterator: Iterator[A] = self.keysIterator
+  override def keys: Iterator[A] = self.keys
+  override def valueIterable: Iterable[B] = self.valueIterable
+  override def valuesIterator: Iterator[B] = self.valuesIterator
+  override def values: Iterator[B] = self.values
+  override def default(key: A): B = self.default(key)
+  override def filterKeys(p: A => Boolean) = self.filterKeys(p)
+  override def mapValues[C](f: B => C) = self.mapValues(f)
+
+  override def hashCode = self.hashCode
+  override def equals(other: Any) = self equals other
+}
diff --git a/src/library/scala/collection/immutable/MapProxy.scala b/src/library/scala/collection/immutable/MapProxy.scala
new file mode 100644
index 0000000000..b6a2b2a364
--- /dev/null
+++ b/src/library/scala/collection/immutable/MapProxy.scala
@@ -0,0 +1,47 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+// $Id$
+
+
+package scala.collection.immutable
+
+import generic.MapProxyTemplate
+
+/** <p>
+ *    This is a simple wrapper class for <a href="Map.html"
+ *    target="contentFrame"><code>scala.collection.mutable.Map</code></a>.
+ *  </p>
+ *  <p>
+ *    It is most useful for assembling customized map abstractions
+ *    dynamically using object composition and forwarding.
+ *  </p>
+ *
+ *  @author  Matthias Zenger, Martin Odersky
+ *  @version 2.0, 31/12/2006
+ */
+
+trait MapProxy[A, +B] extends immutable.Map[A, B] with MapProxyTemplate[A, B, immutable.Map[A, B]]
+{
+  private def newProxy[B1 >: B](newSelf: immutable.Map[A, B1]): MapProxy[A, B1] =
+    new MapProxy[A, B1] { val self = newSelf }
+
+  override def empty = newProxy(immutable.Map[A, B]())
+  override def updated [B1 >: B](key: A, value: B1) = newProxy(self.updated(key, value))
+
+  override def + [B1 >: B](kv: (A, B1)): Map[A, B1] = newProxy(self + kv)
+  override def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *) =
+    newProxy(self.+(elem1, elem2, elems: _*))
+  override def -(key: A) = newProxy(self - key)
+
+  // error: method ++ overrides nothing  -- ??
+  // override def ++[B1 >: B](elems: Traversable[(A, B1)]) = super.++(elems)
+  // override def ++[B1 >: B] (iter: Iterator[(A, B1)]): immutable.Map[A, B1] =
+  override def filterNot(p: ((A, B)) => Boolean) = newProxy(self.filterNot(p))
+  override def update[B1 >: B](key: A, value: B1) = newProxy(self.update(key, value))
+}
diff --git a/src/library/scala/collection/mutable/MapProxy.scala b/src/library/scala/collection/mutable/MapProxy.scala
index eda46ac702..f440f5bc10 100644
--- a/src/library/scala/collection/mutable/MapProxy.scala
+++ b/src/library/scala/collection/mutable/MapProxy.scala
@@ -1,4 +1,3 @@
-/* TODO: Reintegrate
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
 **    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
@@ -12,6 +11,7 @@
 
 package scala.collection.mutable
 
+import generic.MapProxyTemplate
 
 /** <p>
  *    This is a simple wrapper class for <a href="Map.html"
@@ -25,35 +25,17 @@ package scala.collection.mutable
  *  @author  Matthias Zenger, Martin Odersky
  *  @version 2.0, 31/12/2006
  */
-trait MapProxy[A, B] extends Map[A, B] with collection.MapProxy[A, B] {
-
-  def self: Map[A, B]
-
-  override def update(key: A, value: B): Unit = self.update(key, value)
-  override def += (kv: (A, B)): this.type = { self += kv; this }
-  override def += (kv1: (A, B), kv2: (A, B), kvs: (A, B)*): this.type = { self.+=(kv1, kv2, kvs: _*); this }
-  override def ++= (kvs: Iterable[(A, B)]): this.type = { self ++= kvs; this }
-  override def ++= (kvs: Iterator[(A, B)]): this.type = { self ++= kvs; this }
-  override def + (kv: (A, B)): Map[A, B] = self + kv
-  override def + (kv1: (A, B), kv2: (A, B), kvs: (A, B)*): Map[A, B] = self.+(kv1, kv2, kvs: _*)
-  override def ++ (kvs: Iterable[(A, B)]): Map[A, B] = self ++ kvs
-  override def ++ (kvs: Iterator[(A, B)]): Map[A, B] = self ++ kvs
-  override def -= (key: A): this.type = { self -= key; this }
-  override def -= (key1: A, key2: A, keys: A*): this.type = { self.-=(key1, key2, keys: _*); this }
-  override def --= (keys: Iterable[A]): this.type = { self --= keys; this }
-  override def --= (keys: Iterator[A]): this.type = { self --= keys; this }
-  override def - (key: A): Map[A, B] = self - key
-  override def - (key1: A, key2: A, keys: A*): Map[A, B] = self.-(key1, key2, keys: _*)
-  override def -- (keys: Iterable[A]): Map[A, B] = self -- keys
-  override def -- (keys: Iterator[A]): Map[A, B] = self -- keys
-  override def clear(): Unit = self.clear
-  override def transform(f: (A, B) => B) = self transform f
-  override def retain(p: (A, B) => Boolean): Unit = self retain p
-  override def <<(cmd: Message[(A, B)]): Unit = self << cmd
-  override def clone(): Map[A, B] = self.clone()
-  @deprecated
-  override def incl(mappings: (A, B)*): Unit = self.incl(mappings: _*)
-  @deprecated
-  override def excl(keys: A*): Unit = self.excl(keys: _*)
-}
-*/
+
+trait MapProxy[A, B] extends mutable.Map[A, B] with MapProxyTemplate[A, B, mutable.Map[A, B]]
+{
+  override def empty: MapProxy[A, B] = new MapProxy[A, B] { val self = mutable.Map[A,B]() }
+
+  override def +(kv: (A, B)): this.type = { self.update(kv._1, kv._2) ; this }
+  override def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *) = self.+(elem1, elem2, elems: _*)
+  override def -(key: A): this.type = { self.remove(key); this }
+
+  override def += (kv: (A, B)): this.type = { self += kv ; this }
+  override def -= (key: A): this.type = { self -= key ; this }
+
+  // method ++ overrides nothing ???
+}
\ No newline at end of file