KState/ca.acendas.kstate.observers/ObservableStateContainer

ObservableStateContainer

class ObservableStateContainer<T> : StateContainer<T>

Decorator that adds observer capability to any StateContainer.

This wrapper allows any StateContainer implementation to support state change notifications through the observer pattern. Observers are notified only after successful state updates.

Parameters

The type of state being managed

Types

Companion

object Companion

Properties

currentState

open override val currentState: T

The current state of the container.

hasObservers

val hasObservers: Boolean

Returns true if any observers are registered.

observerCount

val observerCount: Int

Returns the number of registered observers.

Functions

addObserver

fun addObserver(observer: StateObserver<T>): Boolean

Adds an observer to receive state change notifications.

clearObservers

fun clearObservers()

Removes all observers.

compareAndSet

fun <T> StateContainer<T>.compareAndSet(expectedState: T, newState: T): Boolean

Conditionally updates the state only if the current state matches the expected state.

getAndUpdate

fun <T> StateContainer<T>.getAndUpdate(updater: (T) -> T): T?

Updates the state and returns the previous state if successful, or null if failed.

getStateAs

inline fun <T, R : T> StateContainer<T>.getStateAs(): R?

Returns the current state cast to the specified type, or null if not of that type.

isState

fun <T> StateContainer<T>.isState(predicate: (T) -> Boolean): Boolean

Checks if the state matches a predicate.

isStateType

inline fun <T, R : T> StateContainer<T>.isStateType(): Boolean

Returns true if the current state is of the specified type.

map

fun <T, R> StateContainer<T>.map(mapper: (T) -> R): R

Maps the current state to a different type.

observe

fun observe(observer: (oldState: T, newState: T) -> Unit): Boolean

Adds an observer using a lambda for convenience.

observeChanges

fun observeChanges(observer: (oldState: T, newState: T) -> Unit): Boolean

Adds an observer that only reacts to actual state changes (not same state).

observeNewState

fun observeNewState(observer: (newState: T) -> Unit): Boolean

Adds an observer that only cares about the new state.

observeStateType

inline fun <R : T> observeStateType(crossinline observer: (oldState: T, newState: R) -> Unit): Boolean

Adds an observer that only reacts to specific state types.

observeWhen

fun observeWhen(predicate: (T, T) -> Boolean, observer: (oldState: T, newState: T) -> Unit): Boolean

Adds an observer that only reacts when a predicate is satisfied.

removeObserver

fun removeObserver(observer: StateObserver<T>): Boolean

Removes an observer from receiving state change notifications.

trySet

fun <T> StateContainer<T>.trySet(newState: T): Boolean

Attempts to set the state to a specific value.

updateAndGet

fun <T> StateContainer<T>.updateAndGet(updater: (T) -> T): T?

Updates the state and returns the new state if successful, or null if failed.

updateAtomic

fun <T> StateContainer<T>.updateAtomic(maxRetries: Int = 10, updater: (T) -> T): StateUpdateResult<T>

Extension function for StateContainer to perform atomic updates.

updateState

open override fun updateState(updater: (T) -> T): StateUpdateResult<T>

Updates the state using the provided updater function.

updateSuspending

suspend fun <T> StateContainer<T>.updateSuspending(updater: suspend (T) -> T): StateUpdateResult<T>

Transforms the state using a suspending function while maintaining thread safety.

validateState

open override fun validateState(state: T): ValidationResult

Validates the given state using the container's validator.

withState

fun <T> StateContainer<T>.withState(action: (T) -> Unit)

Executes an action with the current state.