commons-collections/xyz.xenondevs.commons.collections.observed/ObservableMap

ObservableMap

class ObservableMap<K, V>(val map: MutableMap<K, V>, handleUpdate: () -> Unit) : MutableMap<K, V>

Constructors

ObservableMap

constructor(map: MutableMap<K, V>, handleUpdate: () -> Unit)

Properties

entries

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

keys

open override val keys: MutableSet<K>

map

val map: MutableMap<K, V>

size

open override val size: Int

values

open override val values: MutableCollection<V>

Functions

clear

open override fun clear()

compute

open override fun compute(key: K, remappingFunction: BiFunction<in K, in V?, out V?>): V?

computeIfAbsent

open override fun computeIfAbsent(key: K, mappingFunction: Function<in K, out V>): V

computeIfPresent

open override fun computeIfPresent(key: K, remappingFunction: BiFunction<in K, in V & Any, out V?>): V?

containsKey

open override fun containsKey(key: K): Boolean

containsValue

open override fun containsValue(value: V): Boolean

equals

open operator override fun equals(other: Any?): Boolean

filterIsInstanceKeys

inline fun <R, K, V> Map<K, V>.filterIsInstanceKeys(): Map<R, V>

filterIsInstanceKeysTo

inline fun <R, K, V, C : MutableMap<R, V>> Map<K, V>.filterIsInstanceKeysTo(destination: C): C

filterIsInstanceValues

inline fun <R, K, V> Map<K, V>.filterIsInstanceValues(): Map<K, R>

filterIsInstanceValuesTo

inline fun <R, K, V, C : MutableMap<K, R>> Map<K, V>.filterIsInstanceValuesTo(destination: C): C

filterValuesNotNull

fun <K, V : Any> Map<K, V?>.filterValuesNotNull(): Map<K, V>

filterValuesNotNullTo

fun <K, V : Any, C : MutableMap<K, V>> Map<K, V?>.filterValuesNotNullTo(destination: C): C

flatMap

inline fun <K, V, R> Map<K, V>.flatMap(transform: (Map.Entry<K, V>) -> Array<R>): List<R>

flatMapTo

inline fun <K, V, R, C : MutableCollection<in R>> Map<K, V>.flatMapTo(destination: C, transform: (Map.Entry<K, V>) -> Array<R>): C

get

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

hashCode

open override fun hashCode(): Int

isEmpty

open override fun isEmpty(): Boolean

isNotNullOrEmpty

fun Map<*, *>?.isNotNullOrEmpty(): Boolean

isNullOrEmpty

fun Map<*, *>?.isNullOrEmpty(): Boolean

mapKeysNotNull

inline fun <K, V, R> Map<K, V>.mapKeysNotNull(keySelector: (Map.Entry<K, V>) -> R?): Map<R, V>

mapKeysNotNullTo

inline fun <K, V, R, M : MutableMap<R, V>> Map<K, V>.mapKeysNotNullTo(destination: M, keySelector: (Map.Entry<K, V>) -> R?): M

mapValuesNotNull

inline fun <K, V, R> Map<K, V>.mapValuesNotNull(valueSelector: (Map.Entry<K, V>) -> R?): Map<K, R>

mapValuesNotNullTo

inline fun <K, V, R, M : MutableMap<K, R>> Map<K, V>.mapValuesNotNullTo(destination: M, valueSelector: (Map.Entry<K, V>) -> R?): M

merge

open override fun merge(key: K, value: V & Any, remappingFunction: BiFunction<in V & Any, in V & Any, out V?>): V?

poll

fun <K, V> MutableMap<K, V>.poll(): Map.Entry<K, V>?

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?

putOrRemove

fun <K, V> MutableMap<K, V>.putOrRemove(key: K, value: V?): V?

remove

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

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

removeIf

inline fun <K, V> MutableMap<K, V>.removeIf(predicate: (Map.Entry<K, V>) -> Boolean): MutableMap<K, V>

replace

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

open override fun replace(key: K, oldValue: V, newValue: V): Boolean

replaceAll

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

selectValues

fun <K, V> Map<K, V>.selectValues(keys: Iterable<K>): List<V>

selectValuesTo

fun <K, V, C : MutableCollection<in V>> Map<K, V>.selectValuesTo(destination: C, keys: Iterable<K>): C

toEnumMap

inline fun <K : Enum<K>, V> Map<K, V>.toEnumMap(): EnumMap<K, V>

toString

open override fun toString(): String