Store

interface Store<D> : WithJob

The Store is the main type for all data binding activities. It the base class of all concrete Stores like RootStore, SubStore, etc.

Functions

enqueue

abstract suspend fun enqueue(update: Update<D>)

abstract method defining, how this Store handles an Update

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

abstract val current: D

represents the current value of the Store

data

abstract val data: Flow<D>

the Flow representing the current value of the Store. Use this to bind it to ui-elements or derive calculated values by using map for example.

abstract val id: String

id of this Store. ids of depending Stores are concatenated and separated by a dot.

job

abstract val job: Job

Job for launching coroutines in.

path

abstract val path: String

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

update

abstract val update: Handler<D>

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

Inheritors

RootStore

SubStore

Router

Extensions

messages

fun <M : ValidationMessage> Store<*>.messages(): Flow<List<M>>?

Finds all corresponding ValidationMessages to this Store.

sub

fun <D, I> Store<List<D>>.sub(element: D, id: IdProvider<D, I>): SubStore<List<D>, D>

creates a SubStore using a RootStore as parent using a given IdProvider.

fun <D> Store<List<D>>.sub(index: Int): SubStore<List<D>, D>

creates a SubStore using a RootStore as parent using the index in the list (do not use this, if you want to manipulate the list itself (add or move elements, filter, etc.).