The canonical builder for collections that are addable, i .
An implementation of the Buffer
class using an array to
represent the assembled sequence internally.
A builder class for arrays .
A common supertrait of ArrayOps
and WrappedArray
that factors out most
operations on arrays and wrapped arrays.
This class serves as a wrapper for Array
s with all the operations found in
indexed sequences.
A class for polymorphic arrays of elements that's represented internally by an array of objects .
Simple stack class backed by an array .
A class for mutable bitsets .
Buffers are used to create sequences of elements incrementally by appending, prepending, or inserting new elements .
A template trait for buffers of type Buffer[A]
.
This is a simple proxy class for
The base trait of all builders .
trait
Builder[-Elem, +To] extends Growable[Elem]
A trait for cloneable collections .
The J2ME version of the library defined this trait with a clone
method to substitute for the lack of Object.clone
there.
A template trait for mutable maps that allow concurrent access .
Class used internally for default map model .
This class is used internally .
This class implements double linked lists where both the head (elem
),
the tail (next
) and a reference to the previous node (prev
) are mutable.
This extensible class may be used as a basis for implementing double linked lists .
An implementation class backing a HashSet
.
The canonical builder for collections that are growable, i .
Class used internally .
This class implements mutable maps using a hashtable .
This class implements mutable sets using a hashtable .
This class can be used to construct data structures that are based on hashtables .
History[A, B]
objects may subscribe to events of
type A
published by an object of type B
.
This class can be used as an adaptor to create mutable maps from immutable map implementations .
This class can be used as an adaptor to create mutable sets from immutable set implementations .
A subtrait of collection.IndexedSeq
which represents sequences
that can be mutated.
A subtrait of scala .
A subtrait of scala .
A non-strict view of a mutable IndexedSeq
.
A base trait for iterable collections that can be mutated .
A builder that constructs its result lazily .
A subtrait of collection.LinearSeq
which represents sequences
that can be mutated.
Class for the linked hash map entry, used internally .
This class implements mutable maps using a hashtable .
This class implements mutable sets using a hashtable .
This class implements single linked lists where both the head (elem
)
and the tail (next
) are mutable.
This extensible class may be used as a basis for implementing linked list .
A Buffer
implementation back up by a list.
A simple mutable map backed by a list .
A base trait for maps that can be mutated .
The canonical builder for immutable maps, working with the map's +
method
to add new elements.
A template trait for mutable maps .
This trait implements a proxy for
A trait for mutable maps with multiple values assigned to a key .
trait
MultiMap[A, B] extends Map[A, Set[B]]
This class is used internally to represent mutable lists .
This class is typically used as a mixin .
This class is typically used as a mixin .
This class is typically used as a mixin .
A mutable hash map based on an open hashing scheme .
This class implements priority queues using a heap .
This class servers as a proxy for priority queues .
Publisher[A,This]
objects publish events of type A
to all registered subscribers.
Queue
objects implement data structures that allow to
insert and retrieve elements in a first-in-first-out (FIFO) manner.
Queue
objects implement data structures that allow to
insert and retrieve elements in a first-in-first-out (FIFO) manner.
This class is used internally to implement data structures that are based on resizable arrays .
A revertible history is a History
object which supports
an undo operation.
A subtrait of collection.Seq
which represents sequences
that can be mutated.
A base trait for sets that can be mutated .
The canonical builder for mutable Sets .
A template trait for mutable sets of type mutable.Set[A]
.
This is a simple wrapper class for
A stack implements a data structure which allows to store and retrieve
objects in a last-in-first-out (LIFO) fashion .
class
Stack[A] extends Seq[A] with Cloneable[Stack[A]]
A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion .
A builder for mutable sequence of characters .
Subscriber[A, B] objects may subscribe to events of type A published by an object of type B .
This class should be used as a mixin .
This class should be used as a mixin .
This class implements synchronized priority queues using a binary heap .
This is a synchronized version of the Queue[T]
class.
This class should be used as a mixin .
This is a synchronized version of the Stack[T]
class.
A trait for traversable collections that can be mutated .
Classes that mix in the Undoable
class provide an operation
undo
which can be used to undo the last operation.
A hash map with references to entries which are weakly reachable .
A class representing Array[T]
.
A builder class for arrays .
Factory object for the ArrayBuffer
class.
A companion object for array builders .
A companion object for ArrayOps
.
This object provides a set of operations to create ArraySeq
values.
This object provides a set of operations to create BitSet
values.
This object provides a set of operations to create Buffer
values.
This object provides a set of operations to create DoubleLinkedList
values.
This object provides a set of operations needed to create mutable.HashMap
values.
This object provides a set of operations needed to create mutable.HashSet
values.
This object provides a set of operations to create mutable.IndexedSeq
values.
An object containing the necessary implicit definitions to make
SeqView
s work.
This object provides a set of operations to create mutable.Iterable
values.
This object provides a set of operations to create mutable.LinearSeq
values.
This object provides a set of operations needed to create LinkedHashMap
values.
This object provides a set of operations needed to create LinkedHashSet
values.
This object provides a set of operations to create LinkedList
values.
This object provides a set of operations to create ListBuffer
values.
This object provides a set of operations needed to create mutable.ListMap
values.
This object provides a set of operations needed to create mutable.Map
values.
no summary matey
This object provides a set of operations to create mutable.Seq
values.
This object provides a set of operations needed to create mutable.Set
values.
This object provides a set of operations to create mutable.Traversable
values.
This object provides a set of operations needed to create WeakHashMap
values.
A companion object used to create instances of WrappedArray
.