core/de.peekandpoke.kraft.streams/AsyncStreamWrapper

AsyncStreamWrapper

abstract class AsyncStreamWrapper<WRAPPED, RESULT>(wrapped: Stream<WRAPPED>, mapper: suspend (WRAPPED) -> RESULT?) : StreamWrapperBase<WRAPPED, RESULT?>

Base class for stream wrappers that map the value type from WRAPPED to RESULT

Parameters

WRAPPED

The value type of the wrapped stream

RESULT

The value type of the resulting stream

Constructors

AsyncStreamWrapper

constructor(wrapped: Stream<WRAPPED>, mapper: suspend (WRAPPED) -> RESULT?)

Functions

asFlow

fun <T> Stream<T>.asFlow(): Flow<T>

Converts the Stream into a Flow

combinedWith

fun <IN1, IN2, OUT> Stream<IN1>.combinedWith(other: Stream<IN2>, combinator: (IN1, IN2) -> OUT): Stream<OUT>

Combines with the other stream.

debounce

fun <T> Stream<T>.debounce(delayMs: Int, delayFirstMs: Int = 3): Stream<T>

Debounce the incoming values by the given delayMs

distinct

fun <T> Stream<T>.distinct(): Stream<T>

fun <T> Stream<T>.distinct(strict: Boolean = false): Stream<T>

Ignores duplicate values and thus only publishes when the value has changed.

distinctStrict

fun <T> Stream<T>.distinctStrict(): Stream<T>

Ignores duplicate values and thus only publishes when the value has changed.

fallbackBy

fun <T> Stream<T?>.fallbackBy(fallback: () -> T): Stream<T>

Published the value produced by fallback whenever the value on the stream is null.

fallbackTo

fun <T> Stream<T?>.fallbackTo(fallback: T): Stream<T>

Published the fallback whenever the value on the stream is null.

filter

fun <T> Stream<T>.filter(predicate: (T) -> Boolean): Stream<T?>

fun <T> Stream<T>.filter(initial: T, predicate: (T) -> Boolean): Stream<T>

Filter the incoming values and publish only the ones that match the predicate.

filterIsInstance

inline fun <T, I : T> Stream<T?>.filterIsInstance(): Stream<I?>

inline fun <T, I : T> Stream<T?>.filterIsInstance(initial: I): Stream<I>

Filters the incoming values and publish only the ones that are an instance of I.

filterNotNull

fun <T> Stream<T?>.filterNotNull(initial: T): Stream<T>

Filter out all null values.

fold

fun <T, R> Stream<T>.fold(initial: R, operation: (acc: R, next: T) -> R): Stream<R>

Folds the incoming values with the operation starting with the initial value.

foldNotNull

fun <T, R> Stream<T?>.foldNotNull(initial: R, operation: (acc: R, next: T) -> R): Stream<R>

history

fun <T> Stream<T>.history(capacity: Int): Stream<List<T>>

Records the latest incoming values up to the given capacity.

historyOfNonNull

fun <T> Stream<T?>.historyOfNonNull(capacity: Int): Stream<List<T>>

Records the latest incoming values that are not null up to the given capacity.

indexed

fun <T> Stream<T>.indexed(): Stream<Pair<Int, T>>

Map the stream to pairs of index to value.

invoke

open operator override fun invoke(): RESULT?

Returns the current value of the stream

map

fun <IN, OUT> Stream<IN>.map(mapper: (IN) -> OUT): Stream<OUT>

Maps incoming values from type IN to type OUT.

mapAsync

fun <IN, OUT> Stream<IN>.mapAsync(mapper: suspend (IN) -> OUT?): Stream<OUT?>

Maps incoming values asynchronously from type IN to type OUT.

onEach

fun <T> Stream<T>.onEach(block: (T) -> Unit): Stream<T>

pairedWith

fun <IN1, IN2> Stream<IN1>.pairedWith(other: Stream<IN2>): Stream<Pair<IN1, IN2>>

Pairs the stream with the other stream.

permanent

fun <T> Stream<T>.permanent(): Stream<T>

fun <T> Stream<T>.permanent(handler: (T) -> Unit): Stream<T>

Subscribes to the stream permanently

subscribeToStream

open override fun subscribeToStream(sub: StreamHandler<RESULT?>): Unsubscribe

Adds a subscription to the stream.