Idx.ObservableMutable.X.Basic

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 all

Adds all stream values to the end of this Idx

Add stream at position

Adds stream elements at given position

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

  x.addAllAt(4, 'e' <> 'g')
  x.addAllAt(1, Stream('b','c','d'))

  x.stream.tp // Prints Stream(A, b, c, d, B, C, D, e, f, g, E, F)

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)

Remove everything

Discards all elements, so the colection size will become 0

On element add

Subscribes given function to element add event

val co: Collection.ObservableMutable[Int] = Collection.OM[Int]()

co.onAdd("Added: "+ _ tp())

co ++= 1 <> 3

// Output
Added: 1
Added: 2
Added: 3

On element remove

Subscribes given function to element remove event

val co: Collection.ObservableMutable[Int] = Collection.OM[Int]()

co.onRemove("Removed: "+ _ tp())

co ++= 1 <> 10

co --= 5 <> 7

// Output
Removed: 7
Removed: 6
Removed: 5

Creates a refresh event

Refresh event is an Update event for specified elements, where old and new values are the same.

Supposedly, the elements themself are mutable and their representation has to be "refreshed"

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)

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