core-util/com.flixclusive.core.util.coroutines

Package-level declarations

Types

class AbortFlowException(val owner: FlowCollector<*>) : CancellationException

enum AppDispatchers : Enum<AppDispatchers>

Enum class representing different coroutine dispatchers for the application. Each enum constant encapsulates a CoroutineDispatcher and a corresponding CoroutineScope.

Functions

asStateFlow

fun <T> Flow<T>.asStateFlow(scope: CoroutineScope, started: SharingStarted = SharingStarted.WhileSubscribed(5000), initialValue: T = blockFirst()): StateFlow<T>

asyncCalls

suspend fun <R> asyncCalls(vararg transforms: suspend () -> R): List<R>

Executes multiple suspend functions asynchronously and waits for all to complete.

blockFirst

fun <T> Flow<T>.blockFirst(): T

Blocks the current thread until the first value is emitted by the flow. This should be used cautiously, as it blocks the thread.

blockFirstNotNull

fun <T> Flow<T>.blockFirstNotNull(): T

Blocks the current thread until the first non-null value is emitted by the flow. This should be used cautiously, as it blocks the thread.

collectWhile

inline suspend fun <T> Flow<T>.collectWhile(crossinline predicate: suspend (value: T) -> Boolean)

filterSuspend

fun <T> Flow<T>.filterSuspend(predicate: suspend (T) -> Boolean): Flow<T>

Filters the flow elements based on the given suspendable predicate.

firstNotNull

suspend fun <T> Flow<T>.firstNotNull(): T

The terminal operator that returns the first non-null element emitted by the flow and then cancels flow's collection. Throws NoSuchElementException if the flow was empty.

mapAsync

suspend fun <T, R> Array<out T>.mapAsync(mapper: suspend (T) -> R): List<R>

Asynchronously maps the elements of the array using the specified suspending function mapper.

suspend fun <T, R> Iterable<T>.mapAsync(mapper: suspend (T) -> R): List<R>

Asynchronously maps the elements of the iterable using the specified suspending function mapper.

mapIndexedAsync

suspend fun <T, R> Iterable<T>.mapIndexedAsync(mapper: suspend (Int, T) -> R): List<R>

Asynchronously maps the elements of the iterable with their index using the specified suspending function mapper.

mapSuspend

fun <T, R> Flow<T>.mapSuspend(transform: suspend (T) -> R): Flow<R>

Maps the flow elements using the given suspendable transformation function.