Scala 2.5.1-final
API Specification

This document is the API specification for Scala Library Documentation

Class Summary
`class` | ArrayBuffer [A]`extends` Buffer[A]`with` ResizableArray[A] An implementation of the `Buffer` class using an array to represent the assembled sequence internally.
`class` | BitSet (initSize : Int)`extends` BitSet `with` Set[Int] The class `BitSet` implements mutable, resizable Bit sets
`trait` | Buffer [A]`extends` Seq[A]`with` Scriptable[Message[(Location, 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.
`trait` | BufferProxy [A]`extends` Buffer[A]`with` Proxy 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.
`final class` | DefaultEntry [A, B](`val` key : A, `val` value : B)`extends` HashEntry[A, DefaultEntry[A, B]]
`trait` | DefaultMapModel [A, B]`extends` Map[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, This <: DoubleLinkedList[A, This] >: Null]`extends` SingleLinkedList[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.
`trait` | FlatHashTable [A]`extends` AnyRef
`trait` | HashEntry [A, E]`extends` AnyRef
`class` | HashMap [A, B]`extends` HashTable[A]`with` DefaultMapModel[A, B]
`class` | HashSet [A]`extends` Set[A]`with` FlatHashTable[A]
`trait` | HashTable [A]`extends` AnyRef 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`.
`class` | History [A, B]`extends` Subscriber[A, B]`with` Collection[(B, A)] `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](`protected val` imap : Map[A, B])`extends` Map[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](`protected val` set : Set[A])`extends` Set[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](`val` elem : I)`extends` Message[I]`with` Product This observable update refers to inclusion operations that add new elements to collection classes.
`case class` | Index (`val` n : Int)`extends` Location `with` Product
`class` | JavaMapAdaptor [A, B](jmap : Map)`extends` Map[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](jset : Set)`extends` Set[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](`private` set0 : LinkedHashSet)`extends` Set[A] This class...
`class` | LinkedList [A](`val` elem : A, `val` next : LinkedList[A])`extends` SingleLinkedList[A, LinkedList[A]] This class implements single linked lists where both the head (`elem`) and the tail (`next`) are mutable.
`final class` | ListBuffer [A]`extends` Buffer[A] The class `ListBuffer` ..
`abstract class` | Location `extends` AnyRef Class `Location` describes locations in messages implemented by class `Message`.
`trait` | Map [A, B]`extends` Map[A, B]`with` Scriptable[Message[(A, B)]] 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 `-=`.
`trait` | MapProxy [A, B]`extends` Map[A, B]`with` 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.
`trait` | Message [+A]`extends` AnyRef 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`.
`trait` | MultiMap [A, B]`extends` Map[A, Set[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.
`trait` | MutableList [A]`extends` Seq[A] This class is used internally to represent mutable lists. It is the basis for the implementation of the classes `Buffer`, `Stack`, and `Queue`.
`trait` | ObservableBuffer [A, This <: ObservableBuffer[A, This]]`extends` Buffer[A]`with` Publisher[Message[(Location, A)]`with` Undoable, 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`.
`trait` | ObservableMap [A, B, This <: ObservableMap[A, B, This]]`extends` Map[A, B]`with` Publisher[Message[(A, B)]`with` Undoable, 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`.
`trait` | ObservableSet [A, This <: ObservableSet[A, This]]`extends` Set[A]`with` Publisher[Message[A]`with` Undoable, 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](`implicit` view$0 : (A) => Ordered[A])`extends` ResizableArray[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](`implicit` view$0 : (A) => Ordered[A])`extends` PriorityQueue[A]`with` SeqProxy[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.
`trait` | Publisher [A, This <: Publisher[A, This]]`extends` AnyRef `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]`extends` MutableList[A] `Queue` objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.
`trait` | QueueProxy [A]`extends` Queue[A]`with` SeqProxy[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](`val` elem : A)`extends` Message[A]`with` Product This observable update refers to removal operations of elements from collection classes.
`case class` | Reset [+A]`extends` Message[A]`with` Product This command refers to reset operations.
`trait` | ResizableArray [A]`extends` RandomAccessSeq[A] This class is used internally to implement data structures that are based on resizable arrays. //todo enrich with more efficient operations
`class` | RevertableHistory [A <: Undoable, B]`extends` History[A, B]`with` Undoable 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]`extends` ArrayBuffer[Message[A]]`with` Message[A] Objects of this class represent compound messages consisting of a sequence of other messages.
`trait` | Scriptable [A]`extends` AnyRef Classes that mix in the `Scriptable` class allow messages to be sent to objects of that class.
`trait` | Set [A]`extends` Set[A]`with` Scriptable[Message[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 `+=`, `-= and `clear`.`
`trait` | SetProxy [A]`extends` Set[A]`with` 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, This <: SingleLinkedList[A, This] >: Null]`extends` Seq[A] 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]`extends` MutableList[A] A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.
`trait` | StackProxy [A]`extends` Stack[A]`with` SeqProxy[A] A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.
`trait` | Subscriber [-A, -B]`extends` AnyRef `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`.
`trait` | SynchronizedBuffer [A]`extends` Buffer[A] This class should be used as a mixin. It synchronizes the `Buffer` methods of the class into which it is mixed in.
`trait` | SynchronizedMap [A, B]`extends` Map[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](`implicit` view$0 : (A) => Ordered[A])`extends` PriorityQueue[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]`extends` Queue[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.
`trait` | SynchronizedSet [A]`extends` Set[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]`extends` Stack[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.
`trait` | Undoable `extends` AnyRef Classes that mix in the `Undoable` class provide an operation `undo` which can be used to undo the last operation.
`case class` | Update [+A](`val` elem : A)`extends` Message[A]`with` Product This observable update refers to destructive modification operations of elements from collection classes.

Object Summary
`case object` | End `extends` Location `with` Product
`object` | HashMap `extends` AnyRef This class implements mutable maps using a hashtable.
`object` | HashSet `extends` AnyRef This class implements mutable sets using a hashtable.
`object` | Map `extends` AnyRef The canonical factory methods for mutable maps. These currently return HashMap's.
`case object` | NA `extends` Location `with` Product
`object` | Set `extends` AnyRef The canonical factory methods for mutable sets. Currently these return HashSet's.
`case object` | Start `extends` Location `with` Product