|
Scala
1.4.0.3 |
|||
Object Summary | |
case
|
object End
|
case
|
object NA
|
case
|
object Start
|
Trait Summary | |
trait Buffer[A]()
Buffers are used to create sequences of elements incrementally by appending, prepending, or inserting new elements. |
|
trait BufferProxy[A]()
This is a simple proxy class for scala.collection.mutable.Buffer .
|
|
trait DefaultMapModel[A,B]()
This trait is used internally. |
|
trait Location()
Class Location describes locations in messages implemented
by class Message .
|
|
trait Map[A,B]()
This trait represents mutable maps. |
|
trait MapProxy[A,B]()
This is a simple wrapper class for scala.collection.mutable.Map .
|
|
trait Message[+A]()
Class Message represents messages that are issued by observable
collection classes whenever a data structure is changed.
|
|
trait MultiMap[A,B]()
This class is typically used as a mixin. |
|
trait QueueProxy[A]()
Queue objects implement data structures that allow to
insert and retrieve elements in a first-in-first-out (FIFO) manner.
|
|
trait Scriptable[A]()
Classes that implement the Scriptable trait allow
messages to be sent to objects of that class.
|
|
trait Set[A]()
This trait represents mutable sets. |
|
trait SetProxy[A]()
This is a simple wrapper class for scala.collection.mutable.Set .
|
|
trait StackProxy[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]()
Subscriber[A, B] objects may subscribe to events of
type A published by an object of type B .
|
|
trait SynchronizedBuffer[A]()
This trait should be used as a mixin. |
|
trait SynchronizedMap[A,B]()
This trait should be used as a mixin. |
|
trait SynchronizedSet[A]()
This trait should be used as a mixin. |
|
trait Undoable()
Classes that implement the Undoable trait provide an operation
undo which can be used to undo the last operation.
|
Class Summary | |
class ArrayBuffer[A]()
An implementation of the Buffer trait using an array to represent the assembled sequence internally. |
|
class BitSet(initSize: Int)
mutable, resizable bit sets, to represent dense sets of small integers Bit indices are between 0..(size-1) inclusive |
|
protected
|
class DefaultEntry[A,B](k: A, v: B)
|
abstract
|
class DoubleLinkedList[A,This<:DoubleLinkedList[A,This]]()
This extensible class may be used as a basis for implementing double 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. |
|
abstract
|
class HashTable[A]()
This class can be used to construct data structures that are based on hashtables. |
class History[A,B]()
History[A, B] objects may subscribe to events of
type A published by an object of type B .
|
|
class ImmutableMapAdaptor[A,B](m: Map[A,B])
This class can be used as an adaptor to create mutable maps from immutable map implementations. |
|
class ImmutableSetAdaptor[A](s: Set[A])
This class can be used as an adaptor to create mutable sets from immutable set implementations. |
|
case
|
class Include[+I](elem: I)
This observable update refers to inclusion operations that add new elements to collection classes. |
case
|
class Index(n: Int)
|
class JavaMapAdaptor[A,B](jmap: java.util.Map)
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: java.util.Set)
This class can be used as an adaptor to create mutable sets from Java classes that implement interface java.util.Set .
|
|
class LinkedList[A](head: A, tail: LinkedList[A])
This class implements single linked lists where both the head ( elem )
and the tail (next ) are mutable.
|
|
class ListBuffer[A]()
A list buffer uses a list internally to assemble sequences of elements incrementally by appending or prepending new elements. |
|
abstract
|
class MutableList[A]()
This class is used internally to represent mutable lists. |
abstract
|
class ObservableBuffer[A,This<:ObservableBuffer[A,This]]()
This class is typically used as a mixin. |
abstract
|
class ObservableMap[A,B,This<:ObservableMap[A,B,This]]()
This class is typically used as a mixin. |
abstract
|
class ObservableSet[A,This<:ObservableSet[A,This]]()
This class is typically used as a mixin. |
class PriorityQueue[A](view: (A) => Ordered[A])
This class implements priority queues using a heap. |
|
abstract
|
class PriorityQueueProxy[A](view: (A) => Ordered[A])
This class implements priority queues using a heap. |
abstract
|
class Publisher[A,This<:Publisher[A,This]]()
Publisher[A,This] objects publish events of type A
to all registered subscribers.
|
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](elem: A)
This observable update refers to removal operations of elements from collection classes. |
case
|
class Reset[+A]()
This command refers to reset operations. |
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.
|
|
class Script[A]()
Objects of this class represent compound messages consisting of a sequence of other messages. |
|
abstract
|
class SingleLinkedList[A,This<:SingleLinkedList[A,This]]()
This extensible class may be used as a basis for implementing linked list. |
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](view: (A) => Ordered[A])
This class implements synchronized priority queues using a heap. |
|
class SynchronizedQueue[A]()
This is a synchronized version of the Queue[T] class.
|
|
class SynchronizedStack[A]()
This is a synchronized version of the Stack[T] class.
|
|
case
|
class Update[+A](elem: A)
This observable update refers to destructive modification operations of elements from collection classes. |
|
Scala
1.4.0.3 |
|||