kotlin.reflect.jvm.internal.impl.utils.collections.kt Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of kotlin-reflect Show documentation

Kotlin Full Reflection Library

There is a newer version: 2.1.0-Beta1

/*
 * Copyright 2010-2015 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package kotlin.reflect.jvm.internal.impl.utils

import java.util.*
import kotlin.coroutines.experimental.SequenceBuilder

fun  Iterable.keysToMap(value: (K) -> V): Map {
    return associateBy({ it }, value)
}

fun  Iterable.keysToMapExceptNulls(value: (K) -> V?): Map {
    val map = LinkedHashMap()
    for (k in this) {
        val v = value(k)
        if (v != null) {
            map[k] = v
        }
    }
    return map
}

fun  Iterable.mapToIndex(): Map {
    val map = LinkedHashMap()
    for ((index, k) in this.withIndex()) {
        map[k] = index
    }
    return map
}

inline fun  MutableMap.getOrPutNullable(key: K, defaultValue: () -> V): V {
    return if (!containsKey(key)) {
        val answer = defaultValue()
        put(key, answer)
        answer
    }
    else {
        get(key) as V
    }
}

inline fun > C.ifEmpty(body: () -> C): C = if (isEmpty()) body() else this

inline fun  Array.ifEmpty(body: () -> Array): Array = if (isEmpty()) body() else this

fun  MutableCollection.addIfNotNull(t: T?) {
    if (t != null) add(t)
}

suspend fun  SequenceBuilder.yieldIfNotNull(t: T?) = if (t != null) yield(t) else Unit

fun  newHashMapWithExpectedSize(expectedSize: Int): HashMap =
        HashMap(capacity(expectedSize))

fun  newHashSetWithExpectedSize(expectedSize: Int): HashSet =
        HashSet(capacity(expectedSize))

fun  newLinkedHashMapWithExpectedSize(expectedSize: Int): LinkedHashMap =
        LinkedHashMap(capacity(expectedSize))

fun  newLinkedHashSetWithExpectedSize(expectedSize: Int): LinkedHashSet =
        LinkedHashSet(capacity(expectedSize))

private fun capacity(expectedSize: Int): Int =
        if (expectedSize < 3) 3 else expectedSize + expectedSize / 3 + 1

fun  ArrayList.compactIfPossible(): List =
        when (size) {
            0 -> emptyList()
            1 -> listOf(first())
            else -> apply { trimToSize() }
        }

fun  List.indexOfFirst(startFrom: Int, predicate: (T) -> Boolean): Int {
    for (index in startFrom..lastIndex) {
        if (predicate(this[index])) return index
    }
    return -1
}