generated._Maps.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of kotlin-compiler-embeddable Show documentation
the Kotlin compiler embeddable
There is a newer version: 2.0.20
Show newest version
@file:kotlin.jvm.JvmMultifileClass
@file:kotlin.jvm.JvmName("MapsKt")
@file:kotlin.jvm.JvmVersion

package kotlin.collections

//
// NOTE THIS FILE IS AUTO-GENERATED by the GenerateStandardLib.kt
// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib
//

import kotlin.comparisons.*

/**
 * Returns a [List] containing all key-value pairs.
 */
public fun  Map.toList(): List> {
    if (size == 0)
        return emptyList()
    val iterator = entries.iterator()
    if (!iterator.hasNext())
        return emptyList()
    val first = iterator.next()
    if (!iterator.hasNext())
        return listOf(first.toPair())
    val result = ArrayList>(size)
    result.add(first.toPair())
    do {
        result.add(iterator.next().toPair())
    } while (iterator.hasNext())
    return result
}

/**
 * Returns a single list of all elements yielded from results of [transform] function being invoked on each entry of original map.
 */
public inline fun  Map.flatMap(transform: (Map.Entry) -> Iterable): List {
    return flatMapTo(ArrayList(), transform)
}

/**
 * Appends all elements yielded from results of [transform] function being invoked on each entry of original map, to the given [destination].
 */
public inline fun > Map.flatMapTo(destination: C, transform: (Map.Entry) -> Iterable): C {
    for (element in this) {
        val list = transform(element)
        destination.addAll(list)
    }
    return destination
}

/**
 * Returns a list containing the results of applying the given [transform] function
 * to each entry in the original map.
 */
public inline fun  Map.map(transform: (Map.Entry) -> R): List {
    return mapTo(ArrayList(size), transform)
}

/**
 * Returns a list containing only the non-null results of applying the given [transform] function
 * to each entry in the original map.
 */
public inline fun  Map.mapNotNull(transform: (Map.Entry) -> R?): List {
    return mapNotNullTo(ArrayList(), transform)
}

/**
 * Applies the given [transform] function to each entry in the original map
 * and appends only the non-null results to the given [destination].
 */
public inline fun > Map.mapNotNullTo(destination: C, transform: (Map.Entry) -> R?): C {
    forEach { element -> transform(element)?.let { destination.add(it) } }
    return destination
}

/**
 * Applies the given [transform] function to each entry of the original map
 * and appends the results to the given [destination].
 */
public inline fun > Map.mapTo(destination: C, transform: (Map.Entry) -> R): C {
    for (item in this)
        destination.add(transform(item))
    return destination
}

/**
 * Returns `true` if all entries match the given [predicate].
 */
public inline fun  Map.all(predicate: (Map.Entry) -> Boolean): Boolean {
    for (element in this) if (!predicate(element)) return false
    return true
}

/**
 * Returns `true` if map has at least one entry.
 */
public fun  Map.any(): Boolean {
    for (element in this) return true
    return false
}

/**
 * Returns `true` if at least one entry matches the given [predicate].
 */
public inline fun  Map.any(predicate: (Map.Entry) -> Boolean): Boolean {
    for (element in this) if (predicate(element)) return true
    return false
}

/**
 * Returns the number of entries in this map.
 */
@kotlin.internal.InlineOnly
public inline fun  Map.count(): Int {
    return size
}

/**
 * Returns the number of entries matching the given [predicate].
 */
public inline fun  Map.count(predicate: (Map.Entry) -> Boolean): Int {
    var count = 0
    for (element in this) if (predicate(element)) count++
    return count
}

/**
 * Performs the given [action] on each entry.
 */
@kotlin.internal.HidesMembers
public inline fun  Map.forEach(action: (Map.Entry) -> Unit): Unit {
    for (element in this) action(element)
}

/**
 * Returns the first entry yielding the largest value of the given function or `null` if there are no entries.
 */
@kotlin.internal.InlineOnly
public inline fun > Map.maxBy(selector: (Map.Entry) -> R): Map.Entry? {
    return entries.maxBy(selector)
}

/**
 * Returns the first entry having the largest value according to the provided [comparator] or `null` if there are no entries.
 */
@kotlin.internal.InlineOnly
public inline fun  Map.maxWith(comparator: Comparator>): Map.Entry? {
    return entries.maxWith(comparator)
}

/**
 * Returns the first entry yielding the smallest value of the given function or `null` if there are no entries.
 */
public inline fun > Map.minBy(selector: (Map.Entry) -> R): Map.Entry? {
    return entries.minBy(selector)
}

/**
 * Returns the first entry having the smallest value according to the provided [comparator] or `null` if there are no entries.
 */
public fun  Map.minWith(comparator: Comparator>): Map.Entry? {
    return entries.minWith(comparator)
}

/**
 * Returns `true` if the map has no entries.
 */
public fun  Map.none(): Boolean {
    for (element in this) return false
    return true
}

/**
 * Returns `true` if no entries match the given [predicate].
 */
public inline fun  Map.none(predicate: (Map.Entry) -> Boolean): Boolean {
    for (element in this) if (predicate(element)) return false
    return true
}

/**
 * Performs the given [action] on each entry and returns the map itself afterwards.
 */
@SinceKotlin("1.1")
public inline fun > M.onEach(action: (Map.Entry) -> Unit): M {
    return apply { for (element in this) action(element) }
}

/**
 * Creates an [Iterable] instance that wraps the original map returning its entries when being iterated.
 */
@kotlin.internal.InlineOnly
public inline fun  Map.asIterable(): Iterable> {
    return entries
}

/**
 * Creates a [Sequence] instance that wraps the original map returning its entries when being iterated.
 */
public fun  Map.asSequence(): Sequence> {
    return entries.asSequence()
}