From a911ebb98b46cb9e60bcb6bc505ddd06a6c508a1 Mon Sep 17 00:00:00 2001 From: stepancheg Date: Sat, 28 Jun 2008 20:23:22 +0000 Subject: Refactor proxies: IterableProxy, SeqProxy, Rand... Refactor proxies: IterableProxy, SeqProxy, RandomAccessSeqProxy, MapProxy: not all methods were proxied previously; proxy methods are now declared in the same order as in proxied traits (to make maintaining easier) --- src/library/scala/IterableProxy.scala | 77 ++++++++++++++++++---------- src/library/scala/RandomAccessSeqProxy.scala | 6 ++- src/library/scala/SeqProxy.scala | 50 ++++++++++++++++-- src/library/scala/collection/MapProxy.scala | 30 +++++++---- 4 files changed, 120 insertions(+), 43 deletions(-) (limited to 'src') diff --git a/src/library/scala/IterableProxy.scala b/src/library/scala/IterableProxy.scala index 361113a7a4..ee86728647 100644 --- a/src/library/scala/IterableProxy.scala +++ b/src/library/scala/IterableProxy.scala @@ -24,31 +24,56 @@ import scala.collection.mutable.Buffer trait IterableProxy[+A] extends Iterable[A] with Proxy { override def self: Iterable[A] - override def elements: Iterator[A] = self.elements + + override def elements = self.elements @deprecated - override def concat [B >: A](that: Iterable[B]): Collection[B] = self concat that - override def map[B](f: A => B): Iterable[B] = self map f - override def flatMap[B](f: A => Iterable[B]): Iterable[B] = self flatMap f - override def filter(p: A => Boolean): Iterable[A] = self filter p - override def takeWhile(p: A => Boolean): Iterable[A] = self takeWhile p - override def dropWhile(p: A => Boolean): Collection[A] = self dropWhile p - @deprecated override def take(n: Int): Collection[A] = self take n - @deprecated override def drop(n: Int): Collection[A] = self drop n - override def foreach(f: A => Unit): 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 find(p: A => Boolean): Option[A] = self find p - override def findIndexOf(p: A => Boolean): Int = self findIndexOf p - override def indexOf[B >: A](elem: B): Int = self indexOf elem - override def foldLeft[B](z: B)(op: (B, A) => B): B = (self foldLeft z)(op) - override def foldRight[B](z: B)(op: (A, B) => B): B = (self foldRight z)(op) - override def /:[B](z: B)(op: (B, A) => B): B = (z /: self)(op) - override def :\[B](z: B)(op: (A, B) => B): B = (self :\ z)(op) - override def reduceLeft[B >: A](op: (B, A) => B): B = self reduceLeft op - override def reduceRight[B >: A](op: (A, B) => B): B = self reduceRight op - override def sameElements[B >: A](that: Iterable[B]): Boolean = self sameElements that - override def copyToBuffer[B >: A](dest: Buffer[B]): Unit = self copyToBuffer dest - override def toList: List[A] = self.toList - override def mkString(start: String, sep: String, end: String): String = self.mkString(start, sep, end) - override def addString(buf: StringBuilder, start: String, sep: String, end: String): StringBuilder = self.addString(buf, start, sep, end) + override def concat [B >: A](that: Iterable[B]) = self concat that + override def ++[B >: A](that: Iterable[B]) = self ++ that + override def map[B](f: A => B) = self map f + override def flatMap[B](f: A => Iterable[B]) = self flatMap f + override def filter(p: A => Boolean) = self filter p + override def partition(p: A => Boolean) = self partition p + override def takeWhile(p: A => Boolean) = self takeWhile p + override def dropWhile(p: A => Boolean) = self dropWhile p + @deprecated override def take(n: Int) = self take n + @deprecated override def drop(n: Int) = self drop n + override def foreach(f: A => Unit) = self foreach f + override def forall(p: A => Boolean) = self forall p + override def exists(p: A => Boolean) = self exists p + override def find(p: A => Boolean) = self find p + @deprecated override def findIndexOf(p: A => Boolean) = self findIndexOf p + @deprecated override def indexOf[B >: A](elem: B): Int = self indexOf elem + override def foldLeft[B](z: B)(op: (B, A) => B) = (self foldLeft z)(op) + override def foldRight[B](z: B)(op: (A, B) => B) = (self foldRight z)(op) + override def /:[B](z: B)(op: (B, A) => B) = (z /: self)(op) + override def :\[B](z: B)(op: (A, B) => B) = (self :\ z)(op) + override def reduceLeft[B >: A](op: (B, A) => B) = self reduceLeft op + override def reduceRight[B >: A](op: (A, B) => B) = self reduceRight op + override def copyToBuffer[B >: A](dest: Buffer[B]) = self copyToBuffer dest + override def sameElements[B >: A](that: Iterable[B]) = self sameElements that + + override def toList = self.toList + override def toSeq = self.toSeq + override def toStream = self.toStream + + override def mkString(start: String, sep: String, end: String) = self.mkString(start, sep, end) + override def mkString(sep: String) = self.mkString(sep) + override def mkString = self.mkString + + override def addString(buf: StringBuilder, start: String, sep: String, end: String) = + self.addString(buf, start, sep, end) + + override def addString(buf: StringBuilder, sep: String) = + self.addString(buf, sep) + + override def addString(buf: StringBuilder) = + self.addString(buf) + + override def copyToArray[B >: A](xs: Array[B], start: Int) = self.copyToArray(xs, start) + + override def isEmpty = self.isEmpty + + override def projection = self.projection + + override def hasDefiniteSize = self.hasDefiniteSize } diff --git a/src/library/scala/RandomAccessSeqProxy.scala b/src/library/scala/RandomAccessSeqProxy.scala index a5fb245f97..2a6245ebb0 100644 --- a/src/library/scala/RandomAccessSeqProxy.scala +++ b/src/library/scala/RandomAccessSeqProxy.scala @@ -20,12 +20,16 @@ package scala trait RandomAccessSeqProxy[+A] extends RandomAccessSeq[A] with SeqProxy[A] { override def self: RandomAccessSeq[A] + override def projection = self.projection + override def drop(from: Int): RandomAccessSeq[A] = self.drop(from) override def take(until: Int): RandomAccessSeq[A] = self.take(until) override def slice(from: Int, until: Int) : RandomAccessSeq[A] = self.slice(from, until) + override def reverse = self.reverse override def partition(p: A => Boolean): (RandomAccessSeq[A], RandomAccessSeq[A]) = self.partition(p) - // XXX: def patch, reverse, should not return projection + override def patch[B >: A](from0: Int, patch0: RandomAccessSeq[B], replaced0: Int) = + self.patch(from0, patch0, replaced0) override def ++[B >: A](that: Iterable[B]): RandomAccessSeq[B] = self ++ that override def toStream: Stream[A] = self.toStream } diff --git a/src/library/scala/SeqProxy.scala b/src/library/scala/SeqProxy.scala index b9385139fa..deb046b902 100644 --- a/src/library/scala/SeqProxy.scala +++ b/src/library/scala/SeqProxy.scala @@ -19,27 +19,67 @@ package scala * @author Matthias Zenger * @version 2.0, 31/12/2006 */ -trait SeqProxy[+A] extends Seq[A] with IterableProxy[A] { +trait SeqProxy[+A] extends Seq[A] with CollectionProxy[A] { override def self: Seq[A] + // PartialFunction delegates + override def apply(i: Int): A = self(i) + + // Seq delegates + // Seq methods could be printed by cat Seq.scala | sed -n '/trait Seq/,$ p' | egrep '^ (override )?def' + override def length: Int = self.length - override def isEmpty: Boolean = self.isEmpty + override def lengthCompare(l: Int) = self lengthCompare l + override def size = self.size + override def isEmpty = self.isEmpty @deprecated override def concat [B >: A](that: Iterable[B]): Seq[B] = self concat that + override def last = self.last + override def lastOption = self.lastOption + override def first = self.first + override def firstOption = self.firstOption + override def headOption = self.headOption + + override def ++ [B >: A](that: Iterable[B]) = self ++ that override def isDefinedAt(x: Int): Boolean = self isDefinedAt x + override def lastIndexOf[B >: A](elem: B): Int = self lastIndexOf elem + override def findIndexOf(p: A => Boolean): Int = self findIndexOf p + + override def indexOf[B >: A](elem: B): Int = self indexOf elem + override def map[B](f: A => B): Seq[B] = self map f - override def flatMap[B](f: A => Iterable[B]): Seq[B] = self flatMap f + override def flatMap[B](f: A => Iterable[B]) = self flatMap f override def filter(p: A => Boolean): Seq[A] = self filter p override def take(n: Int): Seq[A] = self take n override def drop(n: Int): Seq[A] = self drop n + + override def slice(from: Int, len: Int): Seq[A] = self.slice(from, len) + override def slice(from: Int) = self slice from + override def takeWhile(p: A => Boolean): Seq[A] = self takeWhile p override def dropWhile(p: A => Boolean): Seq[A] = self dropWhile p + override def reverse: Seq[A] = self.reverse + override def contains(elem: Any): Boolean = self contains elem - override def slice(from: Int, len: Int): Seq[A] = self.slice(from, len) + + override def subseq(from: Int, end: Int) = self.subseq(from, end) + override def toArray[B >: A]: Array[B] = self.toArray - override def copyToArray[B >: A](xs: Array[B], start: Int): Unit = self.copyToArray(xs, start) + + override def toSeq = self.toSeq + + override def projection = self.projection + + override def equalsWith[B](that: Seq[B])(f: (A, B) => Boolean): Boolean = self.equalsWith(that)(f) + + override def startsWith[B](that: Seq[B]) = self startsWith that + override def endsWith[B](that: Seq[B]) = self endsWith that + + override def indexOf[B >: A](that: Seq[B]) = self indexOf that + + override def containsSlice[B](that: Seq[B]) = self containsSlice that } diff --git a/src/library/scala/collection/MapProxy.scala b/src/library/scala/collection/MapProxy.scala index 617c3bc79a..6de1e30f15 100644 --- a/src/library/scala/collection/MapProxy.scala +++ b/src/library/scala/collection/MapProxy.scala @@ -20,18 +20,26 @@ package scala.collection * @author Matthias Zenger * @version 1.0, 21/07/2003 */ -trait MapProxy[A, +B] extends Map[A, B] with IterableProxy[(A, B)] { +trait MapProxy[A, +B] extends Map[A, B] with CollectionProxy[(A, B)] { - def self: Map[A, B] + override def self: Map[A, B] - override def size: Int = self.size - override def get(key: A): Option[B] = self.get(key) - override def isEmpty: Boolean = self.isEmpty - override def apply(key: A): B = self.apply(key) - override def contains(key: A): Boolean = self.contains(key) + 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: Iterator[A] = self.keys - override def keySet: Set[A] = self.keySet - override def values: Iterator[B] = self.values - override def default(key: A): B = self.default(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 } -- cgit v1.2.3