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
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2009, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scalay.collection.generic
import Math.MAX_INT
import TraversableView.NoBuilder
/** <p>
* A base class for views of <code>Traversable</code>.
* </p>
* <p>
* Every subclass has to implement the <code>foreach</code> method.
* </p>
*
* @since 2.8
*/
abstract class TraversableView[+A, +Coll <: Traversable[_]] extends Traversable[A] {
self =>
type This >: this.type <: TraversableView[A, Coll] { type This = self.This }
protected val thisCollection: This = this
protected[this] def newBuilder: Builder[A, This, This] =
throw new UnsupportedOperationException(this+".newBuilder")
def force[B >: A, That](implicit b: Builder[B, That, Coll]) = {
b ++= this
b.result()
}
trait Transformed[+B] extends TraversableView[B, Coll]
/** pre: from >= 0
*/
trait Sliced extends Transformed[A] {
protected[this] val from: Int
protected[this] val until: Int
override def foreach(f: A => Unit) {
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) =
newSliced(from + (from1 max 0), from + (until1 max 0)).asInstanceOf[This]
}
trait Mapped[B] extends Transformed[B] {
protected[this] val mapping: A => B
override def foreach(f: B => Unit) {
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(f: B => Unit) {
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(f: B => Unit) {
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(f: A => Unit) {
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(f: A => Unit) {
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(f: A => Unit) {
var go = false
for (x <- self) {
if (!go && !pred(x)) go = true
if (go) f(x)
}
}
override def stringPrefix = self.stringPrefix+"D"
}
override def ++[B >: A, That](that: Traversable[B])(implicit b: Builder[B, That, This]): That =
if (b.isInstanceOf[NoBuilder[_]]) newAppended(that).asInstanceOf[That]
else super.++[B, That](that)(b)
override def ++[B >: A, That](that: Iterator[B])(implicit b: Builder[B, That, This]): That = ++[B, That](that.toStream)
override def map[B, That](f: A => B)(implicit b: Builder[B, That, This]): That =
if (b.isInstanceOf[NoBuilder[_]]) newMapped(f).asInstanceOf[That]
else super.map[B, That](f)(b)
override def flatMap[B, That](f: A => Traversable[B])(implicit b: Builder[B, That, This]): That =
if (b.isInstanceOf[NoBuilder[_]]) newFlatMapped(f).asInstanceOf[That]
else super.flatMap[B, That](f)(b)
override def filter(p: A => Boolean): This = newFiltered(p).asInstanceOf[This]
override def init: This = newSliced(0, size - 1).asInstanceOf[This]
override def drop(n: Int): This = newSliced(n max 0, MAX_INT).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))
}
object TraversableView {
class NoBuilder[A] extends Builder[A, Nothing, TraversableView[_, _]] {
def +=(elem: A) {}
def iterator: Iterator[A] = Iterator.empty
@deprecated("use `iterator' instead") def elements = iterator
def result() = throw new UnsupportedOperationException("TraversableView.Builder.result")
def clear() {}
}
implicit def implicitBuilder[A]: Builder[A, TraversableView[A, Traversable[_]], TraversableView[_, _]] = new NoBuilder
}
|
