commonMain.kr.jadekim.common.extension.collections.kt Maven / Gradle / Ivy

Go to download
package kr.jadekim.common.extension

import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract

@Suppress("NOTHING_TO_INLINE")
@OptIn(ExperimentalContracts::class)
inline fun  Collection?.hasValue(): Boolean {
    contract {
        returns(true) implies (this@hasValue != null)
    }

    return !hasNotValue()
}

@Suppress("NOTHING_TO_INLINE")
@OptIn(ExperimentalContracts::class)
inline fun  Collection?.hasNotValue(): Boolean {
    contract {
        returns(false) implies (this@hasNotValue != null)
    }

    return isNullOrEmpty()
}

fun  List.sequentialGroupBy(keySelector: (T) -> K): List>> {
    val result = mutableListOf>>()

    var prevKey: K? = null
    var prevItems = mutableListOf()

    for (each in this) {
        val key = keySelector(each)
        if (prevKey == key) {
            prevItems.add(each)
            continue
        }
        prevKey = key
        prevItems = mutableListOf(each)
        result.add(key to prevItems)
    }

    return result.toList()
}

fun > ClosedRange.iterable(next: (T) -> T?): Iterable = object: Iterable {

    override fun iterator(): Iterator = object : Iterator {
        private var isFirst = true
        private var nextValue: T? = start

        override fun hasNext(): Boolean {
            if (isFirst) {
                isFirst = false
                return true
            }

            if (nextValue == null) {
                return false
            }

            nextValue = next(nextValue!!)

            return nextValue != null && nextValue!! in this@iterable
        }

        override fun next(): T = nextValue!!
    }
}

fun  Iterable.withValue(
    values: Iterable,
    keySelector: (V) -> K,
    defaultValue: (K) -> V
): Iterable = object : Iterable {

    override fun iterator(): Iterator = object : Iterator {

        private val keyIterator = [email protected]()
        private val valueIterator = values.iterator()

        private var valueTemp: V? = null

        override fun hasNext(): Boolean = keyIterator.hasNext() || valueIterator.hasNext()

        override fun next(): V {
            if (!keyIterator.hasNext()) {
                return valueTemp ?: valueIterator.next()
            }

            val key = keyIterator.next()
            val value = valueTemp ?: if(valueIterator.hasNext()) valueIterator.next() else defaultValue(key)

            return if (key == keySelector(value)) {
                valueTemp = null
                value
            } else {
                valueTemp = value
                defaultValue(key)
            }
        }
    }
}

fun  Iterable.withValue(
    values: Map,
    defaultValue: (K) -> V
): Iterable = object : Iterable {

    override fun iterator(): Iterator = object : Iterator {

        private val iterator = [email protected]()

        override fun hasNext(): Boolean = iterator.hasNext()

        override fun next(): V {
            val key = iterator.next()
            return values[key] ?: defaultValue(key)
        }
    }
}