core/de.peekandpoke.kraft.streams/StreamWrapper

StreamWrapper

abstract class StreamWrapper<T>(wrapped: Stream<T>) : StreamWrapperBase<T, T>

Base class for stream wrappers that keep the value type

Parameters

wrapped

The wrapped stream

Constructors

StreamWrapper

constructor(wrapped: Stream<T>)

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(): T

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<T>): Unsubscribe

Adds a subscription to the stream.