core/io.nacular.doodle.utils/ObservableList

ObservableList

interface ObservableList<E> : MutableList<E>

A List that notifies observers of changes to its contents.

Inheritors

ObservableListImpl

Types

object Companion

Properties

abstract val changed: ListObservers<ObservableList<E>, E>

Notifies of changes to the list

abstract override val size: Int

Functions

abstract override fun add(element: E): Boolean

abstract fun add(index: Int, element: E)

abstract override fun addAll(elements: Collection<E>): Boolean

abstract fun addAll(index: Int, elements: Collection<E>): Boolean

fun <T> MutableList<T>.addOrAppend(at: Int, value: T)

Ads value to the list at the specify index, or at the end of the list if that index exceeds the current list length.

fun Collection<Completable>.allCompleted(completed: () -> Unit)

abstract fun <T> batch(block: MutableList<E>.() -> T): T

Runs the operations within block and then applies them all to the list as a single operation. This reduces the set of events that would normally trigger if these operations were done sequentially.

abstract override fun clear()

abstract operator override fun contains(element: E): Boolean

operator fun <E> Collection<E>?.contains(element: E): Boolean

Nullable helper

abstract override fun containsAll(elements: Collection<E>): Boolean

abstract operator fun get(index: Int): E

abstract fun indexOf(element: E): Int

abstract override fun isEmpty(): Boolean

abstract operator override fun iterator(): Iterator<E>

abstract fun lastIndexOf(element: E): Int

abstract override fun listIterator(): MutableListIterator<E>

abstract override fun listIterator(index: Int): MutableListIterator<E>

abstract operator fun minusAssign(element: E)

Removes element from the list

abstract fun move(element: E, to: Int): Boolean

Moves element to a new index.

abstract fun notifyChanged(index: Int)

Explicitly trigger a diff that shows the element at index being deleted and re-added. This is useful for cases where the elements in the list are mutable and a change has happened to one that would normally not result in a call to changed (which only notifies of membership changes.

abstract operator fun plusAssign(element: E)

Adds element to the list

abstract override fun remove(element: E): Boolean

abstract override fun removeAll(elements: Collection<E>): Boolean

abstract fun removeAt(index: Int): E

abstract fun replaceAll(elements: Collection<E>): Boolean

Replaces the list's contents with elements.

abstract override fun retainAll(elements: Collection<E>): Boolean

abstract operator fun set(index: Int, element: E): E

fun <T> ObservableList<T>.sortWith(comparator: Comparator<in T>)

sortWithDescending

fun <T> ObservableList<T>.sortWithDescending(comparator: Comparator<in T>)

abstract override fun subList(fromIndex: Int, toIndex: Int): MutableList<E>