boolean dump_simple_p;
YES.
boolean equal id other;
void freeze;
Collection frozen;
self if this is a non-mutable Collection. Otherwise,
return a non-mutable collection with the same contents.
_builtin_.Any member All object;
equal to
the object. The default implementation by Collection visits the
elements using an enumerator.
_builtin_.Any memq All object;
member, but the element is identified on reference equality.
deferred int length;
Collection.
void makeElementsPerform Invocation invocation;
invocation at the elements contained in the receiving
collection.
void makeElementsPerform selector message;
message to the elements contained in the
receiving collection.
void
makeElementsPerform selector message
with All argument;
message with the object argument to the elements
contained in the receiving collection.
boolean mutable;
Collection is not mutable.
void passElementsTo Invocation inv;
OutputStream write OutputStream s;
deferred void add All object;
void addElementsFrom Enumerable other;
void addElementsFromEnumerator Enumerator e;
deferred void empty;
deferred void freeze;
freeze to be undefined since each particular subclass must
itself implement it.
id (self) initWithEnumerator Enumerator e;
self the elements from the enumerator.
boolean mutable;
MutableCollection is mutable.
Keyed Collection stores elements on a key.
deferred _builtin_.Any at All key pre key != nil;
deferred void add All object;
object.
deferred void remove All object;
object.
Mapped Collection is a Keyed collection which stores (key,
value) associations.
boolean equal id other;
deferred Enumerator keyEnumerator;
void add All value;
deferred void set All value at All key pre key != nil && value != nil;
Ordered Collection maintains its elements in a specific order,
though the time complexity or retrieving the nth object not
necessarily independent of n.
Indexed Collection maintains an association between integer
indices and the objects it contains, with the promise that retrieving
an object through the index is O(1) in time complexity.
(int, int) adjustRange (int, int) (start, len);
start, len) to fit the length of the receiving
Indexed collection.
deferred _builtin_.Any at int index;
index. If the receiving collection stores
unboxed values, such as integers, the value returned is the element
boxed.
byte at int index;
index. If the receiving
collection stores objects, the byteValue of the element retrieved is
actually returned.
char at int index;
at int at int index;
long at int index;
float at int index;
double at int index;
dynamic elements;
dynamic elements (int, int) (start, num);
elements, but extract only the num elements starting at
index start.
Enumerator enumerator;
Enumerator on this Indexed.
boolean equal id other;
Collection.
int indexOf All element;
element, or -1 if it could not be
found.
int indexOfIdentical All element;
element, or -1 if it could
not be found.
void makeElementsPerform Invocation inv;
Collection,
without using an Enumerator.
void makeElementsPerform selector message;
void
makeElementsPerform selector message
with All argument;
void passElementsTo Invocation inv;
deferred void set All object at int index;
object at index in the receiving collection.
deferred void swap (int, int) (i, j);
i and j.
void reverse (int, int) (start, len);
start, with length
len.
deferred void removeElementAt int index;
index, decreasing by 1 the indices of the
elements further in the collection.
void removeElement All element;
element.
void removeIdenticalElement All element;
element.
IndexedEnumerator enumerates any Indexed collection,
returning the elements boxed.
instance (id) with Indexed indexed;
int next;
int num;
Indexed indexed;
id (self)
init Indexed a
start: int start = 0
length int length;
(boolean, _builtin_.Any) next;
(boolean, byte) next;
next methods are not really necessary, as they are
provided by the Enumerator behaviour. However, binding them here
directly greatly enhances speed and reduces memory requirements for
non-object indexeds, which now also do not need their own enumerator to
obtain speed.
(boolean, char) next;
(boolean, int) next;
(boolean, long) next;
(boolean, float) next;
(boolean, double) next;