org.jetbrains.kotlin.utils.addToStdlib.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of kotlin-compiler Show documentation
the Kotlin compiler
There is a newer version: 2.0.0
/*
 * 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 org.jetbrains.kotlin.utils.addToStdlib

import java.lang.reflect.Modifier
import java.util.Collections
import java.util.NoSuchElementException
import java.util.concurrent.ConcurrentHashMap

public fun  T?.singletonOrEmptyList(): List = if (this != null) Collections.singletonList(this) else Collections.emptyList()

public fun  T.singletonList(): List = Collections.singletonList(this)

public fun  T?.singletonOrEmptySet(): Set = if (this != null) Collections.singleton(this) else Collections.emptySet()

public inline fun  Sequence<*>.firstIsInstanceOrNull(): T? {
    for (element in this) if (element is T) return element
    return null
}

public inline fun  Iterable<*>.firstIsInstanceOrNull(): T? {
    for (element in this) if (element is T) return element
    return null
}

public inline fun  Array<*>.firstIsInstanceOrNull(): T? {
    for (element in this) if (element is T) return element
    return null
}

public inline fun  Sequence<*>.firstIsInstance(): T {
    for (element in this) if (element is T) return element
    throw NoSuchElementException("No element of given type found")
}

public inline fun  Iterable<*>.firstIsInstance(): T {
    for (element in this) if (element is T) return element
    throw NoSuchElementException("No element of given type found")
}

public inline fun  Array<*>.firstIsInstance(): T {
    for (element in this) if (element is T) return element
    throw NoSuchElementException("No element of given type found")
}

public inline fun  Iterable<*>.lastIsInstanceOrNull(): T? {
    when (this) {
        is List<*> -> {
            for (i in this.indices.reversed()) {
                val element = this[i]
                if (element is T) return element
            }
            return null
        }

        else -> {
            return reverse().firstIsInstanceOrNull()
        }
    }
}

public fun  sequenceOfLazyValues(vararg elements: () -> T): Sequence = elements.asSequence().map { it() }

public fun  Pair.swap(): Pair = Pair(second, first)

public fun  T.check(predicate: (T) -> Boolean): T? = if (predicate(this)) this else null

public fun  constant(calculator: () -> T): T {
    val cached = constantMap[calculator]
    if (cached != null) return cached as T

    // safety check
    val fields = calculator.javaClass.getDeclaredFields().filter { it.getModifiers().and(Modifier.STATIC) == 0 }
    assert(fields.isEmpty()) {
        "No fields in the passed lambda expected but ${fields.joinToString()} found"
    }

    val value = calculator()
    constantMap[calculator] = value
    return value
}

private val constantMap = ConcurrentHashMap, Any>()

public fun String.indexOfOrNull(char: Char, startIndex: Int = 0, ignoreCase: Boolean = false): Int? {
    val index = indexOf(char, startIndex, ignoreCase)
    return if (index >= 0) index else null
}

public fun String.lastIndexOfOrNull(char: Char, startIndex: Int = 0, ignoreCase: Boolean = false): Int? {
    val index = lastIndexOf(char, startIndex, ignoreCase)
    return if (index >= 0) index else null
}