micro_utils.dokka/dev.inmo.micro_utils.coroutines/AccumulatorFlow

AccumulatorFlow

class AccumulatorFlow<T>(sourceDataFlow: Flow<T>, scope: CoroutineScope) : AbstractFlow<T> (source)

This Flow will have behaviour very similar to SharedFlow, but there are several differences:

All unhandled by FlowCollector data will not be removed from AccumulatorFlow and will be sent to new FlowCollectors until anybody will handle it
Here there are an activeData where data T will be stored until somebody will handle it

Constructors

AccumulatorFlow

constructor(sourceDataFlow: Flow<T>, scope: CoroutineScope)

Functions

accumulatorFlow

fun <T> Flow<T>.accumulatorFlow(scope: CoroutineScope): Flow<T>

Creates AccumulatorFlow using this as base Flow

asComposeList

inline fun <T> Flow<List<T>>.asComposeList(scope: CoroutineScope, useContextOnChange: CoroutineContext? = Dispatchers.Main, noinline onException: ExceptionHandler<List<T>?> = defaultSafelyWithoutExceptionHandlerWithNull): List<T>

In fact, it is just classcast of asMutableComposeListState to List

asComposeState

fun <T> Flow<T>.asComposeState(initial: T, scope: CoroutineScope, useContextOnChange: CoroutineContext? = Dispatchers.Main, onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull): ERROR CLASS: Ambiguity: State, [kotlin/collections/State, kotlin/sequences/State]<T>

Will create MutableState using asMutableComposeState and use asState to convert it as immutable state

asMutableComposeListState

inline fun <T> Flow<List<T>>.asMutableComposeListState(scope: CoroutineScope, useContextOnChange: CoroutineContext? = Dispatchers.Main, noinline onException: ExceptionHandler<List<T>?> = defaultSafelyWithoutExceptionHandlerWithNull): ERROR CLASS: Symbol not found for SnapshotStateList<T>

Each value of this will trigger applyDiff to the result SnapshotStateList

asMutableComposeState

fun <T> Flow<T>.asMutableComposeState(initial: T, scope: CoroutineScope, useContextOnChange: CoroutineContext? = Dispatchers.Main, onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull): ERROR CLASS: Symbol not found for MutableState<T>

Will map this as MutableState. Returned MutableState WILL NOT change source Flow

collect

suspend override fun collect(collector: FlowCollector<T>)

collectSafely

open suspend override fun collectSafely(collector: FlowCollector<T>)

debouncedBy

fun <T> Flow<T>.debouncedBy(timeout: (T) -> Long, markerFactory: (T) -> Any?): Flow<T>

Debounces a Flow with per-marker timeout control. Values with the same marker will be debounced independently. For each marker, only the last value within the timeout period will be emitted.

fun <T> Flow<T>.debouncedBy(timeout: Long, markerFactory: (T) -> Any?): Flow<T>

Debounces a Flow with a fixed timeout in milliseconds and per-marker control. Values with the same marker will be debounced independently.

fun <T> Flow<T>.debouncedBy(timeout: Duration, markerFactory: (T) -> Any?): Flow<T>

Debounces a Flow with a fixed timeout as Duration and per-marker control. Values with the same marker will be debounced independently.

filterNotNull

fun <T> Flow<T>.filterNotNull(): Flow<T & Any>

Alias for takeNotNull. Filters out null values from this Flow, returning only non-null elements.

firstNotNull

suspend fun <T> Flow<T?>.firstNotNull(): T & Any

Returns the first non-null element emitted by this Flow. Suspends until a non-null element is found.

flatMap

@JvmName(name = "flatMapIterable")

inline fun <T, R> Flow<Iterable<T>>.flatMap(crossinline mapper: suspend (T) -> R): Flow<R>

Transforms each element from inner Iterables using the given mapper function and flattens the result into a single Flow.

inline fun <T, R> Flow<Flow<T>>.flatMap(crossinline mapper: suspend (T) -> R): Flow<R>

Transforms each inner Flow element using the given mapper function and flattens the result into a single Flow.

flatMapNotNull

@JvmName(name = "flatMapNotNullIterable")

inline fun <T, R> Flow<Iterable<T>>.flatMapNotNull(crossinline mapper: suspend (T) -> R): Flow<R & Any>

Transforms each element from inner Iterables using the given mapper function, flattens the result, and filters out null values.

inline fun <T, R> Flow<Flow<T>>.flatMapNotNull(crossinline mapper: suspend (T) -> R): Flow<R & Any>

Transforms each inner Flow element using the given mapper function, flattens the result, and filters out null values.

flatten

@JvmName(name = "flattenIterable")

fun <T> Flow<Iterable<T>>.flatten(): Flow<T>

Flattens a Flow of Iterables into a single Flow by emitting all elements from each iterable.

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

Flattens a Flow of Flows into a single Flow by collecting all inner flows sequentially.

mapLeftItems

inline fun Flow<Int>.mapLeftItems(crossinline countGetter: () -> Int): Flow<Int>

mapRequireFilling

inline fun Flow<Int>.mapRequireFilling(minimalLeftItems: Int, crossinline countGetter: () -> Int): Flow<Int>

plus

inline operator fun <T> Flow<T>.plus(other: Flow<T>): Flow<T>

Merges two flows into a single flow. Values from both flows will be emitted as they become available. This is a convenient operator syntax for merge.

inline fun <T> Flow<T>.subscribe(scope: CoroutineScope, noinline block: suspend (T) -> Unit): Job

Shortcut for chain if Flow.onEach and Flow.launchIn

subscribeAsync

fun <T, M> Flow<T>.subscribeAsync(scope: CoroutineScope, markerFactory: suspend (T) -> M, logger: KSLog = KSLog, block: suspend (T) -> Unit): Job

Subscribes to a Flow with asynchronous processing based on markers. Each value from the flow will be processed by the block function. Values with the same marker will be processed sequentially in the same coroutine scope, while values with different markers can be processed concurrently in separate coroutine scopes.

subscribeLogging

inline fun <T> Flow<T>.subscribeLogging(scope: CoroutineScope, noinline errorMessageBuilder: T.(Throwable) -> Any = { "Something web wrong" }, logger: KSLog = KSLog, noinline block: suspend (T) -> Unit): Job

Use subscribe, but all blocks will be called inside of safely function. Use onException to set up your reaction for Throwables

subscribeLoggingDropExceptions

inline fun <T> Flow<T>.subscribeLoggingDropExceptions(scope: CoroutineScope, noinline errorMessageBuilder: T.(Throwable) -> Any = { "Something web wrong" }, logger: KSLog = KSLog, noinline block: suspend (T) -> Unit): Job

Use subscribeSafelyWithoutExceptions, but all exceptions will be passed to defaultSafelyExceptionHandler

subscribeLoggingDropExceptionsAsync

fun <T, M> Flow<T>.subscribeLoggingDropExceptionsAsync(scope: CoroutineScope, markerFactory: suspend (T) -> M, logger: KSLog = KSLog, block: suspend (T) -> Unit): Job

Subscribes to a Flow with asynchronous processing based on markers, automatically logging and dropping exceptions. Each value from the flow will be processed by the block function. Values with the same marker will be processed sequentially, while values with different markers can be processed concurrently. Any exceptions thrown during processing will be logged and dropped without affecting other messages.

takeNotNull

fun <T> Flow<T>.takeNotNull(): Flow<T & Any>

Filters out null values from this Flow, returning only non-null elements.