Buffer

abstract class Buffer[A] extends Idx.M[A] with Able.Contain[A]

Value Buffer

Buffer is the default implementation of Mutable Indexed Collection

Buffer is an abstract class with concrete implementations: AnyRef.G.Buffer, Byte.G.Buffer, Int.G.Buffer, etc.

Source
__.scala
trait Idx.Mutable[Buffer.A]
trait Able.Contain[Buffer.A]
trait Collection.Mutable[Buffer.A]
trait Able.Add[Buffer.A]
trait Idx[Buffer.A]
trait Collection[Buffer.A]
trait Able.Size
trait Able.Stream[Buffer.A]
class java.lang.Object
trait scala.Matchable
class Any
class AnyRef.G.Buffer[AnyRef.G.Buffer.A]
class Doc
class Boolean.G.Buffer[Boolean.G.Buffer.A]
class Byte.G.Buffer[Byte.G.Buffer.A]
class Char.G.Buffer[Char.G.Buffer.A]
class Double.G.Buffer[Double.G.Buffer.A]
class Float.G.Buffer[Float.G.Buffer.A]
class Int.G.Buffer[Int.G.Buffer.A]
class Long.G.Buffer[Long.G.Buffer.A]
class Short.G.Buffer[Short.G.Buffer.A]

Def

inline def ++=(v: Opt[A]): Buffer[A]

Alias for addAll

Alias for addAll

Generally Opt could be added as a stream.

This overload is sligtly more efficient, but it is also required for mapped Opt expressions, where Opt type is harder to resolve and it would not compile.

Inherited from
Add
Source
Add.scala
inline def ++=(v: Stream[A]): Buffer[A]

Alias for addAll

Alias for addAll

Calls addAll and returns container

 // Generic example
 val x =  Idx.M(1, 2, 3)

 x ++= (4 <> 6) ++= Stream(7, 8, 9)

 x.stream.tp // Stream(1, 2, 3, 4, 5, 6, 7, 8, 9)
Inherited from
Add
Source
Add.scala
inline def ++@=(position: Int, v: Stream[A]): Buffer[A]

Alias for addAllAt

Alias for addAllAt

Adds stream elements at given position

  // Generic example
  val x = ('A' <> 'F').stream.toBuffer

  x ++@= (4, 'e' <> 'g') ++@= (1, Stream('b','c','d'))

  x.stream.tp // Prints Stream(A, b, c, d, B, C, D, e, f, g, E, F)
Inherited from
Mutable
Source
__.scala
inline def +=(v: A): Buffer[A]

Alias for add

Alias for add

Calls add and returns container

 // Generic example
 val x =  Idx.M(1, 2, 3)

  x += 4 += 5 += 6

  x.stream.tp // Prints Stream(1, 2, 3, 4, 5, 6)
Inherited from
Add
Source
Add.scala
inline def +@=(position: Int, v: A): Buffer[A]

Alias for addAt

Alias for addAt

Adds element at given position

  // Generic example
  val x = ('A' <> 'F').stream.toBuffer

  x +@= (3, 'd') +@= (2, 'c') +@= (1, 'b') +@= (0, 'a')

  x.stream.tp // Prints Stream(a, A, b, B, c, C, d, D, E, F)
Inherited from
Mutable
Source
__.scala
def --=(v: Stream[A]): Buffer[A]

Alias for removeAll

Alias for removeAll

Removes all collection elements, which are equal to those in given stream

Returns the collection itself

Inherited from
Mutable
Source
Mutable.scala
def -=(v: A): Buffer[A]

Alias for remove

Alias for remove

Removes all collection elements, which are equal to the given value

Returns the collection itself

Inherited from
Mutable
Source
Mutable.scala
def add(v: A): Unit

Append element

Append element

Adds given element to the end of this Idx

Inherited from
Mutable
Source
__.scala
override def addAll(v: Stream[A]): Unit

Append Stream

Append Stream

Adds all elements to Buffer end

Definition Classes
Source
__.scala
override def addAllAt(i: Int, v: Stream[A]): Unit

Insert Stream

Insert Stream

Inserts all elements at specified buffer position

Definition Classes
Source
__.scala
final def addArray_trusted(a: Array[A], start: Int, len: Int): Unit

Add array elements

Add array elements

Programms are expected to pass even private sensitive arrays, because this method is final and can be exemined not to abuse the trust

The given arguments specify range of elements to be added.

Whenever possible the adding will be done with bulk copy from given array to buffer array

Source
__.scala
def addAt(position: Int, v: A): Unit

Add at position

Add at position

Adds element at given position

  // Generic example
  val x = ('A' <> 'F').stream.toBuffer

  x.addAt(3, 'd')
  x.addAt(2, 'c')
  x.addAt(1, 'b')
  x.addAt(0, 'a')

  x.stream.tp // Prints Stream(a, A, b, B, c, C, d, D, E, F)
Inherited from
Mutable
Source
__.scala
def apply(i: Int): A

Returns element at specified position

Returns element at specified position

 val idx: Idx[Char] = ('A' <> 'Z').stream.pack

 idx(1).tp // Prints: B

 idx(4).tp // Prints: E
Inherited from
Idx
Source
__.scala
override def clear: Unit

Empty buffer

Empty buffer

Note. Even buffer becomes zero sized, the storage array will not shrink and will still reference the old elements (untill overwritten with new).

Definition Classes
Source
__.scala
def contains(v: A): Boolean

Check if contains

Check if contains

Returns true if given element is contained by the implementing container

Inherited from
Contain
Source
Contain.scala
inline def foreach[U](f: A => U): Unit

Process all elements

Process all elements

Applies given function to each Buffer element.

This method is more eficient than Stream foreach.

Source
__.scala
def pack: Pack[A]

Pack Buffer elements

Pack Buffer elements

Both Buffer and Pack are mostly Array based, so the direct convertions between them are very efficient

Source
__.scala
def remove(v: A): Int

Remove element

Remove element

Removes all Idx elements, which are equal to the given value

Returns count of removed elements, which can be 0, 1, or many

Inherited from
Mutable
Source
__.scala
def removeAll(v: Stream[A]): Int

Remove all streamed

Remove all streamed

Removes all collection elements, which are equal to those in given stream

Returns count of removed elements, which can be 0, 1, or many

Inherited from
Mutable
Source
Mutable.scala
def removeAt(position: Int): Unit

Remove at position

Remove at position

Removes element at given position

 // Generic example
 val x = ('A' <> 'D').stream.toBuffer

 x.remove(2)
 x.remove(1)

 x.stream.tp // Prints Stream(A, D)
Inherited from
Mutable
Source
__.scala
def removeRange(v: Int.Range): Unit

Remove range

Remove range

Removes elements at given range

 val x = (0 <> 10).stream.toBuffer

 x.remove(7 <> 8)
 x.remove(2 <> 4)

 x.stream.tp // Prints Stream(0, 1, 5, 6, 9, 10)
Source
__.scala
def replaceWith(v: Stream[A]): Unit

Replace everything

Replace everything

Discards all old elements and adds all provided elements

Inherited from
Mutable
Source
Mutable.scala

Reorganizes elements

Reorganizes elements

Reorganizes elements according to the given permutation

  val im: Idx.Mutable[Int] = (0 <> 9).stream.toBuffer

  val p = Idx.Permutation.pairs(3 -> 7, 7 -> 3, 4 -> 6, 6 -> 4)

  im.stream.tp
  im.reposition(p)
  im.stream.tp

  // Output
  Stream(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
  Stream(0, 1, 2, 7, 6, 5, 4, 3, 8, 9)
Inherited from
Mutable
Source
__.scala
def size: Int
Inherited from
Idx
Source
__.scala
def sort(using c: Ordering[A]): Unit

Sort elements

Sort elements

Sorts elements in this container

Inherited from
Mutable
Source
__.scala
def stream: Stream[A]

Returns a Stream of all elements

Returns a Stream of all elements

The element order is same as in the Idx itself

  val l: Idx[Char] = ('a' <> 'g').stream.pack

  l.stream.tp  // Prints Stream(a, b, c, d, e, f, g)
Inherited from
Idx
Source
__.scala
def updateAllAt(position: Int, s: Stream[A]): Unit

Update many at position

Update many at position

Replaces elements starting at given position with stream values

Inherited from
Mutable
Source
__.scala
def updateAt(position: Int, s: A): Unit

Update at position

Update at position

Replaces element at given position with given value

  val im: Idx.Mutable[Int] = (0 <> 7).stream.toBuffer

  im.updateAt(7, 777)
  im.updateAt(3, 333)

  im.stream.tp // Prints Stream(0, 1, 2, 333, 4, 5, 6, 777)

  // The same can be done with Scala symplified syntax

  im(7) = 777
  im(3) = 333

Inherited from
Mutable
Source
__.scala