More work on all the collection proxies.

attempted to bring Map/Set/Sequence/Iterable up to date with the methods
in their underlying classes.

11 files changed, 120 insertions, 74 deletions

diff --git a/src/library/scala/collection/MapProxy.scala b/src/library/scala/collection/MapProxy.scala
index 0e55211651..134405bae4 100644
--- a/src/library/scala/collection/MapProxy.scala
+++ b/src/library/scala/collection/MapProxy.scala
@@ -10,6 +10,8 @@
 
 package scala.collection
 
+import generic.MapProxyTemplate
+
 /** 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
@@ -18,4 +20,4 @@ package scala.collection
  *  @author  Matthias Zenger
  *  @version 1.0, 21/07/2003
  */
-trait MapProxy[A, +B] extends Map[A, B] with generic.MapProxyTemplate[A, B, Map[A, B]]
\ No newline at end of file
+trait MapProxy[A, +B] extends Map[A, B] with MapProxyTemplate[A, B, Map[A, B]]
\ No newline at end of file
diff --git a/src/library/scala/collection/SequenceProxy.scala b/src/library/scala/collection/SequenceProxy.scala
index 40ad16f312..fa3d939e72 100644
--- a/src/library/scala/collection/SequenceProxy.scala
+++ b/src/library/scala/collection/SequenceProxy.scala
@@ -6,15 +6,13 @@
 **                          |/                                          **
 \*                                                                      */
 
-// $Id: IterableProxy.scala 15458 2008-06-28 20:23:22Z stepancheg $
+// $Id: SequenceProxy.scala 15458 2008-06-28 20:23:22Z stepancheg $
 
 
 package scala.collection
 
 import generic._
 
-// Methods could be printed by  cat Traversibe.scala | egrep '^  (override )?def'
-
 
 /** This trait implements a proxy for iterable objects. It forwards
  *  all calls to a different iterable object
diff --git a/src/library/scala/collection/SetProxy.scala b/src/library/scala/collection/SetProxy.scala
index 7ed2d7f957..1d01dbc9cb 100644
--- a/src/library/scala/collection/SetProxy.scala
+++ b/src/library/scala/collection/SetProxy.scala
@@ -1,4 +1,3 @@
-/* TODO: Reintegrate
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
 **    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
@@ -12,6 +11,7 @@
 
 package scala.collection
 
+import generic.SetProxyTemplate
 
 /** This is a simple wrapper class for <a href="Set.html"
  *  target="contentFrame"><code>scala.collection.Set</code></a>.
@@ -22,11 +22,5 @@ package scala.collection
  *  @author  Martin Odersky
  *  @version 2.0, 01/01/2007
  */
-trait SetProxy[A] extends Set[A] with IterableProxy[A] {
-  def self: Set[A]
-  def size: Int = self.size
-  override def isEmpty: Boolean = self.isEmpty
-  def contains(elem: A): Boolean = self.contains(elem)
-  override def subsetOf(that: Set[A]): Boolean = self.subsetOf(that)
-}
-*/
+
+trait SetProxy[A] extends Set[A] with SetProxyTemplate[A, Set[A]]
\ No newline at end of file
diff --git a/src/library/scala/collection/generic/MapProxyTemplate.scala b/src/library/scala/collection/generic/MapProxyTemplate.scala
index 4d98440220..ae53e33eaf 100644
--- a/src/library/scala/collection/generic/MapProxyTemplate.scala
+++ b/src/library/scala/collection/generic/MapProxyTemplate.scala
@@ -20,7 +20,9 @@ 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
+  // def empty: This
+  // def + [B1 >: B] (kv: (A, B1)): Map[A, B1]
+  // def - (key: A): This
 
   override def get(key: A): Option[B] = self.get(key)
   override def iterator: Iterator[(A, B)] = self.iterator
@@ -39,6 +41,11 @@ trait MapProxyTemplate[A, +B, +This <: MapTemplate[A, B, This] with Map[A, B]]
   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
+  // override def updated [B1 >: B](key: A, value: B1) = self + ((key, value))
+  // override def + [B1 >: B](elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *) = self.+(elem1, elem2, elems: _*)
+  // override def ++[B1 >: B](elems: Traversable[(A, B1)]) = self.++(elems)
+  // override def ++[B1 >: B](iter: Iterator[(A, B1)]) = self.++(iter)
+
+  override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder =
+    self.addString(b, start, sep, end)
 }
diff --git a/src/library/scala/collection/generic/SequenceProxyTemplate.scala b/src/library/scala/collection/generic/SequenceProxyTemplate.scala
index 753f6ba31d..4231dc1eb7 100644
--- a/src/library/scala/collection/generic/SequenceProxyTemplate.scala
+++ b/src/library/scala/collection/generic/SequenceProxyTemplate.scala
@@ -16,8 +16,8 @@ import collection.mutable.Buffer
 // Methods could be printed by  cat SequenceTemplate.scala | egrep '^  (override )?def'
 
 
-/** This trait implements a proxy for iterable objects. It forwards
- *  all calls to a different iterable object
+/** This trait implements a proxy for sequences. It forwards
+ *  all calls to a different sequence.
  *
  *  @author  Martin Odersky
  *  @version 2.8
@@ -26,6 +26,7 @@ trait SequenceProxyTemplate[+A, +This <: SequenceTemplate[A, This] with Sequence
   override def length: Int = self.length
   override def apply(idx: Int): A = self.apply(idx)
   override def lengthCompare(len: Int): Int = self.lengthCompare(len)
+  override def size = self.size
   override def isDefinedAt(x: Int): Boolean = self.isDefinedAt(x)
   override def zip[A1 >: A, B, That](that: Sequence[B])(implicit bf: BuilderFactory[(A1, B), That, This]): That = self.zip[A1, B, That](that)(bf)
   override def zipAll[B, A1 >: A, That](that: Sequence[B], thisElem: A1, thatElem: B)(implicit bf: BuilderFactory[(A1, B), That, This]): That = self.zipAll(that, thisElem, thatElem)(bf)
@@ -34,6 +35,7 @@ trait SequenceProxyTemplate[+A, +This <: SequenceTemplate[A, This] with Sequence
   override def prefixLength(p: A => Boolean) = self.prefixLength(p)
   override def indexWhere(p: A => Boolean): Int = self.indexWhere(p)
   override def indexWhere(p: A => Boolean, from: Int): Int = self.indexWhere(p, from)
+  override def findIndexOf(p: A => Boolean): Int = self.findIndexOf(p)
   override def indexOf[B >: A](elem: B): Int = self.indexOf(elem)
   override def indexOf[B >: A](elem: B, from: Int): Int = self.indexOf(elem, from)
   override def lastIndexOf[B >: A](elem: B): Int = self.lastIndexOf(elem)
@@ -56,4 +58,8 @@ trait SequenceProxyTemplate[+A, +This <: SequenceTemplate[A, This] with Sequence
   override def indices: Range = self.indices
   override def view = self.view
   override def view(from: Int, until: Int) = self.view(from, until)
+  override def findLastIndexOf(p: A => Boolean): Int = self.findLastIndexOf(p)
+  override def slice(from: Int): Sequence[A] = self.slice(from)
+  override def equalsWith[B](that: Sequence[B])(f: (A,B) => Boolean): Boolean = self.equalsWith(that)(f)
+  override def containsSlice[B](that: Sequence[B]): Boolean = self.containsSlice(that)
 }
diff --git a/src/library/scala/collection/generic/SetProxyTemplate.scala b/src/library/scala/collection/generic/SetProxyTemplate.scala
new file mode 100644
index 0000000000..a944b132a0
--- /dev/null
+++ b/src/library/scala/collection/generic/SetProxyTemplate.scala
@@ -0,0 +1,35 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+
+package scala.collection.generic
+
+// Methods could be printed by  cat SetTemplate.scala | egrep '^  (override )?def'
+
+/** This trait implements a proxy for sets. It forwards
+ *  all calls to a different set.
+ *
+ *  @author  Martin Odersky
+ *  @version 2.8
+ */
+trait SetProxyTemplate[A, +This <: SetTemplate[A, This] with Set[A]] extends SetTemplate[A, This] with IterableProxyTemplate[A, This]
+{
+  // def empty: This
+  // def + (elem: A): This
+  // def - (elem: A): This
+  override def contains(elem: A): Boolean = self.contains(elem)
+  override def isEmpty: Boolean = self.isEmpty
+  override def apply(elem: A): Boolean = self.apply(elem)
+  override def intersect(that: Set[A]) = self.intersect(that)
+  override def &(that: Set[A]): This = self.&(that)
+  override def union(that: Set[A]): This = self.union(that)
+  override def | (that: Set[A]): This = self.|(that)
+  override def diff(that: Set[A]): This = self.diff(that)
+  override def &~(that: Set[A]): This = self.&~(that)
+  override def subsetOf(that: Set[A]): Boolean = self.subsetOf(that)
+}
diff --git a/src/library/scala/collection/generic/TraversableProxyTemplate.scala b/src/library/scala/collection/generic/TraversableProxyTemplate.scala
index dd32c685aa..b3f0fd5a48 100644
--- a/src/library/scala/collection/generic/TraversableProxyTemplate.scala
+++ b/src/library/scala/collection/generic/TraversableProxyTemplate.scala
@@ -13,7 +13,7 @@ package scala.collection.generic
 
 import collection.mutable.Buffer
 
-// Methods could be printed by  cat TraversibeTemplate.scala | egrep '^  (override )?def'
+// Methods could be printed by  cat TraversableTemplate.scala | egrep '^  (override )?def'
 
 
 /** This trait implements a proxy for traversable objects. It forwards
@@ -25,7 +25,9 @@ import collection.mutable.Buffer
 trait TraversableProxyTemplate[+A, +This <: TraversableTemplate[A, This] with Traversable[A]] extends TraversableTemplate[A, This] with Proxy {
   def self: This
 
+  override def foreach[B](f: A => B): Unit = self.foreach(f)
   override def isEmpty: Boolean = self.isEmpty
+  override def nonEmpty: Boolean = self.nonEmpty
   override def size: Int = self.size
   override def hasDefiniteSize = self.hasDefiniteSize
   override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = self.++(that)(bf)
@@ -33,10 +35,10 @@ trait TraversableProxyTemplate[+A, +This <: TraversableTemplate[A, This] with Tr
   override def map[B, That](f: A => B)(implicit bf: BuilderFactory[B, That, This]): That = self.map(f)(bf)
   override def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = self.flatMap(f)(bf)
   override def filter(p: A => Boolean): This = self.filter(p)
+  override def filterNot(p: A => Boolean): This = self.filterNot(p)
   override def remove(p: A => Boolean): This = self.remove(p)
   override def partition(p: A => Boolean): (This, This) = self.partition(p)
   override def groupBy[K](f: A => K): Map[K, This] = self.groupBy(f)
-  override def foreach[B](f: A => B): Unit = self.foreach(f)
   override def forall(p: A => Boolean): Boolean = self.forall(p)
   override def exists(p: A => Boolean): Boolean = self.exists(p)
   override def count(p: A => Boolean): Int = self.count(p)
@@ -70,6 +72,7 @@ trait TraversableProxyTemplate[+A, +This <: TraversableTemplate[A, This] with Tr
   override def toIterable: Iterable[A] = self.toIterable
   override def toSequence: Sequence[A] = self.toSequence
   override def toStream: Stream[A] = self.toStream
+  override def toSet[B >: A]: Set[B] = self.toSet
 //  override def sortWith(lt : (A,A) => Boolean): This = self.sortWith(lt)
   override def mkString(start: String, sep: String, end: String): String = self.mkString(start, sep, end)
   override def mkString(sep: String): String = self.mkString(sep)
@@ -77,7 +80,6 @@ trait TraversableProxyTemplate[+A, +This <: TraversableTemplate[A, This] with Tr
   override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = self.addString(b, start, sep, end)
   override def addString(b: StringBuilder, sep: String): StringBuilder = self.addString(b, sep)
   override def addString(b: StringBuilder): StringBuilder = self.addString(b)
-  override def toString = self.toString
   override def stringPrefix : String = self.stringPrefix
   override def view = self.view
   override def view(from: Int, until: Int): TraversableView[A, This] = self.view(from, until)
diff --git a/src/library/scala/collection/immutable/MapProxy.scala b/src/library/scala/collection/immutable/MapProxy.scala
index b6a2b2a364..a2a1223cfe 100644
--- a/src/library/scala/collection/immutable/MapProxy.scala
+++ b/src/library/scala/collection/immutable/MapProxy.scala
@@ -28,20 +28,15 @@ import generic.MapProxyTemplate
 
 trait MapProxy[A, +B] extends immutable.Map[A, B] with MapProxyTemplate[A, B, immutable.Map[A, B]]
 {
+  override def thisCollection = this
   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 empty = newProxy(self.empty)
   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) *) =
+  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))
-}
+}
\ No newline at end of file
diff --git a/src/library/scala/collection/immutable/SetProxy.scala b/src/library/scala/collection/immutable/SetProxy.scala
new file mode 100644
index 0000000000..4d7ef52d93
--- /dev/null
+++ b/src/library/scala/collection/immutable/SetProxy.scala
@@ -0,0 +1,32 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.collection.immutable
+
+import generic.SetProxyTemplate
+
+/** <p>
+ *    This is a simple wrapper class for <a href="Set.html"
+ *    target="contentFrame"><code>scala.collection.immutable.Set</code></a>.
+ *  </p>
+ *  <p>
+ *    It is most useful for assembling customized set abstractions
+ *    dynamically using object composition and forwarding.
+ *  </p>
+ */
+
+trait SetProxy[A] extends immutable.Set[A] with SetProxyTemplate[A, immutable.Set[A]]
+{
+  override def thisCollection = this
+  private def newProxy[B >: A](newSelf: immutable.Set[B]): SetProxy[B] =
+    new SetProxy[B] { val self = newSelf }
+
+  override def empty = newProxy(self.empty)
+  override def + (elem: A) = newProxy(self + elem)
+  override def - (elem: A) = newProxy(self - elem)
+}
diff --git a/src/library/scala/collection/mutable/MapProxy.scala b/src/library/scala/collection/mutable/MapProxy.scala
index f440f5bc10..92fb1c85a2 100644
--- a/src/library/scala/collection/mutable/MapProxy.scala
+++ b/src/library/scala/collection/mutable/MapProxy.scala
@@ -28,14 +28,15 @@ import generic.MapProxyTemplate
 
 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 thisCollection = this
+  override def empty: MapProxy[A, B] = new MapProxy[A, B] { val self = MapProxy.this.self.empty }
 
-  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)) = { self.update(kv._1, kv._2) ; this }
+  override def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *) =
+    { self.+(elem1, elem2, elems: _*) ; this }
 
-  override def += (kv: (A, B)): this.type = { self += kv ; this }
-  override def -= (key: A): this.type = { self -= key ; this }
+  override def -(key: A) = { self.remove(key); this }
 
-  // method ++ overrides nothing ???
+  override def += (kv: (A, B)) = { self += kv ; this }
+  override def -= (key: A) = { self -= key ; this }
 }
\ No newline at end of file
diff --git a/src/library/scala/collection/mutable/SetProxy.scala b/src/library/scala/collection/mutable/SetProxy.scala
index 1c86472259..0b032816eb 100644
--- a/src/library/scala/collection/mutable/SetProxy.scala
+++ b/src/library/scala/collection/mutable/SetProxy.scala
@@ -1,4 +1,3 @@
-/* TODO: Reintegrate
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
 **    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
@@ -9,9 +8,9 @@
 
 // $Id$
 
-
 package scala.collection.mutable
 
+import generic.SetProxyTemplate
 
 /** This is a simple wrapper class for <a href="Set.html"
  *  target="contentFrame"><code>scala.collection.mutable.Set</code></a>.
@@ -21,38 +20,13 @@ package scala.collection.mutable
  *  @author  Matthias Zenger
  *  @version 1.1, 09/05/2004
  */
-trait SetProxy[A] extends Set[A] with collection.SetProxy[A] {
-
-  def self: Set[A]
-
-  override def update(elem: A, included: Boolean): Unit = self(elem) = included
-
-  def +=(elem: A): this.type = { self += elem; this }
-
-  override def ++=(that: Iterable[A]): this.type = { self ++= that; this }
-
-  override def ++=(it: Iterator[A]): this.type = { self ++= it; this }
-
-  override def incl(elems: A*): Unit = self ++= elems
-
-  def -=(elem: A): this.type = { self -= elem; this }
-
-  override def --=(that: Iterable[A]): Unit = self --= that
-
-  override def --=(it: Iterator[A]): Unit = self --= it
-
-  override def excl(elems: A*): Unit = self --= elems
-
-  override def intersect(that: Set[A]): Unit = self.intersect(that)
-
-  override def clear(): Unit = self.clear
-
-  override def retain(p: A => Boolean): Unit =  self.retain(p)
-
-  override def <<(cmd: Message[A]): Unit = self << cmd
-
-  override def clone(): Set[A] = new SetProxy[A] {
-    def self = SetProxy.this.self.clone()
-  }
-}
-*/
+trait SetProxy[A] extends mutable.Set[A] with SetProxyTemplate[A, mutable.Set[A]]
+{
+  override def thisCollection = this
+  override def empty = new SetProxy[A] { val self = SetProxy.this.self.empty }
+  override def + (elem: A) = { self += elem ; this }
+  override def - (elem: A) = { self -= elem ; this }
+
+  def +=(elem: A) = { self += elem; this }
+  def -=(elem: A) = { self -= elem; this }
+}
\ No newline at end of file