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 <: DoubleLinkedList ]
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 <: ObservableBuffer ]
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 <: ObservableMap ]
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 <: ObservableSet ]
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 <: Publisher ]
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 <: 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 <: SingleLinkedList ]
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
|