package scala.collection
import generic._
import mutable.{ Builder, ArrayBuffer }
import TraversableView.NoBuilder
import annotation.migration
trait ViewMkString[+A] {
self: Traversable[A] =>
protected[this] def thisSeq: Seq[A] = new ArrayBuffer[A] ++= self result
override def mkString: String = mkString("")
override def mkString(sep: String): String = mkString("", sep, "")
override def mkString(start: String, sep: String, end: String): String = {
thisSeq.addString(new StringBuilder(), start, sep, end).toString
}
override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder =
b append start append "..." append end
}
trait TraversableViewLike[+A,
+Coll,
+This <: TraversableView[A, Coll] with TraversableViewLike[A, Coll, This]]
extends Traversable[A] with TraversableLike[A, This] with ViewMkString[A] with GenTraversableViewLike[A, Coll, This]
{
self =>
override protected[this] def newBuilder: Builder[A, This] =
throw new UnsupportedOperationException(this+".newBuilder")
protected def underlying: Coll
protected[this] def viewIdentifier: String = ""
protected[this] def viewIdString: String = ""
override def stringPrefix = "TraversableView"
def force[B >: A, That](implicit bf: CanBuildFrom[Coll, B, That]) = {
val b = bf(underlying)
b ++= this
b.result()
}
trait Transformed[+B] extends TraversableView[B, Coll] with super.Transformed[B] {
def foreach[U](f: B => U): Unit
override def headOption: Option[B] = {
for (x <- this)
return Some(x)
None
}
override def lastOption: Option[B] = {
var empty = true
var result: B = null.asInstanceOf[B]
for (x <- this) {
empty = false
result = x
}
if (empty) None else Some(result)
}
override def stringPrefix = self.stringPrefix
override def toString = viewToString
}
trait EmptyView extends Transformed[Nothing] with super.EmptyView
trait Forced[B] extends Transformed[B] with super.Forced[B]
trait Sliced extends Transformed[A] with super.Sliced
trait Mapped[B] extends Transformed[B] with super.Mapped[B]
trait FlatMapped[B] extends Transformed[B] with super.FlatMapped[B]
trait Appended[B >: A] extends Transformed[B] with super.Appended[B]
trait Filtered extends Transformed[A] with super.Filtered
trait TakenWhile extends Transformed[A] with super.TakenWhile
trait DroppedWhile extends Transformed[A] with super.DroppedWhile
override def ++[B >: A, That](xs: GenTraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That = {
newAppended(xs.seq.toTraversable).asInstanceOf[That]
}
override def map[B, That](f: A => B)(implicit bf: CanBuildFrom[This, B, That]): That = {
newMapped(f).asInstanceOf[That]
}
override def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[This, B, That]): That =
filter(pf.isDefinedAt).map(pf)(bf)
override def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That = {
newFlatMapped(f).asInstanceOf[That]
}
private[this] implicit def asThis(xs: Transformed[A]): This = xs.asInstanceOf[This]
protected def newForced[B](xs: => GenSeq[B]): Transformed[B] = new { val forced = xs } with Forced[B]
protected def newAppended[B >: A](that: GenTraversable[B]): Transformed[B] = new { val rest = that } with Appended[B]
protected def newMapped[B](f: A => B): Transformed[B] = new { val mapping = f } with Mapped[B]
protected def newFlatMapped[B](f: A => GenTraversableOnce[B]): Transformed[B] = new { val mapping = f } with FlatMapped[B]
protected def newFiltered(p: A => Boolean): Transformed[A] = new { val pred = p } with Filtered
protected def newSliced(_endpoints: SliceInterval): Transformed[A] = new { val endpoints = _endpoints } with Sliced
protected def newDroppedWhile(p: A => Boolean): Transformed[A] = new { val pred = p } with DroppedWhile
protected def newTakenWhile(p: A => Boolean): Transformed[A] = new { val pred = p } with TakenWhile
protected def newTaken(n: Int): Transformed[A] = newSliced(SliceInterval(0, n))
protected def newDropped(n: Int): Transformed[A] = newSliced(SliceInterval(n, Int.MaxValue))
override def filter(p: A => Boolean): This = newFiltered(p)
override def withFilter(p: A => Boolean): This = newFiltered(p)
override def partition(p: A => Boolean): (This, This) = (newFiltered(p), newFiltered(!p(_)))
override def init: This = newSliced(SliceInterval(0, size - 1))
override def drop(n: Int): This = newDropped(n)
override def take(n: Int): This = newTaken(n)
override def slice(from: Int, until: Int): This = newSliced(SliceInterval(from, until))
override def dropWhile(p: A => Boolean): This = newDroppedWhile(p)
override def takeWhile(p: A => Boolean): This = newTakenWhile(p)
override def span(p: A => Boolean): (This, This) = (newTakenWhile(p), newDroppedWhile(p))
override def splitAt(n: Int): (This, This) = (newTaken(n), newDropped(n))
override def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[This, B, That]): That =
newForced(thisSeq.scanLeft(z)(op)).asInstanceOf[That]
@migration(2, 9,
"This scanRight definition has changed in 2.9.\n" +
"The previous behavior can be reproduced with scanRight.reverse."
)
override def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[This, B, That]): That =
newForced(thisSeq.scanRight(z)(op)).asInstanceOf[That]
override def groupBy[K](f: A => K): immutable.Map[K, This] =
thisSeq groupBy f mapValues (xs => newForced(xs))
override def toString = viewToString
}