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: unknown class><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: unknown class><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: unknown class><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>

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

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

filterNotNull

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

firstNotNull

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

flatMap

@JvmName(name = "flatMapIterable")

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

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

flatMapNotNull

@JvmName(name = "flatMapNotNullIterable")

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

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

flatten

@JvmName(name = "flattenIterable")

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

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

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>

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, block: suspend (T) -> Unit): Job

subscribeSafely

inline fun <T> Flow<T>.subscribeSafely(scope: CoroutineScope, noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler, 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

subscribeSafelyAsync

fun <T, M> Flow<T>.subscribeSafelyAsync(scope: CoroutineScope, markerFactory: suspend (T) -> M, onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler, block: suspend (T) -> Unit): Job

subscribeSafelySkippingExceptions

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

Use subscribeSafelyWithoutExceptions, but all exceptions inside of safely will be skipped

subscribeSafelySkippingExceptionsAsync

fun <T, M> Flow<T>.subscribeSafelySkippingExceptionsAsync(scope: CoroutineScope, markerFactory: suspend (T) -> M, block: suspend (T) -> Unit): Job

subscribeSafelyWithoutExceptions

inline fun <T> Flow<T>.subscribeSafelyWithoutExceptions(scope: CoroutineScope, noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull, noinline block: suspend (T) -> Unit): Job

Use subscribeSafelyWithoutExceptions, but all exceptions will be passed to defaultSafelyExceptionHandler

subscribeSafelyWithoutExceptionsAsync

fun <T, M> Flow<T>.subscribeSafelyWithoutExceptionsAsync(scope: CoroutineScope, markerFactory: suspend (T) -> M, onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull, block: suspend (T) -> Unit): Job

takeNotNull

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