Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
@file:kotlin.jvm.JvmMultifileClass
@file:kotlin.jvm.JvmName("MapsKt")
package kotlin.collections
import java.io.Serializable
import java.util.*
private object EmptyMap : Map, Serializable {
override fun equals(other: Any?): Boolean = other is Map<*,*> && other.isEmpty()
override fun hashCode(): Int = 0
override fun toString(): String = "{}"
override val size: Int get() = 0
override fun isEmpty(): Boolean = true
override fun containsKey(key: Any?): Boolean = false
override fun containsValue(value: Nothing): Boolean = false
override fun get(key: Any?): Nothing? = null
override val entries: Set> get() = EmptySet
override val keys: Set get() = EmptySet
override val values: Collection get() = EmptyList
private fun readResolve(): Any = EmptyMap
}
/** Returns an empty read-only map of specified type. The returned map is serializable (JVM). */
public fun emptyMap(): Map = EmptyMap as Map
/**
* Returns a new read-only map with the specified contents, given as a list of pairs
* where the first value is the key and the second is the value. If multiple pairs have
* the same key, the resulting map will contain the value from the last of those pairs.
*
* The returned map is serializable (JVM).
*/
public fun mapOf(vararg pairs: Pair): Map = if (pairs.size > 0) linkedMapOf(*pairs) else emptyMap()
/** Returns an empty read-only map. The returned map is serializable (JVM). */
public fun mapOf(): Map = emptyMap()
/* Not available on platform: JS */
/**
* Returns a new [HashMap] with the specified contents, given as a list of pairs
* where the first component is the key and the second is the value.
*
* @sample test.collections.MapTest.createUsingPairs
*/
public fun hashMapOf(vararg pairs: Pair): HashMap
= HashMap(mapCapacity(pairs.size)).apply { putAll(pairs) }
/**
* Returns a new [LinkedHashMap] with the specified contents, given as a list of pairs
* where the first component is the key and the second is the value.
* This map preserves insertion order so iterating through the map's entries will be in the same order.
*
* @sample test.collections.MapTest.createLinkedMap
*/
public fun linkedMapOf(vararg pairs: Pair): LinkedHashMap
= LinkedHashMap(mapCapacity(pairs.size)).apply { putAll(pairs) }
/**
* Calculate the initial capacity of a map, based on Guava's com.google.common.collect.Maps approach. This is equivalent
* to the Collection constructor for HashSet, (c.size()/.75f) + 1, but provides further optimisations for very small or
* very large sizes, allows support non-collection classes, and provides consistency for all map based class construction.
*/
private val INT_MAX_POWER_OF_TWO: Int = Int.MAX_VALUE / 2 + 1
internal fun mapCapacity(expectedSize: Int): Int {
if (expectedSize < 3) {
return expectedSize + 1
}
if (expectedSize < INT_MAX_POWER_OF_TWO) {
return expectedSize + expectedSize / 3
}
return Int.MAX_VALUE // any large value
}
/** Returns `true` if this map is not empty. */
public fun Map.isNotEmpty(): Boolean = !isEmpty()
/**
* Returns the [Map] if its not `null`, or the empty [Map] otherwise.
*/
public fun Map?.orEmpty() : Map = this ?: emptyMap()
/**
* Checks if the map contains the given key. This method allows to use the `x in map` syntax for checking
* whether an object is contained in the map.
*/
public operator fun <@kotlin.internal.OnlyInputTypes K, V> Map.contains(key: K) : Boolean = containsKey(key)
/**
* Returns the value corresponding to the given [key], or `null` if such a key is not present in the map.
*/
public operator fun <@kotlin.internal.OnlyInputTypes K, V> Map.get(key: K): V? = (this as Map).get(key)
/**
* Returns the value corresponding to the given [key], or `null` if such a key is not present in the map.
*
* Allows to overcome type-safety restriction of `get` that requires to pass a key of type `K`.
*/
@Suppress("NOTHING_TO_INLINE")
@Deprecated("Map and key have incompatible types. Upcast key to Any? if you're sure.", ReplaceWith("get(key as Any?)"))
public inline fun Map.getRaw(key: Any?): V? = get(key)
/**
* Returns `true` if the map contains the specified [key].
*
* Allows to overcome type-safety restriction of `containsKey` that requires to pass a key of type `K`.
*/
public fun <@kotlin.internal.OnlyInputTypes K> Map.containsKey(key: K): Boolean = (this as Map).containsKey(key)
@Suppress("NOTHING_TO_INLINE")
@Deprecated("Map and key have incompatible types. Upcast key to Any? if you're sure.", ReplaceWith("containsKey(key as Any?)"))
public inline fun Map.containsKeyRaw(key: Any?): Boolean = containsKey(key)
/**
* Returns `true` if the map maps one or more keys to the specified [value].
*
* Allows to overcome type-safety restriction of `containsValue` that requires to pass a value of type `V`.
*/
public fun Map.containsValue(value: V): Boolean = this.containsValue(value)
@Suppress("NOTHING_TO_INLINE")
@Deprecated("Map and value have incompatible types. Upcast value to Any? if you're sure.", ReplaceWith("containsValue(value as Any?)"))
public inline fun Map.containsValueRaw(value: Any?): Boolean = containsValue(value)
/**
* Removes the specified key and its corresponding value from this map.
*
* @return the previous value associated with the key, or `null` if the key was not present in the map.
* Allows to overcome type-safety restriction of `remove` that requires to pass a key of type `K`.
*/
public fun <@kotlin.internal.OnlyInputTypes K, V> MutableMap.remove(key: K): V? = (this as MutableMap).remove(key)
/**
* Returns the key component of the map entry.
*
* This method allows to use destructuring declarations when working with maps, for example:
* ```
* for ((key, value) in map) {
* // do something with the key and the value
* }
* ```
*/
@Suppress("NOTHING_TO_INLINE")
public inline operator fun Map.Entry.component1(): K = key
/**
* Returns the value component of the map entry.
* This method allows to use destructuring declarations when working with maps, for example:
* ```
* for ((key, value) in map) {
* // do something with the key and the value
* }
* ```
*/
@Suppress("NOTHING_TO_INLINE")
public inline operator fun Map.Entry.component2(): V = value
/**
* Converts entry to [Pair] with key being first component and value being second.
*/
public fun Map.Entry.toPair(): Pair = Pair(key, value)
/**
* Returns the value for the given key, or the result of the [defaultValue] function if there was no entry for the given key.
*
* @sample test.collections.MapTest.getOrElse
*/
@Deprecated("This function will change its behavior soon not to distinguish missing keys and keys mapped to nulls. To stick with the new behavior you can use get(key) with ?: operator after instead.")
public inline fun Map.getOrElse(key: K, defaultValue: () -> V): V {
val value = get(key)
if (value == null && !containsKey(key)) {
return defaultValue()
} else {
return value as V
}
}
/* Not available on platform: JS */
/* Not available on platform: JS */
/**
* Returns an [Iterator] over the entries in the [Map].
*
* @sample test.collections.MapTest.iterateWithProperties
*/
public operator fun Map.iterator(): Iterator> = entries.iterator()
/* Not available on platform: JS */
/**
* Populates the given `destination` [Map] with entries having the keys of this map and the values obtained
* by applying the `transform` function to each entry in this [Map].
*/
public inline fun > Map.mapValuesTo(destination: C, transform: (Map.Entry) -> R): C {
for (e in this) {
val newValue = transform(e)
destination.put(e.key, newValue)
}
return destination
}
/**
* Populates the given `destination` [Map] with entries having the keys obtained
* by applying the `transform` function to each entry in this [Map] and the values of this map.
*/
public inline fun > Map.mapKeysTo(destination: C, transform: (Map.Entry) -> R): C {
for (e in this) {
val newKey = transform(e)
destination.put(newKey, e.value)
}
return destination
}
/**
* Puts all the given [pairs] into this [MutableMap] with the first component in the pair being the key and the second the value.
*/
@kotlin.jvm.JvmName("putAllVararg")
@Deprecated("Use an overload without vararg", ReplaceWith("putAll(pairs)"))
public fun MutableMap.putAll(vararg pairs: Pair): Unit {
putAll(pairs)
}
/**
* Puts all the given [pairs] into this [MutableMap] with the first component in the pair being the key and the second the value.
*/
public fun MutableMap.putAll(pairs: Array>): Unit {
for ((key, value) in pairs) {
put(key, value)
}
}
/**
* Puts all the elements of the given collection into this [MutableMap] with the first component in the pair being the key and the second the value.
*/
public fun MutableMap.putAll(pairs: Iterable>): Unit {
for ((key, value) in pairs) {
put(key, value)
}
}
/**
* Puts all the elements of the given sequence into this [MutableMap] with the first component in the pair being the key and the second the value.
*/
public fun MutableMap.putAll(pairs: Sequence>): Unit {
for ((key, value) in pairs) {
put(key, value)
}
}
/**
* Returns a new map with entries having the keys of this map and the values obtained by applying the `transform`
* function to each entry in this [Map].
*
* @sample test.collections.MapTest.mapValues
*/
public inline fun Map.mapValues(transform: (Map.Entry) -> R): Map {
return mapValuesTo(LinkedHashMap(size), transform)
}
/**
* Returns a new Map with entries having the keys obtained by applying the `transform` function to each entry in this
* [Map] and the values of this map.
*
* @sample test.collections.MapTest.mapKeys
*/
public inline fun Map.mapKeys(transform: (Map.Entry) -> R): Map {
return mapKeysTo(LinkedHashMap(size), transform)
}
/**
* Returns a map containing all key-value pairs with keys matching the given [predicate].
*/
public inline fun Map.filterKeys(predicate: (K) -> Boolean): Map {
val result = LinkedHashMap()
for (entry in this) {
if (predicate(entry.key)) {
result.put(entry.key, entry.value)
}
}
return result
}
/**
* Returns a map containing all key-value pairs with values matching the given [predicate].
*/
public inline fun Map.filterValues(predicate: (V) -> Boolean): Map {
val result = LinkedHashMap()
for (entry in this) {
if (predicate(entry.value)) {
result.put(entry.key, entry.value)
}
}
return result
}
/**
* Appends all entries matching the given [predicate] into the mutable map given as [destination] parameter.
*
* @return the destination map.
*/
public inline fun > Map.filterTo(destination: C, predicate: (Map.Entry) -> Boolean): C {
for (element in this) {
if (predicate(element)) {
destination.put(element.key, element.value)
}
}
return destination
}
/**
* Returns a new map containing all key-value pairs matching the given [predicate].
*/
public inline fun Map.filter(predicate: (Map.Entry) -> Boolean): Map {
return filterTo(LinkedHashMap(), predicate)
}
/**
* Appends all entries not matching the given [predicate] into the given [destination].
*
* @return the destination map.
*/
public inline fun > Map.filterNotTo(destination: C, predicate: (Map.Entry) -> Boolean): C {
for (element in this) {
if (!predicate(element)) {
destination.put(element.key, element.value)
}
}
return destination
}
/**
* Returns a new map containing all key-value pairs not matching the given [predicate].
*/
public inline fun Map.filterNot(predicate: (Map.Entry) -> Boolean): Map {
return filterNotTo(LinkedHashMap(), predicate)
}
/**
* Returns a new map containing all key-value pairs from the given collection of pairs.
*/
public fun Iterable>.toMap(): Map
= LinkedHashMap(collectionSizeOrNull()?.let { mapCapacity(it) } ?: 16).apply { putAll(this@toMap) }
/**
* Returns a new map containing all key-value pairs from the given array of pairs.
*/
public fun Array>.toMap(): Map
= LinkedHashMap(mapCapacity(size)).apply { putAll(this@toMap) }
/**
* Returns a new map containing all key-value pairs from the given sequence of pairs.
*/
public fun Sequence>.toMap(): Map
= LinkedHashMap().apply { putAll(this@toMap) }
/**
* Converts this [Map] to a [LinkedHashMap], maintaining the insertion order of elements added to that map afterwards.
*/
public fun Map.toLinkedMap(): MutableMap = LinkedHashMap(this)
/**
* Creates a new read-only map by replacing or adding an entry to this map from a given key-value [pair].
*/
public operator fun Map.plus(pair: Pair): Map
= this.toLinkedMap().apply { put(pair.first, pair.second) }
/**
* Creates a new read-only map by replacing or adding entries to this map from a given collection of key-value [pairs].
*/
public operator fun Map.plus(pairs: Iterable>): Map
= this.toLinkedMap().apply { putAll(pairs) }
/**
* Creates a new read-only map by replacing or adding entries to this map from a given array of key-value [pairs].
*/
public operator fun Map.plus(pairs: Array>): Map
= this.toLinkedMap().apply { putAll(pairs) }
/**
* Creates a new read-only map by replacing or adding entries to this map from a given sequence of key-value [pairs].
*/
public operator fun Map.plus(pairs: Sequence>): Map
= this.toLinkedMap().apply { putAll(pairs) }
/**
* Creates a new read-only map by replacing or adding entries to this map from another [map].
*/
public operator fun Map.plus(map: Map): Map
= this.toLinkedMap().apply { putAll(map) }
/**
* Appends or replaces the given [pair] in this mutable map.
*/
public operator fun MutableMap.plusAssign(pair: Pair) {
put(pair.first, pair.second)
}
/**
* Appends or replaces all pairs from the given collection of [pairs] in this mutable map.
*/
public operator fun MutableMap.plusAssign(pairs: Iterable>) {
putAll(pairs)
}
/**
* Appends or replaces all pairs from the given array of [pairs] in this mutable map.
*/
public operator fun MutableMap.plusAssign(pairs: Array>) {
putAll(pairs)
}
/**
* Appends or replaces all pairs from the given sequence of [pairs] in this mutable map.
*/
public operator fun MutableMap.plusAssign(pairs: Sequence>) {
putAll(pairs)
}
/**
* Appends or replaces all entries from the given [map] in this mutable map.
*/
public operator fun MutableMap.plusAssign(map: Map) {
putAll(map)
}
/**
* Creates a new read-only map by removing a [key] from this map.
*/
public operator fun Map.minus(key: K): Map
= this.toLinkedMap().apply { minusAssign(key) }
/**
* Creates a new read-only map by removing a collection of [keys] from this map.
*/
public operator fun Map.minus(keys: Iterable): Map
= this.toLinkedMap().apply { minusAssign(keys) }
/**
* Creates a new read-only map by removing a array of [keys] from this map.
*/
public operator fun Map.minus(keys: Array): Map
= this.toLinkedMap().apply { minusAssign(keys) }
/**
* Creates a new read-only map by removing a sequence of [keys] from this map.
*/
public operator fun Map.minus(keys: Sequence): Map
= this.toLinkedMap().apply { minusAssign(keys) }
/**
* Removes the given [key] from this mutable map.
*/
public operator fun MutableMap.minusAssign(key: K) {
remove(key)
}
/**
* Removes all the given [keys] from this mutable map.
*/
public operator fun MutableMap.minusAssign(keys: Iterable) {
for (key in keys) remove(key)
}
/**
* Removes all the given [keys] from this mutable map.
*/
public operator fun MutableMap.minusAssign(keys: Array) {
for (key in keys) remove(key)
}
/**
* Removes all the given [keys] from this mutable map.
*/
public operator fun MutableMap.minusAssign(keys: Sequence) {
for (key in keys) remove(key)
}
