1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2010, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id$
package scala.collection
import generic._
import mutable.{Builder, ArrayBuffer}
import TraversableView.NoBuilder
/** <p>
* A template trait for views of <a href="../Traversable.html"
* target="contentFrame"><code>Traversable</code></a>.<br/>
* Every subclass has to implement the <code>foreach</code> method.
* </p>
* @note Methods such as map/flatMap on this will not invoke the implicitly passed
* Builder factory, but will return a new view directly, to preserve by-name behavior.
* The new view is then cast to the factory's result type.
* This means that every CanBuildFrom that takes a
* View as its From type parameter must yield the same view (or a generic superclass of it)
* as its result parameter. If that assumption is broken, cast errors might result.
*
* @author Martin Odersky
* @version 2.8
*/
trait TraversableViewLike[+A,
+Coll,
+This <: TraversableView[A, Coll] with TraversableViewLike[A, Coll, This]]
extends Traversable[A] with TraversableLike[A, This] {
self =>
override protected[this] def newBuilder: Builder[A, This] =
throw new UnsupportedOperationException(this+".newBuilder")
protected def underlying: Coll
def force[B >: A, That](implicit bf: CanBuildFrom[Coll, B, That]) = {
val b = bf(underlying)
b ++= this
b.result()
}
/** The implementation base trait of this view.
* This trait and all its subtraits has to be re-implemented for each
* ViewLike class.
*/
trait Transformed[+B] extends TraversableView[B, Coll] {
lazy val underlying = self.underlying
override def toString = stringPrefix+"(...)"
}
/** A fall back which forces everything into a vector and then applies an operation
* on it. Used for those operations which do not naturally lend themselves to a view
*/
trait Forced[B] extends Transformed[B] {
protected[this] def forced: Seq[B]
private[this] lazy val forcedCache = forced
override def foreach[U](f: B => U) = forcedCache.foreach(f)
override def stringPrefix = self.stringPrefix+"C"
}
/** pre: from >= 0
*/
trait Sliced extends Transformed[A] {
protected[this] val from: Int
protected[this] val until: Int
override def foreach[U](f: A => U) {
var index = 0
for (x <- self) {
if (from <= index) {
if (until <= index) return
f(x)
}
index += 1
}
}
override def stringPrefix = self.stringPrefix+"S"
override def slice(from1: Int, until1: Int): This =
newSliced(from1 max 0, until1 max 0).asInstanceOf[This]
}
trait Mapped[B] extends Transformed[B] {
protected[this] val mapping: A => B
override def foreach[U](f: B => U) {
for (x <- self)
f(mapping(x))
}
override def stringPrefix = self.stringPrefix+"M"
}
trait FlatMapped[B] extends Transformed[B] {
protected[this] val mapping: A => Traversable[B]
override def foreach[U](f: B => U) {
for (x <- self)
for (y <- mapping(x))
f(y)
}
override def stringPrefix = self.stringPrefix+"N"
}
trait Appended[B >: A] extends Transformed[B] {
protected[this] val rest: Traversable[B]
override def foreach[U](f: B => U) {
for (x <- self) f(x)
for (x <- rest) f(x)
}
override def stringPrefix = self.stringPrefix+"A"
}
trait Filtered extends Transformed[A] {
protected[this] val pred: A => Boolean
override def foreach[U](f: A => U) {
for (x <- self)
if (pred(x)) f(x)
}
override def stringPrefix = self.stringPrefix+"F"
}
trait TakenWhile extends Transformed[A] {
protected[this] val pred: A => Boolean
override def foreach[U](f: A => U) {
for (x <- self) {
if (!pred(x)) return
f(x)
}
}
override def stringPrefix = self.stringPrefix+"T"
}
trait DroppedWhile extends Transformed[A] {
protected[this] val pred: A => Boolean
override def foreach[U](f: A => U) {
var go = false
for (x <- self) {
if (!go && !pred(x)) go = true
if (go) f(x)
}
}
override def stringPrefix = self.stringPrefix+"D"
}
/** Boilerplate method, to override in each subclass
* This method could be eliminated if Scala had virtual classes
*/
protected def newForced[B](xs: => Seq[B]): Transformed[B] = new Forced[B] { val forced = xs }
protected def newAppended[B >: A](that: Traversable[B]): Transformed[B] = new Appended[B] { val rest = that }
protected def newMapped[B](f: A => B): Transformed[B] = new Mapped[B] { val mapping = f }
protected def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
protected def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p }
protected def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until }
protected def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
protected def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p }
override def ++[B >: A, That](xs: TraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That = {
newAppended(xs.toTraversable).asInstanceOf[That]
// was: if (bf.isInstanceOf[ByPassCanBuildFrom]) newAppended(that).asInstanceOf[That]
// else super.++[B, That](that)(bf)
}
override def map[B, That](f: A => B)(implicit bf: CanBuildFrom[This, B, That]): That = {
newMapped(f).asInstanceOf[That]
// val b = bf(repr)
// if (b.isInstanceOf[NoBuilder[_]]) newMapped(f).asInstanceOf[That]
// else super.map[B, That](f)(bf)
}
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 => Traversable[B])(implicit bf: CanBuildFrom[This, B, That]): That = {
newFlatMapped(f).asInstanceOf[That]
// was: val b = bf(repr)
// if (b.isInstanceOf[NoBuilder[_]]) newFlatMapped(f).asInstanceOf[That]
// else super.flatMap[B, That](f)(bf)
}
protected[this] def thisSeq: Seq[A] = {
val buf = new ArrayBuffer[A]
self foreach (buf +=)
buf.result
}
override def filter(p: A => Boolean): This = newFiltered(p).asInstanceOf[This]
override def partition(p: A => Boolean): (This, This) = (filter(p), filter(!p(_)))
override def init: This = newSliced(0, size - 1).asInstanceOf[This]
override def drop(n: Int): This = newSliced(n max 0, Int.MaxValue).asInstanceOf[This]
override def take(n: Int): This = newSliced(0, n).asInstanceOf[This]
override def slice(from: Int, until: Int): This = newSliced(from max 0, until).asInstanceOf[This]
override def dropWhile(p: A => Boolean): This = newDroppedWhile(p).asInstanceOf[This]
override def takeWhile(p: A => Boolean): This = newTakenWhile(p).asInstanceOf[This]
override def span(p: A => Boolean): (This, This) = (takeWhile(p), dropWhile(p))
override def splitAt(n: Int): (This, This) = (take(n), drop(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]
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): Map[K, This] =
thisSeq.groupBy(f).mapValues(xs => newForced(xs).asInstanceOf[This])
override def stringPrefix = "TraversableView"
}
|
