Scala 2
API Specification

This document is the API specification for Scala 2.

Class Summary
| `class` ArrayBuffer [A] An implementation of the `Buffer` class using an array to represent the assembled sequence internally.
| `class` BitSet The class `BitSet` implements mutable, resizable Bit sets
`final` | `class` DefaultEntry [A, B]
`abstract` | `class` DoubleLinkedList [A, This <: scala.collection.mutable.DoubleLinkedList[A, This] >: scala.Null] 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.
| `class` HashMap [A, B]
| `class` HashSet [A]
| `class` History [A, B] `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.
| `class` ImmutableMapAdaptor [A, B] 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.
| `class` ImmutableSetAdaptor [A] 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.
`case` | `class` Include [+I] This observable update refers to inclusion operations that add new elements to collection classes.
`case` | `class` Index
| `class` JavaMapAdaptor [A, B] This class can be used as an adaptor to create mutable maps from Java classes that implementat the `java.util.Map` interface.
| `class` JavaSetAdaptor [A] This class can be used as an adaptor to create mutable sets from Java classes that implement interface `java.util.Set`.
| `class` LinkedHashSet [A] This class...
| `class` LinkedList [A] This class implements single linked lists where both the head (`elem`) and the tail (`next`) are mutable.
`final` | `class` ListBuffer [A] The class `ListBuffer` ..
`abstract` | `class` Location Class `Location` describes locations in messages implemented by class `Message`.
| `class` PriorityQueue [A] This class implements priority queues using a heap. The elements of the queue have to be ordered in terms of the `Ordered[T]` class.
`abstract` | `class` PriorityQueueProxy [A] This class implements priority queues using a heap. The elements of the queue have to be ordered in terms of the `Ordered[T]` class.
| `class` Queue [A] `Queue` objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.
`case` | `class` Remove [+A] This observable update refers to removal operations of elements from collection classes.
`case` | `class` Reset [+A] This command refers to reset operations.
| `class` RevertableHistory [A <: scala.collection.mutable.Undoable, B] 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`.
| `class` Script [A] Objects of this class represent compound messages consisting of a sequence of other messages.
`abstract` | `class` SingleLinkedList [A, This <: scala.collection.mutable.SingleLinkedList[A, This] >: scala.Null] 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.
| `class` Stack [A] A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.
| `class` SynchronizedPriorityQueue [A] 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.
| `class` SynchronizedQueue [A] 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.
| `class` SynchronizedStack [A] 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.
`case` | `class` Update [+A] This observable update refers to destructive modification operations of elements from collection classes.

Trait Summary
`abstract` | `trait` Buffer [A] 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.
`abstract` | `trait` BufferProxy [A] 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.
`abstract` | `trait` DefaultMapModel [A, B] This class is used internally. It implements the mutable `Map` class in terms of three functions: `findEntry`, `addEntry`, and `entries`.
`abstract` | `trait` FlatHashTable [A]
`abstract` | `trait` HashEntry [A, E]
`abstract` | `trait` HashTable [A] 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`.
`abstract` | `trait` Map [A, B]
`abstract` | `trait` MapProxy [A, B] This is a simple wrapper class for `scala.collection.mutable.Map`. It is most useful for assembling customized map abstractions dynamically using object composition and forwarding.
`abstract` | `trait` Message [+A] 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`.
`abstract` | `trait` MultiMap [A, B] 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.
`abstract` | `trait` MutableList [A] This class is used internally to represent mutable lists. It is the basis for the implementation of the classes `Buffer`, `Stack`, and `Queue`.
`abstract` | `trait` ObservableBuffer [A, This <: scala.collection.mutable.ObservableBuffer[A, This]] 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`.
`abstract` | `trait` ObservableMap [A, B, This <: scala.collection.mutable.ObservableMap[A, B, This]] 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`.
`abstract` | `trait` ObservableSet [A, This <: scala.collection.mutable.ObservableSet[A, This]] 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`.
`abstract` | `trait` Publisher [A, This <: scala.collection.mutable.Publisher[A, This]] `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.
`abstract` | `trait` QueueProxy [A] `Queue` objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.
`abstract` | `trait` ResizableArray [A] This class is used internally to implement data structures that are based on resizable arrays. //todo enrich with more efficient operations
`abstract` | `trait` Scriptable [A] Classes that mix in the `Scriptable` class allow messages to be sent to objects of that class.
`abstract` | `trait` Set [A]
`abstract` | `trait` SetProxy [A] 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.
`abstract` | `trait` StackProxy [A] A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.
`abstract` | `trait` Subscriber [-A, -B] `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`.
`abstract` | `trait` SynchronizedBuffer [A] This class should be used as a mixin. It synchronizes the `Buffer` methods of the class into which it is mixed in.
`abstract` | `trait` SynchronizedMap [A, B] This class should be used as a mixin. It synchronizes the `Map` functions of the class into which it is mixed in.
`abstract` | `trait` SynchronizedSet [A] This class should be used as a mixin. It synchronizes the `Set` functions of the class into which it is mixed in.
`abstract` | `trait` Undoable Classes that mix in the `Undoable` class provide an operation `undo` which can be used to undo the last operation.

Object Summary
`case` | `object` End
| `object` HashMap This class implements mutable maps using a hashtable.
| `object` HashSet This class implements mutable sets using a hashtable.
| `object` Map This class 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 `-=`.
`case` | `object` NA
| `object` Set 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`.`
`case` | `object` Start