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

ObservableMap

@API(status = API.Status.EXPERIMENTAL)

class ObservableMap<K, V> : ObservableHolder<Pair<K, V>> , MutableMap<K, V>

Functions

clear

open override fun clear()

compute

open fun compute(p0: K, p1: BiFunction<in K, in V?, out V?>): V?

computeIfAbsent

open fun computeIfAbsent(p0: K, p1: Function<in K, out V>): V

computeIfPresent

open fun computeIfPresent(p0: K, p1: BiFunction<in K, in V, out V?>): V?

containsKey

open override fun containsKey(key: K): Boolean

containsValue

open override fun containsValue(value: V): Boolean

forEach

open fun forEach(p0: BiConsumer<in K, in V>)

get

open operator override fun get(key: K): V?

getOrDefault

open fun getOrDefault(key: K, defaultValue: V): V

isEmpty

open override fun isEmpty(): Boolean

merge

open fun merge(p0: K, p1: V, p2: BiFunction<in V, in V, out V?>): V?

observe

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

put

open override fun put(key: K, value: V): V?

putAll

open override fun putAll(from: Map<out K, V>)

putIfAbsent

open override fun putIfAbsent(key: K, value: V): V?

remove

open override fun remove(key: K): V?

open override fun remove(key: K, value: V): Boolean

replace

open override fun replace(key: K, value: V): V?

open override fun replace(key: K, first: V, second: V): Boolean

replaceAll

open fun replaceAll(p0: BiFunction<in K, in V, out V>)

runListeners

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

Properties

entries

open override val entries: MutableSet<MutableMap.MutableEntry<K, V>>

keys

open override val keys: MutableSet<K>

listeners

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

size

open override val size: Int

values

open override val values: MutableCollection<V>

Extensions

asObservable

@API(status = API.Status.EXPERIMENTAL)

fun <K, V> MutableMap<K, V>.asObservable(): ObservableMap<K, V>

clear

inline fun <K, V> MutableMap<K, V>.clear(crossinline onRemove: suspend (K, V) -> Unit)

computeAndRemove

inline fun <K, V> MutableMap<K, V>.computeAndRemove(key: K, crossinline onRemove: suspend V.() -> Unit): Boolean

contains

inline fun Map<String, *>.contains(key: String, ignoreCase: Boolean = false): Boolean

get

inline fun <V> Map<String, V>.get(key: String, ignoreCase: Boolean = false): Option<V>

getCast

inline fun <T : Any, K> Map<K, *>.getCast(key: K): Option<T>