io.github.goquati/io.github.goquati.kotlin.util.coroutine

Package-level declarations

Types

class CoalescingTaskRunner(context: <Error class: unknown class> = Dispatchers.Default, errorHandler: (Throwable) -> Unit = {}, task: suspend () -> Unit)

A coroutine-based utility that coalesces multiple trigger calls into at most one active execution of a suspending task. It runs the task in a dedicated coroutine and ensures that:

CoalescingTaskRunnerWithResult

class CoalescingTaskRunnerWithResult<T>(context: <Error class: unknown class> = Dispatchers.Default, task: suspend () -> T)

A coroutine-based utility that coalesces multiple invocations of a suspending task and ensures only the latest scheduled invocation is executed, returning its result.

Functions

associate

inline suspend fun <T, K, V> <Error class: unknown class><T>.associate(crossinline block: (T) -> <Error class: unknown class><K, V>): Map<K, V>

associateBy

inline suspend fun <T, K> <Error class: unknown class><T>.associateBy(crossinline keySelector: (T) -> K): Map<K, T>

associateByNotNull

inline suspend fun <T, K : Any> <Error class: unknown class><T>.associateByNotNull(crossinline keySelector: (T) -> K?): Map<K, T>

associateNotNull

inline suspend fun <T, K : Any, V : Any> <Error class: unknown class><T>.associateNotNull(crossinline valueSelector: (T) -> <Error class: unknown class><K?, V?>?): Map<K, V>

associateWith

inline suspend fun <T, V> <Error class: unknown class><T>.associateWith(crossinline valueSelector: (T) -> V): Map<T, V>

associateWithNotNull

inline suspend fun <T, V : Any> <Error class: unknown class><T>.associateWithNotNull(crossinline valueSelector: (T) -> V?): Map<T, V>

awaitAll

suspend fun <R1, R2> awaitAll(f1: suspend <Error class: unknown class>.() -> R1, f2: suspend <Error class: unknown class>.() -> R2): <Error class: unknown class><R1, R2>

suspend fun <R1, R2, R3> awaitAll(f1: suspend <Error class: unknown class>.() -> R1, f2: suspend <Error class: unknown class>.() -> R2, f3: suspend <Error class: unknown class>.() -> R3): <Error class: unknown class><R1, R2, R3>

emitAll

suspend fun <T> <Error class: unknown class><T>.emitAll()

suspend fun <T> Iterable<T>.emitAll()

filterFailure

fun <E> <Error class: unknown class><Result<*, E>>.filterFailure(): <Error class: unknown class><E>

fun <Error class: unknown class><<Error class: unknown class><out <Error class: unknown class>>>.filterFailure(): <Error class: unknown class><Throwable>

filterNotEmpty

fun <T, C : Collection<T>> <Error class: unknown class><C>.filterNotEmpty(): <Error class: unknown class><C>

filterSuccess

fun <T> <Error class: unknown class><Result<T, *>>.filterSuccess(): <Error class: unknown class><T>

fun <T> <Error class: unknown class><<Error class: unknown class><T>>.filterSuccess(): <Error class: unknown class><T>

getAndResetCollection

inline suspend fun <T, C : Collection<T>> <Error class: unknown class><C>.getAndResetCollection(defaultValue: C): C

getAndResetList

inline suspend fun <T> <Error class: unknown class><List<T>>.getAndResetList(): List<T>

getAndResetSet

inline suspend fun <T> <Error class: unknown class><Set<T>>.getAndResetSet(): Set<T>

getOrPutAsync

suspend fun <K, V> ConcurrentMap<K, CompletableFuture<V>>.getOrPutAsync(key: K, block: suspend (K) -> V): V

groupBy

inline suspend fun <T, K> <Error class: unknown class><T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>

inline suspend fun <T, K, V> <Error class: unknown class><T>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>>

groupByNotNull

inline suspend fun <T, K : Any> <Error class: unknown class><T>.groupByNotNull(keySelector: (T) -> K?): Map<K, List<T>>

inline suspend fun <T, K : Any, V : Any> <Error class: unknown class><T>.groupByNotNull(keySelector: (T) -> K?, valueTransform: (T) -> V?): Map<K, List<V>>

isEmpty

suspend fun <T> <Error class: unknown class><T>.isEmpty(): Boolean

isNotEmpty

suspend fun <T> <Error class: unknown class><T>.isNotEmpty(): Boolean

launchJobs

fun <T> <Error class: unknown class>.launchJobs(nofWorkers: Int, block: suspend <Error class: unknown class>.(Int) -> T): List<<Error class: unknown class><T>>

launchWorker

fun <Error class: unknown class>.launchWorker(nofWorkers: Int, block: suspend <Error class: unknown class>.(Int) -> Unit): List<<Error class: unknown class>>

lazyAsync

fun <T> <Error class: unknown class>.lazyAsync(context: <Error class: unknown class> = EmptyCoroutineContext, block: suspend <Error class: unknown class>.() -> T): <Error class: unknown class><T>

loopCatching

fun <Error class: unknown class>.loopCatching(handler: (Throwable) -> Unit, block: suspend <Error class: unknown class>.() -> Unit): <Error class: unknown class>

mapParallel

fun <T, R> <Error class: unknown class><T>.mapParallel(concurrency: Int = DEFAULT_CONCURRENCY, block: suspend (T) -> R): <Error class: unknown class><R>

onEachFailure

fun <T, E> <Error class: unknown class><Result<T, E>>.onEachFailure(block: (E) -> Unit): <Error class: unknown class><Result<T, E>>

fun <T> <Error class: unknown class><<Error class: unknown class><T>>.onEachFailure(block: (Throwable) -> Unit): <Error class: unknown class><<Error class: unknown class><T>>

sendAll

suspend fun <T> <Error class: unknown class><T>.sendAll()

suspend fun <T> Iterable<T>.sendAll()

toBatchedFlow

fun <T> <Error class: unknown class><T>.toBatchedFlow(maxBatchSize: Int? = null): <Error class: unknown class><List<T>>

toReceiveChannel

suspend fun <T> Collection<T>.toReceiveChannel(): <Error class: unknown class><T>

suspend fun <T> Iterable<T>.toReceiveChannel(capacity: Int = Channel.UNLIMITED): <Error class: unknown class><T>

toResultCollection

suspend fun <T, E, C : MutableCollection<in T>> <Error class: unknown class><Result<T, E>>.toResultCollection(destination: C): Result<C, E>

suspend fun <T, C : MutableCollection<in T>> <Error class: unknown class><<Error class: unknown class><T>>.toResultCollection(destination: C): <Error class: unknown class><C>

toResultList

suspend fun <T, E> <Error class: unknown class><Result<T, E>>.toResultList(destination: MutableList<T> = ArrayList()): Result<List<T>, E>

suspend fun <T> <Error class: unknown class><<Error class: unknown class><T>>.toResultList(destination: MutableList<T> = ArrayList()): <Error class: unknown class><List<T>>

toResultSet

suspend fun <T, E> <Error class: unknown class><Result<T, E>>.toResultSet(destination: MutableSet<T> = LinkedHashSet()): Result<Set<T>, E>

suspend fun <T> <Error class: unknown class><<Error class: unknown class><T>>.toResultSet(destination: MutableSet<T> = LinkedHashSet()): <Error class: unknown class><Set<T>>