ktor-utils/io.ktor.util.collections/ConcurrentMap

ConcurrentMap

expect class ConcurrentMap<Key, Value>(initialCapacity: Int = INITIAL_CAPACITY) : MutableMap<Key, Value>

Ktor concurrent map implementation. Please do not use it.

actual class ConcurrentMap<Key, Value>(initialCapacity: Int) : MutableMap<Key, Value>

Ktor concurrent map implementation. Please do not use it.

actual class ConcurrentMap<Key, Value>(initialCapacity: Int) : MutableMap<Key, Value>

Ktor concurrent map implementation. Please do not use it.

actual class ConcurrentMap<Key, Value>(initialCapacity: Int) : MutableMap<Key, Value>

Ktor concurrent map implementation. Please do not use it.

Constructors

ConcurrentMap

expect constructor(initialCapacity: Int = INITIAL_CAPACITY)

actual constructor(initialCapacity: Int)

Properties

entries

abstract override val entries: MutableSet<MutableMap.MutableEntry<Key, Value>>

open override val entries: MutableSet<MutableMap.MutableEntry<Key, Value>>

keys

abstract override val keys: MutableSet<Key>

open override val keys: MutableSet<Key>

size

abstract val size: Int

open override val size: Int

values

abstract override val values: MutableCollection<Value>

open override val values: MutableCollection<Value>

Functions

clear

abstract fun clear()

open override fun clear()

compute

open fun compute(p0: Key, p1: BiFunction<in Key, in Value?, out Value?>): Value?

computeIfAbsent

expect fun computeIfAbsent(key: Key, block: () -> Value): Value

Computes block and inserts result in map. The block will be evaluated at most once.

actual fun computeIfAbsent(key: Key, block: () -> Value): Value

Computes block and inserts result in map. The block will be evaluated at most once.

actual fun computeIfAbsent(key: Key, block: () -> Value): Value

Computes block and inserts result in map. The block will be evaluated at most once.

open fun computeIfAbsent(p0: Key, p1: Function<in Key, out Value>): Value

actual fun computeIfAbsent(key: Key, block: () -> Value): Value

Computes block and inserts result in map. The block will be evaluated at most once.

computeIfPresent

open fun computeIfPresent(p0: Key, p1: BiFunction<in Key, in Value & Any, out Value?>): Value?

containsKey

abstract fun containsKey(key: Key): Boolean

open override fun containsKey(key: Key): Boolean

containsValue

abstract fun containsValue(value: Value): Boolean

open override fun containsValue(value: Value): Boolean

equals

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

forEach

open fun forEach(p0: BiConsumer<in Key, in Value>)

get

abstract operator fun get(key: Key): Value?

open operator override fun get(key: Key): Value?

getOrDefault

open fun getOrDefault(key: Key, defaultValue: Value): Value

hashCode

open override fun hashCode(): Int

isEmpty

abstract fun isEmpty(): Boolean

open override fun isEmpty(): Boolean

merge

open fun merge(p0: Key, p1: Value & Any, p2: BiFunction<in Value & Any, in Value & Any, out Value?>): Value?

put

abstract fun put(key: Key, value: Value): Value?

open override fun put(key: Key, value: Value): Value?

putAll

abstract fun putAll(from: Map<out Key, Value>)

open override fun putAll(from: Map<out Key, Value>)

putIfAbsent

open fun putIfAbsent(p0: Key, p1: Value): Value?

remove

expect fun remove(key: Key, value: Value): Boolean

Removes key from map if it is mapped to value.

abstract fun remove(key: Key): Value?

open override fun remove(key: Key): Value?

actual fun remove(key: Key, value: Value): Boolean

open override fun remove(key: Key): Value?

actual open override fun remove(key: Key, value: Value): Boolean

open override fun remove(key: Key): Value?

actual fun remove(key: Key, value: Value): Boolean

replace

open fun replace(p0: Key, p1: Value): Value?

open fun replace(p0: Key, p1: Value, p2: Value): Boolean

replaceAll

open fun replaceAll(p0: BiFunction<in Key, in Value, out Value>)

toString

open override fun toString(): String