Buffer

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.

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)

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)

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)

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)

Alias for removeAll

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

Returns the collection itself

Alias for remove

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

Returns the collection itself

Append element

Adds given element to the end of this Idx

Append Stream

Adds all elements to Buffer end

Insert Stream

Inserts all elements at specified buffer position

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

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)

Returns element at specified position

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

 idx(1).tp // Prints: B

 idx(4).tp // Prints: E

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).

Check if contains

Returns true if given element is contained by the implementing container

Process all elements

Applies given function to each Buffer element.

This method is more eficient than Stream foreach.

Pack Buffer elements

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

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

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

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)

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)

Replace everything

Discards all old elements and adds all provided 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)

Sort elements

Sorts elements in this container

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)

Update many at position

Replaces elements starting at given position with stream values

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