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 This class implements mutable, resizable Bit sets
`mixin` `abstract` | `class` 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.
`mixin` `abstract` | `class` 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.
`protected` | `class` DefaultEntry [ A , B ]
`mixin` `abstract` | `class` DefaultMapModel [ A , B ] This class is used internally. It implements the mutable `Map` class in terms of three functions: `findEntry`, `addEntry`, and `entries`.
`abstract` | `class` DoubleLinkedList [ A , scala.AllRef <: This <: scala.collection.mutable.DoubleLinkedList[A,This] ] 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 ] This class implements mutable maps using a hashtable.
| `class` HashSet [ A ] This class implements mutable sets using a hashtable.
`mixin` `abstract` | `class` 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` and implement the function `entryKey`. 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`.
| `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` LinkedList [ A ] This class implements single linked lists where both the head (`elem`) and the tail (`next`) are mutable.
`final` | `class` ListBuffer [ A ]
`abstract` | `class` Location Class `Location` describes locations in messages implemented by class `Message`.
`mixin` `abstract` | `class` Map [ A , B ] 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 `remove`.
`mixin` `abstract` | `class` 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.
`mixin` `abstract` | `class` 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`.
`mixin` `abstract` | `class` 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.
`mixin` `abstract` | `class` 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`.
`mixin` `abstract` | `class` 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`.
`mixin` `abstract` | `class` 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`.
`mixin` `abstract` | `class` 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`.
| `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.
`mixin` `abstract` | `class` 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.
| `class` Queue [ A ] `Queue` objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.
`mixin` `abstract` | `class` QueueProxy [ 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.
`mixin` `abstract` | `class` ResizableArray [ A ] This class is used internally to implement data structures that are based on resizable arrays.
| `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.
`mixin` `abstract` | `class` Scriptable [ A ] Classes that mix in the `Scriptable` class allow messages to be sent to objects of that class.
`mixin` `abstract` | `class` Set [ A ] 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 `add`, `remove`, and `clear`.
`mixin` `abstract` | `class` 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` | `class` SingleLinkedList [ A , scala.AllRef <: This <: scala.collection.mutable.SingleLinkedList[A,This] ] 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.
`mixin` `abstract` | `class` StackProxy [ A ] A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.
`mixin` `abstract` | `class` 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`.
`mixin` `abstract` | `class` SynchronizedBuffer [ A ] This class should be used as a mixin. It synchronizes the `Buffer` methods of the class into which it is mixed in.
`mixin` `abstract` | `class` 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.
| `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.
`mixin` `abstract` | `class` SynchronizedSet [ A ] This class should be used as a mixin. It synchronizes the `Set` functions of the class into which it is mixed in.
| `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.
`mixin` `abstract` | `class` Undoable Classes that mix in the `Undoable` class provide an operation `undo` which can be used to undo the last operation.
`case` | `class` Update [ A ] This observable update refers to destructive modification operations of elements from collection classes.

Object Summary
`case` | `object` End
`case` | `object` NA
`case` | `object` Start