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
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2009, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id: ArrayBuffer.scala 15407 2008-06-20 09:26:36Z stepancheg $
package scalax.collection.mutable
import generic.SequenceFactory
/* Factory object for `ArrayBuffer` class */
object ArrayBuffer extends SequenceFactory[ArrayBuffer] {
def apply[A](args: A*): ArrayBuffer[A] = new ArrayBuffer[A] ++ args.asInstanceOf[Iterable[A]] // !@!
}
/** An implementation of the <code>Buffer</code> class using an array to
* represent the assembled sequence internally. Append, update and random
* access take constant time (amortized time). Prepends and removes are
* linear in the buffer size.
*
* @author Matthias Zenger
* @author Martin Odersky
* @version 2.8
*/
@serializable
class ArrayBuffer[A](override protected val initialSize: Int)
extends Buffer[A]
with Vector[A]
with generic.mutable.VectorTemplate[ArrayBuffer, A]
with Builder[ArrayBuffer, A]
with ResizableArray[A] {
def this() = this(16)
def clear() { reduceToSize(0) }
/** Appends a single element to this buffer and returns
* the identity of the buffer. It takes constant time.
*
* @param elem the element to append.
*/
def +=(elem: A) {
ensureSize(size0 + 1)
array(size0) = elem.asInstanceOf[AnyRef]
size0 += 1
}
/** Appends a number of elements provided by an iterable object
* via its <code>elements</code> method. The identity of the
* buffer is returned.
*
* @param iter the iterfable object.
* @return the updated buffer.
*/
override def ++=(iter: collection.Iterable[A]) = iter match {
case v: Vector[_] =>
val n = v.length
ensureSize(size0 + n)
v.copyToArray(array.asInstanceOf[scala.Array[Any]], n)
case _ =>
super.++=(iter)
}
/** Prepends a single element to this buffer and return
* the identity of the buffer. It takes time linear in
* the buffer size.
*
* @param elem the element to append.
* @return the updated buffer.
*/
def +:(elem: A): this.type = {
ensureSize(size0 + 1)
copy(0, 1, size0)
array(0) = elem.asInstanceOf[AnyRef]
size0 += 1
this
}
/** Prepends a number of elements provided by an iterable object
* via its <code>elements</code> method. The identity of the
* buffer is returned.
*
* @param iter the iterable object.
* @return the updated buffer.
*/
override def ++:(iter: Iterable[A]): this.type = { insertAll(0, iter); this }
/** Inserts new elements at the index <code>n</code>. Opposed to method
* <code>update</code>, this method will not replace an element with a
* one. Instead, it will insert a new element at index <code>n</code>.
*
* @param n the index where a new element will be inserted.
* @param iter the iterable object providing all elements to insert.
* @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds.
*/
def insertAll(n: Int, iter: Iterable[A]) {
if ((n < 0) || (n > size0))
throw new IndexOutOfBoundsException(n.toString)
val xs = iter.elements.toList
val len = xs.length
ensureSize(size0 + len)
copy(n, n + len, size0 - n)
xs.copyToArray(array.asInstanceOf[scala.Array[Any]], n)
size0 += len
}
/** Removes the element on a given index position. It takes time linear in
* the buffer size.
*
* @param n the index which refers to the first element to delete.
* @param count the number of elemenets to delete
* @return the updated array buffer.
* @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds.
*/
def remove(n: Int, count: Int) {
if ((n < 0) || (n >= size0))
throw new IndexOutOfBoundsException(n.toString)
copy(n + count, n, size0 - (n + count))
size0 -= count
}
/** Return a clone of this buffer.
*
* @return an <code>ArrayBuffer</code> with the same elements.
*/
override def clone(): Buffer[A] = new ArrayBuffer[A] ++ this
def result: ArrayBuffer[A] = this
/** Defines the prefix of the string representation.
*/
override def stringPrefix: String = "ArrayBuffer"
}
|
