core/dev.fritz2.core/SubStore

SubStore

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

A Store that is derived from a parent Store mapping its data in both ways by a given Lens.

Constructors

SubStore

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

Functions

enqueue

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.

Properties

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.

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.

Extensions

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>

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.

messages

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

Finds all corresponding ValidationMessages to this Store.