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 scala.collection.mutable.Buffer
.
The base trait of all builders.
A trait for cloneable collections.
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 scala.collection.mutable.Map
.
A trait for mutable maps with multiple values assigned to a key.
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 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]
.
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.
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 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.
The canonical builder for collections that are addable, i.
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.
Factory object for the ArrayStack
class.
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.
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.
Factory object for the mutable.Stack
class.
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
.