Event-observer-state/br.com.arch.toolkit.eventObserver.state/ViewModelState/Regular

Regular

class Regular<T : Any>(name: String, serializer: KSerializer<T>, stateHandle: SavedStateHandle, scope: CoroutineScope, json: Json = Json, default: T? = null, workerDispatcher: CoroutineDispatcher = Dispatchers.Default) : ViewModelState<T> (source)

Plain values from one-shot or continuous sources.

Constructors

Regular

constructor(name: String, serializer: KSerializer<T>, stateHandle: SavedStateHandle, scope: CoroutineScope, json: Json = Json, default: T? = null, workerDispatcher: CoroutineDispatcher = Dispatchers.Default)

Properties

data

val data: StateFlow<T?>

Saved payload stream, independent of execution status.

name

val name: String

Key owned by this state; its raw SavedStateHandle representation is a JSON string.

scope

val scope: CoroutineScope

Scope controlling operations, usually viewModelScope.

workerDispatcher

val workerDispatcher: CoroutineDispatcher

Dispatcher for repository work, transformations and serialization.

Functions

bind

fun bind(source: Flow<T>, onError: (Throwable) -> Unit = { throw it }): Job

Replaces the old operation. Unhandled errors propagate to the supplied scope.

bindMapped

fun <A> bindMapped(source: Flow<A>, onError: (Throwable) -> Unit = { throw it }, transform: suspend (A) -> T): Job

Transforms each repository value into a saved view value.

bindReducing

fun <A> bindReducing(source: Flow<A>, onError: (Throwable) -> Unit = { throw it }, reduce: suspend (T?, A) -> T): Job

Accumulates, merges or replaces data using a consumer-defined reducer.

cancel

fun cancel()

Stops the active operation without clearing state or completing its observers.

flow

fun flow(): StateFlow<T?>

Stable state; completing a bound flow leaves its last value here.

get

fun get(): T?

Reads the restored or latest saved payload.

invalidate

fun invalidate()

Clears the payload without disconnecting observers.

select

fun <R> select(transform: (T?) -> R): StateFlow<R>

Synchronous projection for cheap work. Use selectAsync for expensive computations.

selectAsync

fun <R> selectAsync(initialValue: R, transform: suspend (T?) -> R): StateFlow<R>

Computes an expensive derived state asynchronously; reads reuse its last completed value.

set

open fun set(value: T?)

Synchronous write for small values. Throws on codec failure, preserving the prior state. Prefer setAsync for expensive payloads; this method runs on the calling thread.

open fun set(value: T?, distinct: Boolean)

Compatibility overload: skips encoding equal values when distinct is true.

setAsync

fun setAsync(value: T?): Job

Prepares a detached saved snapshot on workerDispatcher, then commits on the owner scope. Replaces the active operation. Prefer this to synchronous set for expensive payloads. Plain failures propagate to the scope; result holders expose an Error with the old payload.