in scala/collection
package mutable

package mutable

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.