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
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2006, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id$
package scala.collection.mutable
/** This is a simple proxy class for <a href="Buffer.html"
* target="contentFrame"><code>scala.collection.mutable.Buffer</code></a>.
* It is most useful for assembling customized set abstractions
* dynamically using object composition and forwarding.
*
* @author Matthias Zenger
* @version 1.0, 16/04/2004
*/
trait BufferProxy[A] extends Buffer[A] with Proxy {
def self: Buffer[A]
def length: Int = self.length
override def elements: Iterator[A] = self.elements
def apply(n: Int): A = self.apply(n)
/** Append a single element to this buffer and return
* the identity of the buffer.
*
* @param elem the element to append.
* @return the updated buffer.
*/
override def +(elem: A): Buffer[A] = self.+(elem)
/** Append a single element to this buffer.
*
* @param elem the element to append.
*/
def +=(elem: A): Unit = self.+=(elem)
override def readOnly = self.readOnly
/** 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 iterable object.
* @return the updated buffer.
*/
override def ++(iter: Iterable[A]): Buffer[A] = self.++(iter)
/** Appends a number of elements provided by an iterable object
* via its <code>elements</code> method.
*
* @param iter the iterable object.
*/
override def ++=(iter: Iterable[A]): Unit = self.++=(iter)
/** Appends a sequence of elements to this buffer.
*
* @param elems the elements to append.
*/
override def append(elems: A*): Unit = self.++=(elems)
/** Appends a number of elements provided by an iterable object
* via its <code>elements</code> method.
*
* @param iter the iterable object.
*/
override def appendAll(iter: Iterable[A]): Unit = self.appendAll(iter)
/** Prepend a single element to this buffer and return
* the identity of the buffer.
*
* @param elem the element to append.
*/
def +:(elem: A): Buffer[A] = self.+:(elem)
/** 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.
*/
override def ++:(iter: Iterable[A]): Buffer[A] = self.++:(iter)
/** Prepend an element to this list.
*
* @param elem the element to prepend.
*/
override def prepend(elems: A*): Unit = self.prependAll(elems)
/** 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.
*/
override def prependAll(elems: Iterable[A]): Unit = self.prependAll(elems)
/** 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 the new elements at index <code>n</code>.
*
* @param n the index where a new element will be inserted.
* @param elems the new elements to insert.
*/
override def insert(n: Int, elems: A*): Unit = self.insertAll(n, elems)
/** 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.
*/
def insertAll(n: Int, iter: Iterable[A]): Unit = self.insertAll(n, iter)
/** Replace element at index <code>n</code> with the new element
* <code>newelem</code>.
*
* @param n the index of the element to replace.
* @param newelem the new element.
*/
def update(n: Int, newelem: A): Unit = self.update(n, newelem)
/** Removes the element on a given index position.
*
* @param n the index which refers to the element to delete.
*/
def remove(n: Int): A = self.remove(n)
/** Clears the buffer contents.
*/
def clear(): Unit = self.clear
/** Send a message to this scriptable object.
*
* @param cmd the message to send.
*/
override def <<(cmd: Message[(Location, A)]): Unit = self << cmd
/** Return a clone of this buffer.
*
* @return a <code>Buffer</code> with the same elements.
*/
override def clone(): Buffer[A] = new BufferProxy[A] {
def self = BufferProxy.this.self.clone()
}
}
|
