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 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
|
|
case
|
object
Start
|