5.1.2

reactive/com.lightningkite.reactive.core/MutableRemember

MutableRemember

class MutableRemember<T>(stopListeningWhenOverridden: Boolean = true, useLastWhileLoading: Boolean = false, coroutineContext: CoroutineContext = Dispatchers.Unconfined, initialValue: ReactiveContext.() -> T) : BaseReactive<T> , ReactiveWithMutableValue<T> (source)

A mutable reactive value that can be set directly or calculated automatically from dependencies.

When not overridden, the value is calculated in a reactive context and updates automatically when dependencies change. When overridden by direct assignment, automatic calculation is paused until reset() is called.

Note:

MutableRemember is lazy: if it has no listeners, it will not calculate a value.
Listeners are only notified if the calculated or set value changes.
The reset() method restores automatic calculation and updates the value from dependencies.

Parameters

coroutineContext

The coroutine context for running the calculation.

initialValue

The block to compute the initial value reactively.

Constructors

MutableRemember

constructor(stopListeningWhenOverridden: Boolean = true, useLastWhileLoading: Boolean = false, coroutineContext: CoroutineContext = Dispatchers.Unconfined, initialValue: ReactiveContext.() -> T)

Properties

var overridden: Boolean

open override var state: ReactiveState<T>

@set:JvmName(name = "setValue2")

var <T> MutableValue<T>.value: T

val <T : Any> MutableReactive<T?>.waitForNotNull: MutableReactive<T>

val <T : Any> Reactive<T?>.waitForNotNull: Reactive<T>

Functions

addAndRunListener

fun Listenable.addAndRunListener(listener: () -> Unit): () -> Unit

Adds a listener and immediately runs it once.

abstract fun addListener(listener: () -> Unit): () -> Unit

Adds the listener to be called every time this event fires.

@JvmName(name = "writableStringAsByte")

fun MutableReactive<String>.asByte(): MutableReactive<Byte?>

@JvmName(name = "writableStringAsByteHex")

fun MutableReactive<String>.asByteHex(): MutableReactive<Byte?>

@JvmName(name = "writableIntAsDoubleNullable")

fun MutableReactive<Int?>.asDouble(): MutableReactive<Double?>

@JvmName(name = "writableStringAsDouble")

fun MutableReactive<String>.asDouble(): MutableReactive<Double?>

@JvmName(name = "writableStringAsFloat")

fun MutableReactive<String>.asFloat(): MutableReactive<Float?>

@JvmName(name = "writableStringAsInt")

fun MutableReactive<String>.asInt(): MutableReactive<Int?>

@JvmName(name = "writableStringAsIntHex")

fun MutableReactive<String>.asIntHex(): MutableReactive<Int?>

@JvmName(name = "writableStringAsLong")

fun MutableReactive<String>.asLong(): MutableReactive<Long?>

@JvmName(name = "writableStringAsLongHex")

fun MutableReactive<String>.asLongHex(): MutableReactive<Long?>

fun <T> MutableReactive<T>.assert(summary: String, description: String = summary, setOnIssue: Boolean = true, condition: (T) -> Boolean): MutableValidated<T>

Asserts a condition on this MutableReactive instance and reports an issue if the condition fails.

@JvmName(name = "writableStringAsShort")

fun MutableReactive<String>.asShort(): MutableReactive<Short?>

@JvmName(name = "writableStringAsShortHex")

fun MutableReactive<String>.asShortHex(): MutableReactive<Short?>

@JvmName(name = "writableStringAsUByteHex")

fun MutableReactive<String>.asUByteHex(): MutableReactive<UByte?>

@JvmName(name = "writableStringAsUIntHex")

fun MutableReactive<String>.asUIntHex(): MutableReactive<UInt?>

@JvmName(name = "writableStringAsULongHex")

fun MutableReactive<String>.asULongHex(): MutableReactive<ULong?>

@JvmName(name = "writableStringAsUShortHex")

fun MutableReactive<String>.asUShortHex(): MutableReactive<UShort?>

suspend fun <T> Reactive<T>.await(): T

suspend fun <T : Any> Reactive<T?>.awaitNotNull(): T

suspend fun <T> Reactive<T>.awaitOnce(): T

open override fun beginUse(): () -> Unit

Begins using the resource. Returns a function to stop using the resource.

fun <T> MutableReactive<T>.checkForIssue(validate: (T) -> Issue?): MutableValidated<T>

Adds a validation check to a MutableReactive instance, returning a MutableValidated that tracks issues.

@JvmName(name = "containsList")

infix fun <T> MutableReactive<List<T>>.contains(value: T): MutableReactive<Boolean>

infix fun <T> MutableReactive<Set<T>>.contains(value: T): MutableReactive<Boolean>

fun Listenable.debounce(timeMs: Long): Listenable

fun Listenable.debounce(duration: Duration): Listenable

fun <T> Reactive<T>.debounce(timeMs: Long): Reactive<T>

fun <T> Reactive<T>.debounce(duration: Duration): Reactive<T>

fun <T> MutableReactive<T>.debounceWrite(duration: Duration): MutableReactive<T>

infix fun <T> MutableReactive<T>.equalTo(value: T): MutableReactive<Boolean>

inline suspend fun <T> Reactive<T>.exception(): Exception?

fun <T> Reactive<MutableReactive<T>>.flatten(): MutableReactive<T>

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

inline suspend operator fun <T> Reactive<T>.invoke(): T

open fun <L> lens(get: (T) -> L, set: (L) -> T): MutableReactive<L>

'Lenses' a new type from this MutableReactive. This is useful when translating one type to another for user input, or safe type coercion.

open fun <L> lens(get: (T) -> L, modify: (T, L) -> T): MutableReactive<L>

'Lenses' a subtype from this MutableReactive. This is useful for extracting properties from a data class or modifying a single item in a collection.

fun <T, L> Reactive<T>.lens(get: (T) -> L): Reactive<L>

fun <E, ID> MutableReactive<List<E>>.~~lensByElement~~(identity: (E) -> ID): LensByElement<E, ID, LensByElement.Element<E, ID, *>>

@JvmName(name = "setLensByElement")

fun <E, ID> MutableReactive<Set<E>>.~~lensByElement~~(identity: (E) -> ID): LensByElement<E, ID, LensByElement.Element<E, ID, *>>

fun <E, ID, W> MutableReactive<List<E>>.~~lensByElement~~(identity: (E) -> ID, map: CalculationContext.(MutableWithReactiveValue<E>) -> W): LensByElement<E, ID, W>

@JvmName(name = "setLensByElement")

fun <E, ID, W> MutableReactive<Set<E>>.~~lensByElement~~(identity: (E) -> ID, map: CalculationContext.(MutableWithReactiveValue<E>) -> W): LensByElement<E, ID, W>

lensByElementAssumingSetNeverManipulates

fun <E> MutableReactive<List<E>>.lensByElementAssumingSetNeverManipulates(): Reactive<List<MutableReactiveElement<E>>>

fun <E, W> MutableReactive<List<E>>.lensByElementAssumingSetNeverManipulates(map: CalculationContext.(MutableReactiveElement<E>) -> W): Reactive<List<W>>

THIS ONLY WORKS IF THE set on the receiver never manipulates the input before notifying.

lensByElementWithIdentity

fun <E, ID> MutableReactive<List<E>>.lensByElementWithIdentity(identity: (E) -> ID): LensByElement<E, ID, LensByElement.Element<E, ID, *>>

@JvmName(name = "setLensByElementWithIdentity")

fun <E, ID> MutableReactive<Set<E>>.lensByElementWithIdentity(identity: (E) -> ID): LensByElement<E, ID, LensByElement.Element<E, ID, *>>

fun <E, ID, W> MutableReactive<List<E>>.lensByElementWithIdentity(identity: (E) -> ID, map: CalculationContext.(MutableWithReactiveValue<E>) -> W): LensByElement<E, ID, W>

@JvmName(name = "setLensByElementWithIdentity")

fun <E, ID, W> MutableReactive<Set<E>>.lensByElementWithIdentity(identity: (E) -> ID, map: CalculationContext.(MutableWithReactiveValue<E>) -> W): LensByElement<E, ID, W>

fun <T> Listenable.lensListenable(get: () -> T): Reactive<T>

infix suspend fun <T> MutableReactive<T>.modify(action: suspend (T) -> T)

fun <T : Any> MutableReactive<T?>.notNull(default: T): MutableReactive<T>

fun <T : Any> MutableReactive<T>.nullable(): MutableReactive<T?>

fun MutableReactive<String?>.nullToBlank(): MutableReactive<String>

fun MutableReactive<Double>.nullToZero(): MutableReactive<Double?>

fun <T> Reactive<T>.onNextSuccess(action: (T) -> Unit): () -> Unit

operator fun Listenable.plus(other: Listenable): Listenable

fun reset()

Restores automatic calculation and updates the value from dependencies. If the value was overridden, this resumes listening and updates the value.

abstract infix suspend fun set(value: T)

suspend fun <T> Reactive<T>.state(): ReactiveState<T>

suspend fun <T, V> Reactive<T>.state(get: (ReactiveState<T>) -> V): V

suspend fun MutableReactive<Boolean>.toggle()

fun <T> MutableReactive<T>.validate(setOnIssue: Boolean = true, validate: (T) -> String?): MutableValidated<T>

Adds a validation check to this MutableReactive instance.

fun <T> MutableReactive<T>.validated(): MutableValidated<T>

Wraps a MutableReactive as a MutableValidated.

fun <T> Reactive<T>.validated(validate: (T) -> Issue?): Validated<T>

validateNotBlank

fun MutableReactive<String>.validateNotBlank(summary: String = "Cannot be blank.", description: String = summary, setOnIssue: Boolean = true): MutableValidated<String>

Validates that the value of this MutableReactive is not blank (for String values).

validateNotNull

fun <T : Any> MutableReactive<T?>.validateNotNull(summary: String = "Cannot be blank.", description: String = summary, setOnIssue: Boolean = true): MutableValidated<T?>

Validates that the value of this MutableReactive is not null.

open infix override fun valueSet(value: T)

fun <T> Reactive<T>.withWrite(action: suspend Reactive<T>.(T) -> Unit): MutableReactive<T>