rd-core/com.jetbrains.rd.util.reactive/ViewableList

ViewableList

class ViewableList<T : Any>(storage: MutableList<T> = mutableListOf()) : IMutableViewableList<T>

Constructors

ViewableList

fun <T : Any> ViewableList(storage: MutableList<T> = mutableListOf())

Functions

add

open override fun add(element: T): Boolean

open override fun add(index: Int, element: T)

addAll

open override fun addAll(elements: Collection<T>): Boolean

open override fun addAll(index: Int, elements: Collection<T>): Boolean

advise

open override fun advise(lifetime: Lifetime, handler: (IViewableList.Event<T>) -> Unit)

Adds an event subscription. Every time an event occurs, the handler is called, receiving an instance of the event. The subscription is removed when the given lifetime expires.

adviseAddRemove

open fun adviseAddRemove(lifetime: Lifetime, handler: (AddRemove, Int, T) -> Unit)

Adds a subscription to additions and removals of list elements. When a list element is updated, the handler is called twice: to report the removal of the old element and the addition of the new one.

clear

open override fun clear()

contains

open operator override fun contains(element: T): Boolean

containsAll

open override fun containsAll(elements: Collection<T>): Boolean

forEach

open fun forEach(p0: Consumer<in T>)

get

open operator override fun get(index: Int): T

indexOf

open override fun indexOf(element: T): Int

isEmpty

open override fun isEmpty(): Boolean

iterator

open operator override fun iterator(): MutableIterator<T>

lastIndexOf

open override fun lastIndexOf(element: T): Int

listIterator

open override fun listIterator(): MutableListIterator<T>

open override fun listIterator(index: Int): MutableListIterator<T>

parallelStream

open fun parallelStream(): Stream<T>

remove

open override fun remove(element: T): Boolean

removeAll

open override fun removeAll(elements: Collection<T>): Boolean

removeAt

open override fun removeAt(index: Int): T

removeIf

open fun removeIf(p0: Predicate<in T>): Boolean

removeRange

fun removeRange(fromIndex: Int, toIndex: Int)

replaceAll

open fun replaceAll(p0: UnaryOperator<T>)

retainAll

open override fun retainAll(elements: Collection<T>): Boolean

set

open operator override fun set(index: Int, element: T): T

sort

open fun sort(p0: Comparator<in T>)

spliterator

open override fun spliterator(): Spliterator<T>

stream

open fun stream(): Stream<T>

subList

open override fun subList(fromIndex: Int, toIndex: Int): MutableList<T>

sync

fun sync(newValues: Collection<T>): Boolean

Synchronizes the viewable list by adding missing elements and removing unmatched elements. If the order of equal values is not changed, then they won't be modified. However, even if equal elements exist in both lists, but order is swapped, then they will be removed and re-added to satisfy the new values order. It helps drastically reduce the number of change events if the collection is unmodified at all or just a few elements are changed compared to the classical approach with 'clear' and 'addAll'.

toArray

~~open~~ ~~fun~~ <T : Any> ~~toArray~~(p0: IntFunction<Array<T>>): Array<T>

view

open override fun view(lifetime: Lifetime, handler: (Lifetime, Pair<Int, T>) -> Unit)

Adds a subscription to changes of the contents of the list.

open fun view(lifetime: Lifetime, handler: (Lifetime, Int, T) -> Unit)

Adds a subscription to changes of the contents of the list, receiving the index and value as separate parameters.

Properties

change

open override val change: Signal<IViewableList.Event<T>>

changing

open val changing: Boolean

size

open override val size: Int