commons-provider-dsl/xyz.xenondevs.commons.provider.dsl/MutableProviderDslProperty

MutableProviderDslProperty

interface MutableProviderDslProperty<T> : MutableProvider<T>

A DSL property backed by a MutableProvider. Can be set to a static value or bound to a reactive MutableProvider using the by infix function.

Used for properties that can change at runtime:

// static initial value
page by 0

// reactive mutable provider (can be changed later)
val pageProvider = mutableProvider(0)
page by pageProvider

This property is also a MutableProvider, meaning that the configured provider can be read back:

someTextProperty by page.map { "Page: $it" }

Properties

children

abstract val children: Set<Provider<*>>

delegate

open override val delegate: MutableProvider<T>

isStable

abstract val isStable: Boolean

parents

abstract val parents: Set<Provider<*>>

value

abstract val value: DeferredValue<T>

Functions

addStrongChild

abstract fun addStrongChild(child: Provider<*>)

addWeakChild

abstract fun addWeakChild(child: Provider<*>)

open infix fun by(value: T)

Sets this property to a static value.

abstract infix fun by(provider: MutableProvider<T>)

Binds this property to a reactive MutableProvider. The property will update automatically when the provider's value changes, and changes to the property will propagate back.

decompose

abstract fun <A, B, C, D, E, F, G, H, I, J> decompose(decompose: (T) -> Tuple10<A, B, C, D, E, F, G, H, I, J>, recompose: (A, B, C, D, E, F, G, H, I, J) -> T): Tuple10<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>, MutableProvider<H>, MutableProvider, MutableProvider<J>>

abstract fun <A, B> decompose(decompose: (T) -> Tuple2<A, B>, recompose: (A, B) -> T): Tuple2<MutableProvider<A>, MutableProvider>

abstract fun <A, B, C> decompose(decompose: (T) -> Tuple3<A, B, C>, recompose: (A, B, C) -> T): Tuple3<MutableProvider<A>, MutableProvider, MutableProvider<C>>

abstract fun <A, B, C, D> decompose(decompose: (T) -> Tuple4<A, B, C, D>, recompose: (A, B, C, D) -> T): Tuple4<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>>

abstract fun <A, B, C, D, E> decompose(decompose: (T) -> Tuple5<A, B, C, D, E>, recompose: (A, B, C, D, E) -> T): Tuple5<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>>

abstract fun <A, B, C, D, E, F> decompose(decompose: (T) -> Tuple6<A, B, C, D, E, F>, recompose: (A, B, C, D, E, F) -> T): Tuple6<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>>

abstract fun <A, B, C, D, E, F, G> decompose(decompose: (T) -> Tuple7<A, B, C, D, E, F, G>, recompose: (A, B, C, D, E, F, G) -> T): Tuple7<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>>

abstract fun <A, B, C, D, E, F, G, H> decompose(decompose: (T) -> Tuple8<A, B, C, D, E, F, G, H>, recompose: (A, B, C, D, E, F, G, H) -> T): Tuple8<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>, MutableProvider<H>>

abstract fun <A, B, C, D, E, F, G, H, I> decompose(decompose: (T) -> Tuple9<A, B, C, D, E, F, G, H, I>, recompose: (A, B, C, D, E, F, G, H, I) -> T): Tuple9<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>, MutableProvider<H>, MutableProvider>

abstract fun <R> decompose(size: Int, decompose: (T) -> List<R>, recompose: (List<R>) -> T): List<MutableProvider<R>>

flatMap

abstract fun <R> flatMap(transform: (T) -> Provider<R>): Provider<R>

get

open override fun get(): T

getValue

open operator fun <X> getValue(thisRef: X?, property: KProperty<*>?): T

handleParentUpdated

abstract fun handleParentUpdated(updatedParent: Provider<*>)

immediateFlatMap

abstract fun <R> immediateFlatMap(transform: (T) -> Provider<R>): Provider<R>

immediateFlatMapMutable

abstract fun <R> immediateFlatMapMutable(transform: (T) -> MutableProvider<R>): MutableProvider<R>

map

abstract fun <R> map(transform: (T) -> R, untransform: (R) -> T): MutableProvider<R>

abstract fun <R> map(transform: (T) -> R): Provider<R>

observe

abstract fun observe(action: () -> Unit)

observeWeak

abstract fun <R : Any> observeWeak(owner: R, action: (owner: R) -> Unit)

removeStrongChild

abstract fun removeStrongChild(child: Provider<*>)

removeWeakChild

abstract fun removeWeakChild(child: Provider<*>)

set

open fun set(value: T)

open fun set(lazyValue: () -> T)

setValue

open operator fun <X> setValue(thisRef: X?, property: KProperty<*>, value: T)

strongDecompose

abstract fun <A, B, C, D, E, F, G, H, I, J> strongDecompose(decompose: (T) -> Tuple10<A, B, C, D, E, F, G, H, I, J>, recompose: (A, B, C, D, E, F, G, H, I, J) -> T): Tuple10<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>, MutableProvider<H>, MutableProvider, MutableProvider<J>>

abstract fun <A, B> strongDecompose(decompose: (T) -> Tuple2<A, B>, recompose: (A, B) -> T): Tuple2<MutableProvider<A>, MutableProvider>

abstract fun <A, B, C> strongDecompose(decompose: (T) -> Tuple3<A, B, C>, recompose: (A, B, C) -> T): Tuple3<MutableProvider<A>, MutableProvider, MutableProvider<C>>

abstract fun <A, B, C, D> strongDecompose(decompose: (T) -> Tuple4<A, B, C, D>, recompose: (A, B, C, D) -> T): Tuple4<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>>

abstract fun <A, B, C, D, E> strongDecompose(decompose: (T) -> Tuple5<A, B, C, D, E>, recompose: (A, B, C, D, E) -> T): Tuple5<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>>

abstract fun <A, B, C, D, E, F> strongDecompose(decompose: (T) -> Tuple6<A, B, C, D, E, F>, recompose: (A, B, C, D, E, F) -> T): Tuple6<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>>

abstract fun <A, B, C, D, E, F, G> strongDecompose(decompose: (T) -> Tuple7<A, B, C, D, E, F, G>, recompose: (A, B, C, D, E, F, G) -> T): Tuple7<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>>

abstract fun <A, B, C, D, E, F, G, H> strongDecompose(decompose: (T) -> Tuple8<A, B, C, D, E, F, G, H>, recompose: (A, B, C, D, E, F, G, H) -> T): Tuple8<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>, MutableProvider<H>>

abstract fun <A, B, C, D, E, F, G, H, I> strongDecompose(decompose: (T) -> Tuple9<A, B, C, D, E, F, G, H, I>, recompose: (A, B, C, D, E, F, G, H, I) -> T): Tuple9<MutableProvider<A>, MutableProvider, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>, MutableProvider<H>, MutableProvider>

abstract fun <R> strongDecompose(size: Int, decompose: (T) -> List<R>, recompose: (List<R>) -> T): List<MutableProvider<R>>

strongFlatMap

abstract fun <R> strongFlatMap(transform: (T) -> Provider<R>): Provider<R>

strongImmediateFlatMap

abstract fun <R> strongImmediateFlatMap(transform: (T) -> Provider<R>): Provider<R>

strongImmediateFlatMapMutable

abstract fun <R> strongImmediateFlatMapMutable(transform: (T) -> MutableProvider<R>): MutableProvider<R>

strongMap

abstract fun <R> strongMap(transform: (T) -> R, untransform: (R) -> T): MutableProvider<R>

abstract fun <R> strongMap(transform: (T) -> R): Provider<R>

abstract fun subscribe(action: (value: T) -> Unit)

subscribeWeak

abstract fun <R : Any> subscribeWeak(owner: R, action: (owner: R, value: T) -> Unit)

unobserve

abstract fun unobserve(action: () -> Unit)

unobserveWeak

abstract fun <R : Any> unobserveWeak(owner: R)

abstract fun <R : Any> unobserveWeak(owner: R, action: (R) -> Unit)

unsubscribe

abstract fun unsubscribe(action: (T) -> Unit)

unsubscribeWeak

abstract fun <R : Any> unsubscribeWeak(owner: R)

abstract fun <R : Any> unsubscribeWeak(owner: R, action: (R, T) -> Unit)

update

abstract fun update(value: DeferredValue<T>, ignore: Set<Provider<*>>): Boolean