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

SynchronizedMap

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

Constructors

SynchronizedMap

fun SynchronizedMap()

Functions

add

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

addAll

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

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 override 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

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?

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>>

merge

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

parallelStream

open fun parallelStream(): Stream<MutableMap.MutableEntry<TK, TV>>

put

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

putAll

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

putIfAbsent

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

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

spliterator

open override fun spliterator(): Spliterator<MutableMap.MutableEntry<TK, TV>>

stream

open fun stream(): Stream<MutableMap.MutableEntry<TK, TV>>

toArray

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

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>