An implementation of the Buffer 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.

Simple stack class backed by an array. Should be significantly faster than the standard mutable stack.

The class BitSet implements mutable, resizable Bit sets

Buffers are used to create sequences of elements incrementally by appending, prepending, or inserting new elements. It is also possible to access and modify elements in a random access fashion via the index of the element in the current sequence.

This is a simple proxy class for scala.collection.mutable.Buffer. It is most useful for assembling customized set abstractions dynamically using object composition and forwarding.

The J2ME version of the library defined this trait with a clone method to substitute for the lack of Object.clone there

This class is used internally. It implements the mutable Map class in terms of three functions: findEntry, addEntry, and entries.

This extensible class may be used as a basis for implementing double linked lists. Type variable A refers to the element type of the list, type variable This is used to model self types of linked lists.

This class can be used to construct data structures that are based on hashtables. Class HashTable[A] implements a hashtable that maps keys of type A to values of the fully abstract member type Entry. Classes that make use of HashTable have to provide an implementation for Entry There are mainly two parameters that affect the performance of a hashtable: the initial size and the load factor. The size refers to the number of buckets in the hashtable, and the load factor is a measure of how full the hashtable is allowed to get before its size is automatically doubled. Both parameters may be changed by overriding the corresponding values in class HashTable.

History[A, B] objects may subscribe to events of type A published by an object of type B. The history subscriber object records all published events up to maximum number of maxHistory events.

This class can be used as an adaptor to create mutable maps from immutable map implementations. Only method empty has to be redefined if the immutable map on which this mutable map is originally based is not empty. empty is supposed to return the representation of an empty map.

This class can be used as an adaptor to create mutable sets from immutable set implementations. Only method empty has to be redefined if the immutable set on which this mutable set is originally based is not empty. empty is supposed to return the representation of an empty set.

This observable update refers to inclusion operations that add new elements to collection classes.

This class can be used as an adaptor to create mutable maps from Java classes that implementat the java.util.Map interface.

This class can be used as an adaptor to create mutable sets from Java classes that implement interface java.util.Set.

This class implements single linked lists where both the head (elem) and the tail (next) are mutable.

A Buffer implementation back up by a list. It provides constant time prepend and append. Most other operations are linear.

Class Location describes locations in messages implemented by class Message.

This trait represents mutable maps. Concrete map implementations just have to provide functionality for the abstract methods in scala.collection.Map as well as for update, and -=.

Class Message represents messages that are issued by observable collection classes whenever a data structure is changed. Class Message has several subclasses for the various kinds of events: Update Remove, Include, Reset, and Script.

This class is typically used as a mixin. It turns maps which map A to Set[B] objects into multi maps which map A to B objects.

This class is used internally to represent mutable lists. It is the basis for the implementation of the classes Buffer, Stack, and Queue.

This class is typically used as a mixin. It adds a subscription mechanism to the Buffer class into which this abstract class is mixed in. Class ObservableBuffer publishes events of the type Message.

This class is typically used as a mixin. It adds a subscription mechanism to the Map class into which this abstract class is mixed in. Class ObservableMap publishes events of the type Message.

This class is typically used as a mixin. It adds a subscription mechanism to the Set class into which this abstract class is mixed in. Class ObservableSet publishes events of the type Message.

A mutable hash map based on an open hashing scheme. The precise scheme is undefined, but it should make a reasonable effort to ensure that an insert with consecutive hash codes is not unneccessarily penalised. In particular, mappings of consecutive integer keys should work without significant performance loss.

This class implements priority queues using a heap. The elements of the queue have to be ordered in terms of the Ordered[T] class.

This class implements priority queues using a heap. The elements of the queue have to be ordered in terms of the Ordered[T] class.

Publisher[A,This] objects publish events of type A to all registered subscribers. When subscribing, a subscriber may specify a filter which can be used to constrain the number of events sent to the subscriber. Subscribers may suspend their subscription, or reactivate a suspended subscription. Class Publisher is typically used as a mixin. The type variable This models self types.

Queue objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.

Queue objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.

This observable update refers to removal operations of elements from collection classes.

This command refers to reset operations.

This class is used internally to implement data structures that are based on resizable arrays. //todo enrich with more efficient operations

A revertable history is a History object which supports an undo operation. Type variable A refers to the type of the published events, B denotes the publisher type. Type B is typically a subtype of Publisher.

Objects of this class represent compound messages consisting of a sequence of other messages.

Classes that mix in the Scriptable class allow messages to be sent to objects of that class.

This class represents mutable sets. Concrete set implementations just have to provide functionality for the abstract methods in scala.collection.Set as well as for +=, -= and clear.

This is a simple wrapper class for scala.collection.mutable.Set. It is most useful for assembling customized set abstractions dynamically using object composition and forwarding.

This extensible class may be used as a basis for implementing linked list. Type variable A refers to the element type of the list, type variable This is used to model self types of linked lists.

A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.

A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.

Subscriber[A, B] objects may subscribe to events of type A published by an object of type B. B is typically a subtype of Publisher.

This class should be used as a mixin. It synchronizes the Buffer methods of the class into which it is mixed in.

This class should be used as a mixin. It synchronizes the Map functions of the class into which it is mixed in.

This class implements synchronized priority queues using a heap. The elements of the queue have to be ordered in terms of the Ordered[T] class.

This is a synchronized version of the Queue[T] class. It implements a data structure that allows one to insert and retrieve elements in a first-in-first-out (FIFO) manner.

This class should be used as a mixin. It synchronizes the Set functions of the class into which it is mixed in.

This is a synchronized version of the Stack[T] class. It implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.

Classes that mix in the Undoable class provide an operation undo which can be used to undo the last operation.

This observable update refers to destructive modification operations of elements from collection classes.

This class implements mutable maps using a hashtable.

This class implements mutable sets using a hashtable.

This class implements mutable maps using a hashtable.

The canonical factory methods for mutable maps. These currently return HashMap's.

The canonical factory methods for mutable sets. Currently these return HashSet's.