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
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2008, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id: Sequence.scala 16092 2008-09-12 10:37:06Z nielsen $
package scalax.collection.generic.mutable
import collection.mutable.Vector
import collection.mutable.Vector._
/** A non-strict projection of an iterable.
* @author Sean McDirmid
* @author Martin Odersky
* @note this should really be a virtual class of SequenceFactory
*/
trait VectorView[+UC[B] <: Vector[B], A] extends SequenceView[UC, A] with Vector[A] {
self =>
/** refined from Iterable.View */
val origin: Vector[_]
trait Transformed[B] extends super.Transformed[B] with VectorView[UC, B] {
override val origin = self
override def elements: Iterator[B] = new Elements(0, length)
override protected def asCC = asInstanceOf[VectorView[UC, B]]
}
class Appended(that: Vector[A]) extends super.Appended[A](that) with Transformed[A] {
override def update(idx: Int, elem: A) {
val ll = self.length
if (idx < ll) self.update(idx, elem) else that.update(idx - ll, elem)
}
}
class Sliced(from: Int, to: Int) extends super.Sliced(from, to) with Transformed[A] {
override def update(idx: Int, elem: A) {
if (idx >= 0 && idx < length) self.update(idx + from, elem)
else throw new IndexOutOfBoundsException(idx.toString)
}
override def slice(from1: Int, to1: Int) =
new self.Sliced(from + (from1 min length max 0) , to + (to1 min length max 0))
}
class Reversed extends super.Reversed with Transformed[A] {
override def update(idx: Int, elem: A) {
self.update(length - 1 - idx, elem)
}
}
class Zipped[B](that: Vector[B]) extends super.Zipped[B](that) with Transformed[(A, B)] {
override def update(idx: Int, elem: (A, B)) {
self.update(idx, elem._1)
that.update(idx, elem._2)
}
}
def ++(that: Vector[A]): VectorView[UC, A] =
new Appended(that).asCC
override def reverse: VectorView[UC, A] =
(new Reversed).asCC
private def toVector[B](xs: Iterable[B]): Vector[B] = xs match {
case ras: Vector[_] => ras.asInstanceOf[Vector[B]]
case _ => Vector() ++ xs
}
override def zip[B](that: Iterable[B]): VectorView[UC, (A, B)] =
new Zipped(toVector(that)).asCC
override def zipWithIndex: VectorView[UC, (A, Int)] =
zip((0 until length).asInstanceOf[Null]) // !!!
override def take(n: Int): VectorView[UC, A] =
slice(0, n)
override def drop(n: Int): VectorView[UC, A] =
slice(n, Math.MAX_INT)
override def splitAt(n: Int): (VectorView[UC, A], VectorView[UC, A]) = (take(n), drop(n))
override def slice(from: Int, until: Int): VectorView[UC, A] =
new Sliced(from, until).asCC
override def takeWhile(p: A => Boolean): VectorView[UC, A] =
take(prefixLength(p))
override def dropWhile(p: A => Boolean): VectorView[UC, A] =
drop(prefixLength(p))
override def span(p: A => Boolean): (VectorView[UC, A], VectorView[UC, A]) = {
val n = prefixLength(p)
(take(n), drop(n))
}
}
|
