diff options
author | Paul Phillips <paulp@improving.org> | 2009-06-16 14:30:44 +0000 |
---|---|---|
committer | Paul Phillips <paulp@improving.org> | 2009-06-16 14:30:44 +0000 |
commit | e41d30ba4a308baa8260a6957b7a0207c4035326 (patch) | |
tree | 8b860babffc09d7b9a7de4d2858660cf1efb9cfe /src/library | |
parent | 73746f649a39156df26a289022b2f6127f8145a7 (diff) | |
download | scala-e41d30ba4a308baa8260a6957b7a0207c4035326.tar.gz scala-e41d30ba4a308baa8260a6957b7a0207c4035326.tar.bz2 scala-e41d30ba4a308baa8260a6957b7a0207c4035326.zip |
More work on all the collection proxies.
attempted to bring Map/Set/Sequence/Iterable up to date with the methods
in their underlying classes.
Diffstat (limited to 'src/library')
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 |