module-common/dev.racci.minix.api.utils.collections/ObservableList

ObservableList

@API(status = API.Status.EXPERIMENTAL)

class ObservableList<T> : ObservableCollection<T> , MutableList<T>

Functions

add

open override fun add(element: T): Boolean

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

addAll

fun addAll(vararg elements: T): Boolean

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

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

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>

observe

inline fun <F : Function<Unit>> observe(vararg action: ObservableAction?, listener: F)

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

replaceAll

open fun replaceAll(p0: UnaryOperator<T>)

retainAll

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

runListeners

inline fun <F : Function<Unit>> runListeners(vararg params: Any?)

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>

toArray

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

Properties

listeners

open override val listeners: MutableMultiMap<Function<Unit>, ObservableAction?>

size

open override val size: Int

Extensions

asObservable

@API(status = API.Status.EXPERIMENTAL)

fun <T> MutableList<T>.asObservable(): ObservableList<T>

clear

inline suspend fun <V> MutableCollection<V>.clear(crossinline onRemove: suspend V.() -> Unit)

contains

fun Collection<String>.contains(value: String, ignoreCase: Boolean = false): Boolean

findKCallable

fun <T : KCallable<*>> Collection<T>.findKCallable(name: String, ignoreCase: Boolean = false): Option<T>

findKFunction

@JvmName(name = "findKFunction")

inline fun <R> Collection<KFunction<*>>.findKFunction(name: String, ignoreCase: Boolean = false): Option<KFunction<R>>

@JvmName(name = "findKFunction0")

inline fun <R> Collection<() -> *>.findKFunction(name: String, ignoreCase: Boolean = false): Option<() -> R>

@JvmName(name = "findKFunction1")

inline fun <R> Collection<(*) -> *>.findKFunction(name: String, ignoreCase: Boolean = false): Option<(Any) -> R>

@JvmName(name = "findKFunction2")

inline fun <R> Collection<(*, *) -> *>.findKFunction(name: String, ignoreCase: Boolean = false): Option<(*, *) -> R>

findKProperty

@JvmName(name = "findKProperty0")

inline fun <R> Collection<KProperty0<*>>.findKProperty(name: String, ignoreCase: Boolean = false): Option<KProperty0<R>>

@JvmName(name = "findKProperty1")

inline fun <R> Collection<KProperty1<*, *>>.findKProperty(name: String, ignoreCase: Boolean = false): Option<KProperty1<Any, R>>

@JvmName(name = "findKProperty2")

inline fun <R> Collection<KProperty2<*, *, *>>.findKProperty(name: String, ignoreCase: Boolean = false): Option<KProperty2<*, *, R>>

@JvmName(name = "findKPropertyMutable0")

inline fun <R> Collection<KMutableProperty0<*>>.findKProperty(name: String, ignoreCase: Boolean = false): Option<KMutableProperty0<R>>

@JvmName(name = "findKPropertyMutable1")

inline fun <R> Collection<KMutableProperty1<*, *>>.findKProperty(name: String, ignoreCase: Boolean = false): Option<KMutableProperty1<*, R>>

@JvmName(name = "findKPropertyMutable2")

inline fun <R> Collection<KMutableProperty2<*, *, *>>.findKProperty(name: String, ignoreCase: Boolean = false): Option<KMutableProperty2<*, *, R>>

getCast

fun <T : Any> Collection<*>.getCast(index: Int): Validated<Throwable, T>

ifNotEmpty

inline fun <T> Collection<T>?.ifNotEmpty(block: Collection<T>.() -> Unit): Collection<T>?

Invokes the given block if the receiver is not empty.

msg

@JvmName(name = "msgAudienceCollection")

infix fun Collection<ComponentLike>.msg(audience: Audience)

parse

fun Collection<String>.parse(): List<Component>