rd-core/com.jetbrains.rd.util.collections/SynchronizedMap

SynchronizedMap

class SynchronizedMap<TK, TV> : MutableMap<TK, TV> , MutableSet<MutableMap.MutableEntry<TK, TV>>

Constructors

SynchronizedMap

constructor()

Properties

entries

open override val entries: MutableSet<MutableMap.MutableEntry<TK, TV>>

keys

open override val keys: MutableSet<TK>

size

open override val size: Int

values

open override val values: MutableCollection<TV>

Functions

add

open override fun add(element: MutableMap.MutableEntry<TK, TV>): Boolean

addAll

open override fun addAll(elements: Collection<MutableMap.MutableEntry<TK, TV>>): Boolean

addUnique

fun <T> MutableCollection<T>.addUnique(lifetime: Lifetime, value: T)

fun <K, V> MutableMap<K, V>.addUnique(lifetime: Lifetime, key: K, value: V): V

blockingPutUnique

fun <K, V> MutableMap<K, V>.blockingPutUnique(lf: Lifetime, lock: Any, key: K, value: V)

clear

open override fun clear()

compute

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

computeIfAbsent

open override fun computeIfAbsent(key: TK, mappingFunction: Function<in TK, out TV>): TV

computeIfPresent

open fun computeIfPresent(key: TK, remappingFunction: BiFunction<in TK, in TV, out TV?>): TV?

contains

open operator override fun contains(element: MutableMap.MutableEntry<TK, TV>): Boolean

containsAll

open override fun containsAll(elements: Collection<MutableMap.MutableEntry<TK, TV>>): Boolean

containsKey

open override fun containsKey(key: TK): Boolean

containsValue

open override fun containsValue(value: TV): Boolean

first

fun <TKey, TValue> Map<TKey, TValue>.first(): Map.Entry<TKey, TValue>

firstOrNull

fun <TKey, TValue> Map<TKey, TValue>.firstOrNull(): Map.Entry<TKey, TValue>?

fold

fun <TSource, TResult : Any> Iterable<IPropertyView<TSource>>.fold(lifetime: Lifetime, initial: TResult, func: (TResult, TSource) -> TResult): OptProperty<TResult>

foldOpt

fun <TSource : Any, TResult : Any> Iterable<IOptPropertyView<TSource>>.foldOpt(lifetime: Lifetime, initial: TResult, func: (TResult, TSource) -> TResult): OptProperty<TResult>

forEach

open override fun forEach(action: BiConsumer<in TK, in TV>)

open override fun forEach(action: Consumer<in MutableMap.MutableEntry<TK, TV>>?)

get

open operator override fun get(key: TK): TV?

getOrCreate

inline fun <K : Any, V : Any> MutableMap<K, V>.getOrCreate(key: K, crossinline creator: (K) -> V): V

getOrDefault

open override fun getOrDefault(key: TK, defaultValue: TV): TV

isEmpty

open override fun isEmpty(): Boolean

iterator

open operator override fun iterator(): MutableIterator<MutableMap.MutableEntry<TK, TV>>

keySet

fun <K, V> MutableMap<K, V>.keySet(value: V): MutableSet<K>

merge

open fun merge(key: TK, value: TV, remappingFunction: BiFunction<in TV, in TV, out TV?>): TV?

put

open override fun put(key: TK, value: TV): TV?

put

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

fun <K, V> MutableMap<K, V>.put(lf: Lifetime, key: K, value: V)

putAll

open override fun putAll(from: Map<out TK, TV>)

putIfAbsent

open override fun putIfAbsent(key: TK, value: TV): TV?

putUnique

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

remove

open override fun remove(key: TK): TV?

open override fun remove(element: MutableMap.MutableEntry<TK, TV>): Boolean

open override fun remove(key: TK, value: TV): Boolean

removeAll

open override fun removeAll(elements: Collection<MutableMap.MutableEntry<TK, TV>>): Boolean

removeIf

open override fun removeIf(filter: Predicate<in MutableMap.MutableEntry<TK, TV>>): Boolean

replace

open override fun replace(key: TK, value: TV): TV?

open override fun replace(key: TK, oldValue: TV, newValue: TV): Boolean

replaceAll

open override fun replaceAll(function: BiFunction<in TK, in TV, out TV>)

retainAll

open override fun retainAll(elements: Collection<MutableMap.MutableEntry<TK, TV>>): Boolean