Store

interface Store<D>

Store interface is the main type for all two-way data binding activities.

Inheritors

Properties

Link copied to clipboard
abstract val current: D

represents the current value of the Store

Link copied to clipboard
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.

Link copied to clipboard
abstract val id: String

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

Link copied to clipboard
abstract val job: Job

Job for launching coroutines in.

Link copied to clipboard
abstract val path: String

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

Link copied to clipboard
abstract val update: Handler<D>

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

Functions

Link copied to clipboard
abstract suspend fun enqueue(update: Update<D>)

abstract method defining, how this Store handles an Update

Link copied to clipboard
open fun errorHandler(cause: Throwable)

Default error handler printing the error to console.

Link copied to clipboard
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.

Link copied to clipboard
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.

Link copied to clipboard
open fun <E> handleOnlyEmit(execute: suspend FlowCollector<E>.(D) -> Unit): EmittingHandler<Unit, E>

factory method to create an EmittingHandler taking the current store value but does not derive a new value from it. The actual value is just passed through, so it is all about dealing with some side effect by calling the FlowCollector.emit function from within the execute parameter.

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

factory method to create an EmittingHandler taking an action-value and the current store value but does not derive a new value from both. The actual value is just passed through, so it is all about dealing with some side effect by calling the FlowCollector.emit function from within the execute parameter.

Link copied to clipboard
fun <D> Store<D>.history(capacity: Int = 0, initialEntries: List<D> = emptyList(), job: Job = this.job, synced: Boolean = true): History<D>

factory-method to create a History synced with the given Store, so that each update is automatically stored in history.

Link copied to clipboard
open fun <X> map(lens: Lens<D, X>): Store<X>

Creates a new Store that contains data derived by a given Lens.

Link copied to clipboard
fun <P, T> Store<P?>.map(lens: Lens<P & Any, T>): Store<T>

on a Store of nullable data this creates a Store with a nullable parent and non-nullable value. It can be called using a Lens on a non-nullable parent (that can be created by using the @Lenses-annotation), but you have to ensure, that the resulting Store is never used, when it's parent's value is null. Otherwise, a NullPointerException is thrown.

Link copied to clipboard
fun <D, I> Store<List<D>>.mapByElement(element: D, idProvider: IdProvider<D, I>): Store<D>

Creates a new Store containing the element for the given element and idProvider from the original Store's List.

Link copied to clipboard
fun <D> Store<List<D>>.mapByIndex(index: Int): Store<D>

Creates a new Store containing the element for the given index from the original Store's List

Link copied to clipboard
fun <K, V> Store<Map<K, V>>.mapByKey(key: K): Store<V>

Creates a new Store containing the corresponding value for the given key from the original Store's Map.

Link copied to clipboard
fun <T> Store<T?>.mapNull(default: T): Store<T>

Creates a new Store from a nullable parent store that either contains the original value or a given default value if the original value was null.

Link copied to clipboard
fun <T> Store<T>.mapNullable(placeholder: T): Store<T?>

Creates a new Store from a non-nullable parent store that either contains the original value or null if its value matches the given placeholder.

Link copied to clipboard
fun <M : ValidationMessage> Store<*>.messages(): Flow<List<M>>?

Finds all exactly corresponding ValidationMessages to this Store, which means all messages, which have exactly the same path as the Store.

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

Finds all corresponding ValidationMessages to this Store which satisfy the filterPredicate-expression.

Link copied to clipboard

Finds all corresponding ValidationMessages to this Store, which means all messages, that fit exactly with their path or which are sub-elements of this Stores data model.