renetik-android-event/renetik.android.event.property/CSListValuesProperty

CSListValuesProperty

interface CSListValuesProperty<T> : CSListValuesVariable<T> , CSProperty<T>

Properties

eventIsFalse

val CSHasChangeValue<Boolean>.eventIsFalse: CSHasChange<Unit>

eventIsNotNull

val CSHasChangeValue<out Any?>.eventIsNotNull: CSHasChange<Unit>

eventIsNull

val CSHasChangeValue<out Any?>.eventIsNull: CSHasChange<Unit>

eventIsTrue

val CSHasChangeValue<Boolean>.eventIsTrue: CSHasChange<Unit>

nullable

val <T> CSHasChangeValue<T>?.nullable: CSHasChangeValue<T?>

value

abstract override var value: T

values

abstract val values: List<T>

Functions

action

inline fun <T> CSHasChangeValue<T>.action(noinline function: (T) -> Unit): CSRegistration

inline fun CSHasChange<Unit>.action(crossinline function: () -> Unit): CSRegistration

inline fun <ParentValue, ChildValue> CSHasChangeValue<ParentValue>.action(crossinline nullableChild: (ParentValue) -> CSHasChangeValue<ChildValue>?, crossinline action: (ChildValue?) -> Unit): CSRegistration

@JvmName(name = "actionChild")

inline fun <ParentValue, ChildValue> CSHasChangeValue<ParentValue>.action(crossinline child: (ParentValue) -> CSHasChangeValue<ChildValue>, crossinline action: (ChildValue) -> Unit): CSRegistration

inline fun CSHasChange<*>.action(crossinline function: () -> Unit): CSRegistration

inline fun CSHasChangeValue<Boolean>.action(crossinline onTrue: (CSRegistration) -> Unit, crossinline onFalse: (CSRegistration) -> Unit): CSRegistration

actionFalse

inline fun CSHasChangeValue<Boolean>.actionFalse(crossinline function: () -> Unit): CSRegistration

actionFalseLaunch

inline fun CSHasChangeValue<Boolean>.actionFalseLaunch(dispatcher: CoroutineDispatcher = Main, crossinline function: suspend () -> Unit): CSRegistration

actionFromTo

inline fun <T> CSHasChangeValue<T>.actionFromTo(crossinline function: (from: T?, to: T) -> Unit): CSRegistration

actionLaterOnce

inline fun <Argument> CSHasChangeValue<Argument>.actionLaterOnce(after: Duration = ZERO, crossinline onChange: ArgFun<Argument>): CSRegistration

actionLaunch

inline fun <T> CSHasChangeValue<T>.actionLaunch(dispatcher: CoroutineDispatcher = Main, crossinline function: suspend (T) -> Unit): CSRegistration

fun <T> CSHasChange<T>.actionLaunch(dispatcher: CoroutineContext = Main, function: suspend () -> Unit): CSRegistration

inline fun <T> CSHasChangeValue<T>.actionLaunch(key: String, dispatcher: CoroutineDispatcher = Main, crossinline function: suspend (T) -> Unit): CSRegistration

fun <T> CSHasChangeValue<T>.actionLaunch(parent: CSHasRegistrations, dispatcher: CoroutineContext = Main, function: suspend (T) -> Unit): CSRegistration

actionNotNull

inline fun <T> CSHasChangeValue<T?>.actionNotNull(crossinline function: () -> Unit): CSRegistration

inline fun <T> CSHasChangeValue<T?>.actionNotNull(crossinline function: (T) -> Unit): CSRegistration

actionNotNullOnce

inline fun <Argument> CSHasChangeValue<out Argument?>.actionNotNullOnce(crossinline function: (Argument) -> Unit): CSRegistration?

actionNull

inline fun <T> CSHasChangeValue<T?>.actionNull(crossinline function: () -> Unit): CSRegistration

actionTrue

inline fun CSHasChangeValue<Boolean>.actionTrue(crossinline function: (CSRegistration) -> Unit): CSRegistration

actionTrueLaunch

inline fun CSHasChangeValue<Boolean>.actionTrueLaunch(dispatcher: CoroutineDispatcher = Main, crossinline function: suspend (CSRegistration) -> Unit): CSRegistration

add

fun <T> CSProperty<List<T>>.add(item: T)

and

@JvmName(name = "CSHasChangeValueAndCSHasChangeValueBoolean")

infix fun <T> CSHasChangeValue<T>.and(other: CSHasChangeValue<Boolean>): CSHasChangeValue<T>

@JvmName(name = "CSHasChangeValueAndCSSafeHasChangeValueBoolean")

infix fun <T> CSHasChangeValue<T>.and(other: CSSafeHasChangeValue<Boolean>): CSSafeHasChangeValue<T>

@JvmName(name = "CSHasChangeValueBooleanAndBoolean")

infix fun CSHasChangeValue<Boolean>.and(other: Boolean): CSHasChangeValue<Boolean>

@JvmName(name = "CSHasChangeValueBooleanAndCSHasChangeValueBooleanNullable")

infix fun CSHasChangeValue<Boolean>.and(other: CSHasChangeValue<Boolean?>): CSHasChangeValue<Boolean>

@JvmName(name = "CSHasChangeValueBooleanAndCSHasChangeValueBoolean")

infix fun CSHasChangeValue<Boolean>.and(other: CSHasChangeValue<Boolean>): CSHasChangeValue<Boolean>

@JvmName(name = "CSHasChangeAndCSValue")

infix fun CSHasChange<*>.and(other: CSValue<Boolean>): CSHasChange<Unit>

asType

inline fun <T> CSHasChangeValue<*>.asType(): CSHasChangeValue<T?>

computed

inline fun <T> CSProperty<T>.computed(parent: CSHasRegistrations): CSProperty<T>

inline fun <T, V> CSHasChangeValue<T>.computed(parent: CSHasRegistrations? = null, crossinline child: (T) -> CSProperty<V>, noinline onChange: ArgFun<V>? = null): CSProperty<V>

inline fun <T, V> CSProperty<T>.computed(parent: CSHasRegistrations? = null, crossinline from: (T) -> V, crossinline to: (V) -> T, noinline onChange: ArgFun<V>? = null): CSProperty<V>

inline fun <T, V> CSProperty<T>.computed(parent: CSHasRegistrations? = null, crossinline get: (T) -> V, crossinline set: (CSProperty<T>, V) -> Unit, noinline onChange: ArgFun<V>? = null): CSProperty<V>

computedAsPercentOf

fun CSProperty<Int>.computedAsPercentOf(parent: CSHasRegistrations, max: Int = 100): CSProperty<Float>

computedFrom

inline fun <T> CSProperty<T>.computedFrom(parent: CSHasRegistrations? = null, crossinline from: (T) -> T, noinline onChange: ArgFun<T>? = null): CSProperty<T>

computedTo

inline fun <T> CSProperty<T>.computedTo(parent: CSHasRegistrations? = null, crossinline to: (T) -> T, noinline onChange: ArgFun<T>? = null): CSProperty<T>

connect

fun <T> CSProperty<T>.connect(property: CSProperty<T>): CSRegistration

delegate

fun <T> CSHasChangeValue<T>.delegate(parent: CSHasRegistrations? = null): CSHasChangeValue<T>

fun <T, Return> CSHasChangeValue<T>.delegate(parent: CSHasRegistrations? = null, fromValue: (T) -> Return): CSHasChangeValue<Return>

@JvmName(name = "delegateNullable")

fun <ParentValue, ChildValue> CSHasChangeValue<ParentValue>.delegate(parent: CSHasRegistrations? = null, fromValueNullableChild: (ParentValue) -> CSHasChangeValue<ChildValue>?): CSHasChangeValue<ChildValue?>

@JvmName(name = "delegateChild")

fun <ParentValue, ChildValue> CSHasChangeValue<ParentValue>.delegate(parent: CSHasRegistrations? = null, fromValueChild: (ParentValue) -> CSHasChangeValue<ChildValue>): CSHasChangeValue<ChildValue>

inline fun <Return> CSHasChange<out Any>.delegate(parent: CSHasRegistrations? = null, crossinline from: () -> Return): CSHasChangeValue<Return>

@JvmName(name = "delegateChild")

fun <ChildValue> CSHasChange<out Any>.delegate(parent: CSHasRegistrations? = null, child: () -> CSHasChangeValue<ChildValue>): CSHasChangeValue<ChildValue>

delegateChange

@JvmName(name = "delegateChildren")

fun <Argument, Return> CSHasChangeValue<Argument>.delegateChange(parent: CSHasRegistrations? = null, fromValueChildList: (Argument) -> List<CSHasChange<out Return>>): CSHasChange<Return>

fun <ParentValue, ChildValue> CSHasChangeValue<ParentValue>.delegateChange(parent: CSHasRegistrations? = null, fromValueNullableChild: (ParentValue) -> CSHasChange<ChildValue>?): CSHasChange<ChildValue>

@JvmName(name = "delegateChild")

fun <ParentValue, ChildValue> CSHasChangeValue<ParentValue>.delegateChange(parent: CSHasRegistrations? = null, fromValueChild: (ParentValue) -> CSHasChange<ChildValue>): CSHasChange<ChildValue>

delegateIsChange

fun <T> CSHasChangeValue<T>.delegateIsChange(parent: CSHasRegistrations? = null): CSHasChangeValue<Boolean>

event

inline fun CSHasChange<*>.event(): CSEvent<*>

eventIsNotNull

fun <T> CSHasChangeValue<out T?>.eventIsNotNull(): CSHasChange<T>

eventLaterOnce

inline fun CSHasChange<*>.eventLaterOnce(): CSEvent<*>

fireChange

abstract fun fireChange()

getAndSet

open fun getAndSet(newValue: T): T

getValue

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

ifFalse

@JvmName(name = "CSHasChangeValueIfFalseCSHasChangeValueBoolean")

infix fun <T> CSHasChangeValue<T>.ifFalse(other: CSHasChangeValue<Boolean>): CSHasChangeValue<T?>

ifTrue

@JvmName(name = "CSHasChangeValueIfTrueCSHasChangeValueBoolean")

infix fun <T> CSHasChangeValue<T>.ifTrue(other: CSHasChangeValue<Boolean>): CSHasChangeValue<T?>

invoke

operator fun <T> CSHasChange<T>.invoke(param: (T) -> Unit): CSRegistration

operator fun CSHasChange<Unit>.invoke(param: () -> Unit): CSRegistration

isEqualTo

infix inline fun <T> CSHasChangeValue<T>.isEqualTo(other: CSHasChangeValue<T>): CSHasChangeValue<Boolean>

isFalse

infix inline fun <T> CSHasChangeValue<T>.isFalse(crossinline condition: (T) -> Boolean): CSHasChangeValue<Boolean>

inline fun CSHasChangeValue<Boolean>.isFalse(parent: CSHasRegistrations? = null): CSHasChangeValue<Boolean>

isNotNull

inline fun <T> CSHasChangeValue<T?>.isNotNull(): CSHasChangeValue<Boolean>

isNotSetTo

infix inline fun <T> CSHasChangeValue<T>.isNotSetTo(value: T): CSHasChangeValue<Boolean>

isNull

inline fun <T> CSHasChangeValue<T?>.isNull(): CSHasChangeValue<Boolean>

isOfType

inline fun <T> CSHasChangeValue<*>.isOfType(): CSHasChangeValue<Boolean>

isSetTo

infix inline fun <T> CSHasChangeValue<T>.isSetTo(value: T): CSHasChangeValue<Boolean>

inline fun <T> CSHasChangeValue<T>.isSetTo(parent: CSHasRegistrations, value: T): CSHasChangeValue<Boolean>

isTrue

infix inline fun <T> CSHasChangeValue<T>.isTrue(crossinline condition: (T) -> Boolean): CSHasChangeValue<Boolean>

@JvmName(name = "CSHasChangeValueOptionalBooleanDelegateIsTrue")

inline fun CSHasChangeValue<Boolean?>.isTrue(parent: CSHasRegistrations? = null): CSHasChangeValue<Boolean>

inline fun CSHasChangeValue<Boolean>.isTrue(parent: CSHasRegistrations? = null): CSHasChangeValue<Boolean>

lazyDestructFactory

@JvmName(name = "CSHasChangeValueLazyDestructFactory")

fun <V, Instance : CSHasDestruct> CSHasChangeValue<V>.lazyDestructFactory(parent: CSHasRegistrations, create: (V) -> Instance): CSValue<Instance>

fun <V, Instance : CSHasDestruct> CSHasChangeValue<V>.lazyDestructFactory(parent: CSHasRegistrations? = null, createInstance: (V) -> Instance): CSValue<Instance>

lazyFactory

fun <V, Instance> CSHasChangeValue<V>.lazyFactory(parent: CSHasRegistrations, create: (Instance?, V) -> Instance): CSValue<Instance>

max

fun CSProperty<Float>.max(value: Float): CSProperty<Float>

min

fun CSProperty<Float>.min(value: Float): CSProperty<Float>

not

inline operator fun CSHasChangeValue<Boolean>.not(): CSHasChangeValue<Boolean>

operator fun CSProperty<Boolean>.not(): CSProperty<Boolean>

onChange

abstract fun onChange(function: (T) -> Unit): CSRegistration

onChange

inline fun <Argument> CSHasChange<Argument>.onChange(crossinline function: () -> Unit): CSRegistration

inline fun <Argument> CSHasChange<Argument>.onChange(crossinline function: (CSRegistration) -> Unit): CSRegistration

inline fun <Argument> CSHasChange<Argument>.onChange(crossinline function: (CSRegistration, Argument) -> Unit): CSRegistration

@JvmName(name = "onChangeChildNullable")

inline fun <ParentValue, ChildValue> CSHasChangeValue<ParentValue>.onChange(crossinline nullableChild: (ParentValue) -> CSHasChange<ChildValue>?, crossinline onChange: (ChildValue) -> Unit): CSRegistration

@JvmName(name = "onChangeChild")

inline fun <ParentValue, ChildValue> CSHasChangeValue<ParentValue>.onChange(crossinline child: (ParentValue) -> CSHasChange<ChildValue>, noinline onChange: (ChildValue) -> Unit): CSRegistration

onChangeFrom

inline fun <T> CSHasChangeValue<T>.onChangeFrom(crossinline function: (from: T) -> Unit): CSRegistration

onChangeFromTo

inline fun <T> CSHasChangeValue<T>.onChangeFromTo(crossinline function: (from: T, to: T) -> Unit): CSRegistration

onChangeFromToLaunch

fun <T> CSHasChangeValue<T>.onChangeFromToLaunch(function: suspend (from: T, to: T) -> Unit): CSRegistration

fun <T> CSHasChangeValue<T>.onChangeFromToLaunch(parent: CSHasRegistrations, function: suspend (from: T, to: T) -> Unit): CSRegistration

onChangeLaterOnce

inline fun <Argument> CSHasChange<Argument>.onChangeLaterOnce(crossinline function: Fun): CSRegistration

inline fun <Argument> CSHasChangeValue<Argument>.onChangeLaterOnce(after: Duration = ZERO, crossinline onChange: ArgFun<Argument>): CSRegistration

inline fun <Argument> CSHasChange<Argument>.onChangeLaterOnce(after: Duration, crossinline function: Fun): CSRegistration

onChangeLaunch

fun <T> CSHasChange<T>.onChangeLaunch(dispatcher: CoroutineContext = Main, function: suspend (T) -> Unit): CSRegistration

fun <T> CSHasChange<T>.onChangeLaunch(parent: CSHasRegistrations, function: suspend (T) -> Unit): CSRegistration

fun <T> CSHasChange<T>.onChangeLaunch(key: String, dispatcher: CoroutineContext = Main, function: suspend (T) -> Unit): CSRegistration

onChangeNotNull

inline fun <T> CSHasChangeValue<T?>.onChangeNotNull(crossinline function: (from: T) -> Unit): CSRegistration

onChangeNotNullOnce

inline fun <Argument> CSHasChange<out Argument?>.onChangeNotNullOnce(crossinline function: (Argument) -> Unit): CSRegistration

onChangeOnce

inline fun <Argument> CSHasChange<Argument>.onChangeOnce(parent: CSHasRegistrations? = null, crossinline function: () -> Unit): CSRegistration

inline fun <Argument> CSHasChange<Argument>.onChangeOnce(parent: CSHasRegistrations? = null, crossinline function: (Argument) -> Unit)

Registers a one-time change listener.

onChangeTo

inline fun <Value> CSHasChangeValue<Value>.onChangeTo(value: Value, crossinline onChange: () -> Unit): CSRegistration

onFalse

inline fun CSHasChangeValue<Boolean>.onFalse(crossinline function: () -> Unit): CSRegistration

fun CSHasChange<Boolean>.onFalse(function: () -> Unit): CSRegistration

onFalseLaunch

fun CSHasChange<Boolean>.onFalseLaunch(dispatcher: CoroutineContext = Main, function: suspend () -> Unit): CSRegistration

fun CSHasChange<Boolean>.onFalseLaunch(key: String, dispatcher: CoroutineContext = Main, function: suspend () -> Unit): CSRegistration

onFalseOnce

inline fun CSHasChangeValue<Boolean>.onFalseOnce(crossinline function: () -> Unit): CSRegistration

onNotNull

inline fun <T> CSHasChangeValue<out T?>.onNotNull(crossinline function: () -> Unit): CSRegistration

inline fun <T> CSHasChangeValue<out T?>.onNotNull(crossinline function: (T) -> Unit): CSRegistration

onNull

inline fun <T> CSHasChangeValue<out T?>.onNull(crossinline function: () -> Unit): CSRegistration

onTrue

inline fun CSHasChangeValue<Boolean>.onTrue(crossinline function: () -> Unit): CSRegistration

fun CSHasChange<Boolean>.onTrue(function: () -> Unit): CSRegistration

onTrueLaunch

fun CSHasChange<Boolean>.onTrueLaunch(dispatcher: CoroutineContext = Main, function: suspend () -> Unit): CSRegistration

onTrueOnce

inline fun CSHasChangeValue<Boolean>.onTrueOnce(crossinline function: () -> Unit): CSRegistration

onTrueUntilFalse

inline fun CSHasChangeValue<Boolean>.onTrueUntilFalse(crossinline registration: () -> CSRegistration?): CSRegistration

onType

inline suspend fun <T> CSHasChangeValue<*>.onType(): T

inline fun <T> CSHasChangeValue<*>.onType(crossinline function: (T) -> Unit): CSRegistration

onValue

inline fun <T> CSHasChangeValue<T>.onValue(function: (T) -> Unit)

infix fun <T> CSHasChangeValue<T>.or(second: CSHasChange<*>): CSHasChangeValue<T>

infix fun CSHasChangeValue<Boolean>.or(other: CSHasChangeValue<Boolean>): CSHasChangeValue<Boolean>

infix fun CSHasChange<*>.or(other: CSHasChange<*>): CSHasChange<Unit>

pause

open fun pause()

range

fun CSProperty<Float>.range(range: ClosedRange<Float>): CSProperty<Float>

rangeTo

operator fun CSProperty<Int>.rangeTo(other: CSProperty<Int>): ClosedRange<Int>

rangeUntil

operator fun CSProperty<Int>.rangeUntil(other: CSProperty<Int>): ClosedRange<Int>

remove

fun <T> CSProperty<List<T>>.remove(item: T)

resume

open fun resume(fireChange: Boolean = true)

safe

fun <T> CSProperty<T>.safe(parent: CSHasDestruct, @AnyThread onChangeUnsafe: (value: T) -> Unit? = null): CSSafeProperty<T>

safeStateDelegate

fun <T> CSHasChangeValue<T>.safeStateDelegate(parent: CSHasDestruct, onChange: ArgFun<T>? = null): CSSafeHasChangeValue<T>

safeValue

fun <T> CSHasChangeValue<T>.safeValue(parent: CSHasRegistrations): CSSafeValue<T>

set

operator fun <T> CSProperty<List<T>>.set(index: Int, newValue: T)

setValue

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

stateDelegate

fun <Argument> CSHasChangeValue<Argument>.stateDelegate(parent: CSHasRegistrations? = null, onChange: ArgFun<Argument>? = null): CSHasChangeValue<Argument>

fun <Argument, Return> CSHasChangeValue<Argument>.stateDelegate(parent: CSHasRegistrations? = null, fromValue: (Argument) -> Return, onChange: ArgFun<Return>? = null): CSHasChangeValue<Return>

@JvmName(name = "stateDelegateChild")

fun <ParentValue, Return> CSHasChangeValue<ParentValue>.stateDelegate(parent: CSHasRegistrations? = null, fromValueChild: (ParentValue) -> CSHasChangeValue<Return>, onChange: (Return) -> Unit? = null): CSHasChangeValue<Return>

fun <Argument, Return> CSHasChangeValue<Argument>.stateDelegate(parent: CSHasRegistrations? = null, fromValueAndPrevious: (Argument, Return?) -> Return, onChange: ArgFun<Return>? = null): CSHasChangeValue<Return>

stateDelegateDestruct

fun <Argument, Return : CSHasDestruct> CSHasChangeValue<Argument>.stateDelegateDestruct(parent: CSHasRegistrations? = null, fromValue: (Argument) -> Return, onChange: ArgFun<Return>? = null): CSHasChangeValue<Return>

stateDelegateNullable

fun <ParentValue, Return> CSHasChangeValue<ParentValue>.stateDelegateNullable(parent: CSHasRegistrations? = null, fromValueChild: (ParentValue) -> CSHasChangeValue<Return>?, onChange: (Return?) -> Unit? = null): CSHasChangeValue<Return?>

suspended

fun <T> CSProperty<T>.suspended(parent: CSHasRegistrations): CSSuspendProperty<T>

suspendIfFalse

suspend fun CSHasChangeValue<Boolean>.suspendIfFalse()

suspendIfTrue

suspend fun CSHasChangeValue<Boolean>.suspendIfTrue()

untilFalse

inline fun CSHasChangeValue<Boolean>.untilFalse(registration: CSRegistration): CSRegistration

@JvmName(name = "untilFalseCSRegistrationNullable")

inline fun CSHasChangeValue<Boolean>.untilFalse(registration: CSRegistration?): CSRegistration?

update

fun <Item : CSHasDestruct> CSValue<Int>.update(list: MutableList<Item>, function: (index: Int) -> Item)

fun CSValue<Int>.update(newCount: Int, onAdd: ArgFun<Int>? = null, onRemove: ArgFun<Int>? = null)

value

abstract fun value(newValue: T, fire: Boolean = true)

wait

suspend fun <T> CSHasChange<T>.wait(): T

waitFor

suspend fun <T> CSHasChangeValue<T>.waitFor(condition: (T) -> Boolean)

waitForFalse

suspend fun CSHasChangeValue<Boolean>.waitForFalse()

waitForTrue

suspend fun CSHasChangeValue<Boolean>.waitForTrue()