SubStore

fun <P, D> SubStore(parent: Store<P>, lens: Lens<P, D>)

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

Since a SubStore is just a view on a parent holding the real value, it forwards the Update to it, using it's Lens to transform it.

errorHandler

open override 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.

map

open fun <X> map(lens: Lens<D, X>): Store<X>

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

current

open override val current: D

represents the current value of the Store

data

open override val data: Flow<D>

the current value of the Store is derived from the data of it's parent using the given Lens.

id

open override val id: String

defines how to infer the id of the sub-part from the parent's id.

job

open override val job: Job

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

parent

val parent: Store<P>

path

open override val path: String

defines how to infer the id of the sub-part from the parent's id.

update

open override val update: SimpleHandler<D>

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

history

fun <D> Store<D>.history(capacity: Int = 0, initialEntries: List<D> = emptyList(), 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.

map

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.

mapByElement

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.

mapByIndex

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

mapByKey

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.

mapNull

fun <T> Store<T?>.mapNull(default: 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 provide a default value. When updating the value of the resulting Store to this default value, null is used instead updating the parent. When this Store's value would be null according to it's parent's value, the default value will be used instead.

messages

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

Finds all corresponding ValidationMessages to this Store.

SubStore

Constructors

Functions

Properties

Extensions