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