This class implements mutable maps with AnyRef
keys based on a hash table with open addressing.
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 the
deep
method for arrays and wrapped arrays and serves as a marker trait
for array wrappers.
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]
.
The base trait of all builders.
A trait for cloneable collections.
Class used internally for default map model.
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
.
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.
A Buffer
implementation back up by a list.
A simple mutable map backed by a list.
This class implements mutable maps with Long
keys based on a hash table with open addressing.
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.
A trait for mutable maps with multiple values assigned to a key.
This class is used internally to represent mutable lists.
A mutable hash map based on an open hashing scheme.
This class implements priority queues using a heap.
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.
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 template trait for mutable sequences of type mutable.Seq[A]
.
A generic trait for mutable sets.
The canonical builder for mutable Sets.
A template trait for mutable sets of type mutable.Set[A]
.
Base trait for mutable sorted set.
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
.
A trait for traversable collections that can be mutated.
A mutable SortedSet using an immutable RedBlack Tree as underlying data structure.
Classes that mix in the Undoable
class provide an operation
undo
which can be used to undo the last operation.
A buffer that stores elements in an unrolled linked list.
A hash map with references to entries which are weakly reachable.
A class representing Array[T]
.
A builder class for arrays.
This is a simple proxy class for `scala.collection.mutable.Buffer`.
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.
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 more traditional/primitive style of linked list where the "list" is also the "head" link.
This extensible class may be used as a basis for implementing linked list.
This trait implements a proxy for scala.collection.mutable.Map.
This class is typically used as a mixin.
This class is typically used as a mixin.
This class is typically used as a mixin.
This class servers as a proxy for priority queues.
Queue
objects implement data structures that allow to
insert and retrieve elements in a first-in-first-out (FIFO) manner.
This is a simple wrapper class for scala.collection.mutable.Set.
A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.
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.
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
values.ArraySeq
Factory object for the ArrayStack
class.
This object provides a set of operations to create
values.BitSet
This object provides a set of operations to create
values.Buffer
This object provides a set of operations needed to create
values.mutable.HashMap
This object provides a set of operations needed to create
values.mutable.HashSet
This object provides a set of operations to create
values.mutable.IndexedSeq
An object containing the necessary implicit definitions to make
SeqView
s work.
This object provides a set of operations to create
values.mutable.Iterable
This object provides a set of operations to create
values.mutable.LinearSeq
This object provides a set of operations needed to create
values.LinkedHashMap
This object provides a set of operations needed to create
values.LinkedHashSet
This object provides a set of operations to create
values.ListBuffer
This object provides a set of operations needed to create
values.mutable.ListMap
This object provides a set of operations needed to create
values.mutable.Map
This object provides a set of operations to create
values.mutable.Seq
This object provides a set of operations needed to create
values.mutable.Set
A template for mutable sorted set companion objects.
Factory object for the mutable.Stack
class.
This object provides a set of operations to create
values.mutable.Traversable
This object provides a set of operations needed to create
values.WeakHashMap
A companion object used to create instances of WrappedArray
.
This object provides a set of operations to create
values.DoubleLinkedList
This object provides a set of operations to create
values.LinkedList