RootStore

open class RootStore<D>(initialData: D, id: String) : Store<D>

A Store can be initialized with a given value. Use a RootStore to "store" your model and create SubStores from here.

Parameters

initialData

first current value of this Store

id of this Store. Ids of SubStores will be concatenated.

Constructors

RootStore

fun <D> RootStore(initialData: D, id: String = Id.next())

Functions

enqueue

open suspend override fun enqueue(update: Update<D>)

in a RootStore an Update is handled by applying it to the internal StateFlow.

errorHandler

open fun errorHandler(cause: Throwable)

Default error handler printing the error to console.

handle

open fun handle(execute: suspend (D) -> D): SimpleHandler<Unit>

Factory method to create a SimpleHandler that does not take an Action

open fun <A> handle(execute: suspend (D, A) -> D): SimpleHandler<A>

Factory method to create a SimpleHandler mapping the actual value of the Store and a given Action to a new value.

handleAndEmit

open fun <E> handleAndEmit(execute: suspend FlowCollector<E>.(D) -> D): EmittingHandler<Unit, E>

factory method to create an EmittingHandler that does not take an action in it's execute-lambda.

open fun <A, E> handleAndEmit(execute: suspend FlowCollector<E>.(D, A) -> D): EmittingHandler<A, E>

Factory method to create a EmittingHandler taking an action-value and the current store value to derive the new value. An EmittingHandler is a Flow by itself and can therefore be connected to other SimpleHandlers even in other Stores.

handledBy

open infix fun <A> Flow<A>.handledBy(handler: Handler<A>)

Connects a Flow to a Handler.

open infix fun <A> Flow<A>.handledBy(execute: suspend (A) -> Unit): Job

open infix fun <E : Event> Flow<E>.handledBy(execute: suspend (E) -> Unit): Job

Connects a Flow to a suspendable execute function.

open infix fun <E : Event> Flow<E>.handledBy(handler: Handler<Unit>)

Connects Events to a Handler.

invoke

open operator fun Handler<Unit>.invoke()

open operator fun <A> Handler<A>.invoke(data: A)

Calls this handler exactly once.

sub

open fun <X> sub(lens: Lens<D, X>): SubStore<D, X>

create a SubStore that represents a certain part of your data model.

syncWith

open fun <D, I> Store<D>.syncWith(socket: Socket, resource: Resource<D, I>)

Syncs a Store by via a Websockets connection.

Properties

current

open override val current: D

Represents the current data of this RootStore.

data

override val data: Flow<D>

Emits a Flow with the current data of this RootStore. The Flow internal data is only changed, when the value differs from the last one to avoid calculations and updates that are not necessary.

open override val id: String

job

open override val job: Job

Job used as parent job on all coroutines started in Handlers in the scope of this Store

path

open override val path: String

Path of this Store derived from the underlying model. Paths of depending Stores are concatenated and separated by a dot.

update

open override val update: SimpleHandler<D>

a simple SimpleHandler that just takes the given action-value as the new value for the Store.

Inheritors

ValidatingStore