glok-model/uk.co.nickthecoder.glok.collections/MutableObservableList

MutableObservableList

interface MutableObservableList<E> : MutableList<E> , ObservableList<E>

A mutable list, which can be observed by ListChangeListeners and InvalidationListeners.

Note, the collection names in Glok use Kotlin's naming convention. So an ObservableList is not mutable, whereas MutableObservableList is.

Comparing Glok with JavaFX :

Glok : ObservableList <-> JavaFX : ReadOnlyObservableList
Glok : MutableObservableList <-> JavaFX : ObservableList

The easiest way to create a MutableObservableList is to wrap an existing (non-observable) list using asMutableObservableList :

val myObservableList = myMutableList.asObservableList()

Afterwards, you should never modify myMutableList directly, as those changes will not be heard by any ListChangeListeners, or InvalidationListeners.

See ObservableList for a class diagram.

Properties

size

abstract override val size: Int

Functions

add

abstract override fun add(element: E): Boolean

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

addAll

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

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

open fun addAll(vararg items: E): Boolean

addChangeListener

open fun addChangeListener(lambda: (list: ObservableList<E>, change: ListChange<E>) -> Unit): ListChangeListener<E>

abstract fun addChangeListener(listener: ListChangeListener<E>)

addListener

open fun addListener(lambda: (Observable) -> Unit): InvalidationListener

abstract fun addListener(listener: InvalidationListener)

addWeakChangeListener

open fun addWeakChangeListener(lambda: (list: ObservableList<E>, change: ListChange<E>) -> Unit): ListChangeListener<E>

addWeakListener

open fun addWeakListener(lambda: (Observable) -> Unit): InvalidationListener

asMutableObservableList

fun <E> MutableList<E>.asMutableObservableList(): MutableObservableList<E>

Wraps a regular list, creating a MutableObservableList.

asObservableList

fun <E> List<E>.asObservableList(): ObservableList<E>

Wraps a regular list, creating a MutableObservableList.

asReadOnly

open fun asReadOnly(): ObservableList<E>

clear

abstract override fun clear()

contains

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

containsAll

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

get

abstract operator fun get(index: Int): E

indexOf

abstract fun indexOf(element: E): Int

isEmpty

abstract override fun isEmpty(): Boolean

isEmptyProperty

fun ObservableList<*>.isEmptyProperty(): ObservableBoolean

isNotEmptyProperty

fun ObservableList<*>.isNotEmptyProperty(): ObservableBoolean

iterator

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

lastIndexOf

abstract fun lastIndexOf(element: E): Int

listIterator

abstract override fun listIterator(): MutableListIterator<E>

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

remove

abstract override fun remove(element: E): Boolean

removeAll

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

removeAt

abstract fun removeAt(index: Int): E

removeBetween

abstract fun removeBetween(indices: IntRange)

removeChangeListener

abstract fun removeChangeListener(listener: ListChangeListener<E>)

removeListener

abstract fun removeListener(listener: InvalidationListener)

retainAll

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

set

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

sizeProperty

fun ObservableList<*>.sizeProperty(): ObservableInt

subList

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

syncWith

fun <E> MutableObservableList<E>.syncWith(other: MutableObservableList<out E>): ListChangeListener<E>

Sync this mutable list with other. Returns a ListChangeListener for this list. To stop syncing, remove the listener using MutableObservableList.removeListener. As Glok uses weak references for listeners, you must keep a reference to this listener, otherwise the garbage collector will end the sync.