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 add(action: CSProperty<Boolean>): 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?>

atomicProperty

fun <T> CSHasDestruct.atomicProperty(value: T, onChange: (value: T) -> Unit? = null): CSAtomicProperty<T>

backgroundOnce

fun CSHasDestruct.backgroundOnce(after: Int = 0, @WorkerThread function: () -> Unit): CSBackgroundOnceFunc

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

debouncer

fun CSHasRegistrations.debouncer(function: suspend () -> Unit): CSDebouncer

fun CSHasRegistrations.debouncer(dispatcher: CoroutineContext = Main, function: suspend () -> Unit): CSDebouncer

fun CSHasRegistrations.debouncer(after: Duration, function: suspend () -> Unit): CSDebouncer

fun CSHasRegistrations.debouncer(scope: CoroutineScope, function: suspend () -> Unit): CSDebouncer

fun CSHasRegistrations.debouncer(dispatcher: CoroutineContext = Main, after: Duration, function: suspend () -> Unit): CSDebouncer

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

open override fun fireChange()

getAndSet

open fun getAndSet(newValue: Boolean): Boolean

getValue

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

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>

later

inline fun CSHasDestruct.later(@MainThread crossinline function: () -> Unit)

inline fun CSHasRegistrations.later(after: Int, crossinline function: () -> Unit): CSRegistration

inline fun CSHasRegistrations.later(after: Duration, crossinline function: () -> Unit): CSRegistration

laterOnce

fun CSHasRegistrations.laterOnce(function: suspend () -> Unit): CSLaterOnceFunc

fun CSHasRegistrations.laterOnce(after: Duration, function: suspend () -> Unit): CSLaterOnceFunc

fun CSHasRegistrations.laterOnce(dispatcher: CoroutineDispatcher = Main, function: suspend () -> Unit): CSLaterOnceFunc

fun CSHasRegistrations.laterOnce(dispatcher: CoroutineDispatcher = Main, after: Duration, function: suspend () -> Unit): CSLaterOnceFunc

lateValue

fun <T> CSHasDestruct.lateValue(create: () -> CSValue<T>): CSLateReadOnlyProperty<T>

launch

fun CSHasRegistrations.launch(dispatcher: CoroutineContext = Main, func: suspend (JobRegistration) -> Unit): JobRegistration

fun CSHasRegistrations.launch(key: String, dispatcher: CoroutineContext = Main, func: suspend (JobRegistration) -> Unit): JobRegistration

fun CSHasRegistrations.launch(scope: CoroutineScope, context: CoroutineContext = Main, func: suspend (JobRegistration) -> Unit): JobRegistration

launchIfNot

fun CSHasRegistrations.launchIfNot(key: String, dispatcher: CoroutineContext = Main, func: suspend (CSRegistration) -> Unit): CSRegistration?

launchRepeat

fun CSHasRegistrations.launchRepeat(delay: Int, start: Boolean = true, dispatcher: CoroutineContext = Main, function: suspend () -> Unit): CSRegistration

fun CSHasRegistrations.launchRepeat(after: Int, delay: Int, start: Boolean = true, dispatcher: CoroutineContext = Main, function: suspend () -> Unit): CSRegistration

fun CSHasRegistrations.launchRepeat(dispatcher: CoroutineContext, delay: Int, after: Int = delay, start: Boolean = true, function: suspend () -> Unit): CSRegistration

fun CSHasRegistrations.launchRepeat(dispatcher: CoroutineContext = Main, delay: Duration = ZERO, after: Duration = delay, start: Boolean = true, function: suspend () -> Unit): CSRegistration

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>

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

lazyFactory

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

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

listenUntilTrueOnce

inline fun CSHasRegistrations.listenUntilTrueOnce(hasChange: CSHasChange<Boolean>, crossinline listener: () -> Unit): CSRegistration

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>

nullAtomicProperty

fun <T> CSHasDestruct.nullAtomicProperty(value: T? = null, onChange: (value: T?) -> Unit? = null): CSAtomicProperty<T?>

onCancel

fun CSHasRegistrations.onCancel(function: Fun): CSRegistration

onChange

open override fun onChange(function: (Boolean) -> 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.

inline fun CSHasRegistrations.onChangeOnce(event: CSHasChange<*>, crossinline listener: () -> Unit): CSRegistration

inline fun <T> CSHasRegistrations.onChangeOnce(event: CSHasChange<T>, crossinline listener: (argument: T) -> Unit): CSRegistration

onChangeTo

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

onDestruct

open override fun onDestruct()

onDestructed

inline fun CSHasDestruct.onDestructed(crossinline func: Fun)

inline fun CSHasDestruct.onDestructed(parent: CSHasRegistrations, crossinline func: Fun)

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

onMain

inline fun CSHasDestruct.onMain(@MainThread crossinline function: () -> Unit)

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()

plus

@JvmName(name = "plusNullable")

operator fun <T : CSRegistration> CSHasRegistrations.plus(registration: T?): T?

@JvmName(name = "plusPairNullable")

operator fun CSHasRegistrations.plus(registration: Pair<String, CSRegistration?>): CSRegistration?

operator fun CSHasRegistrations.plus(registration: Pair<String, CSRegistration>): CSRegistration

@JvmName(name = "plusRegistrationReplace")

operator fun CSHasRegistrations.plus(registration: Pair<CSRegistration?, CSRegistration>): CSRegistration

operator fun CSHasRegistrations.plus(registration: CSRegistration): CSRegistration

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>

@Synchronized

@AnyThread

fun CSModel.register(key: String, registration: CSRegistration?): CSRegistration?

@AnyThread

fun CSHasRegistrations.register(registration: CSRegistration): CSRegistration

@JvmName(name = "registerNullable")

fun CSHasRegistrations.register(registration: CSRegistration?): CSRegistration?

fun CSHasRegistrations.register(key: String, registration: CSRegistration): CSRegistration

@JvmName(name = "registerKeyRegistrationNullable")

fun CSHasRegistrations.register(key: String, registration: CSRegistration?): CSRegistration?

fun CSHasRegistrations.register(replace: CSRegistration?, registration: CSRegistration): CSRegistration

@JvmName(name = "registerReplaceRegistrationNullable")

fun CSHasRegistrations.register(replace: CSRegistration?, registration: CSRegistration?): CSRegistration?

remove

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

resume

open fun resume(fireChange: Boolean = true)

safe

fun <T> CSHasDestruct.safe(property: CSHasChangeValue<T>): CSSafeHasChangeValue<T>

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

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

safeEvent

@JvmName(name = "eventWithArgument")

inline fun <T> CSHasDestruct.safeEvent(): CSSafeEvent<T>

safeProperty

fun <T> CSHasDestruct.safeProperty(value: T, onChangeUnsafe: (value: T) -> Unit? = null): CSSafePropertyImpl<T>

fun <T> CSHasDestruct.safeProperty(value: T, onChangeUnsafe: (previous: T, current: T) -> Unit): CSSafePropertyImpl<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>

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

safeWeakProperty

fun <T> CSHasDestruct.safeWeakProperty(value: T? = null, onChangeUnsafe: (value: T?) -> Unit? = null): CSProperty<T?>

set

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

setValue

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

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()

throttler

fun CSHasRegistrations.throttler(function: suspend () -> Unit): CSThrottler<Unit>

fun <T> CSHasRegistrations.throttler(function: suspend (T) -> Unit): CSThrottler<T>

fun CSHasRegistrations.throttler(dispatcher: CoroutineContext = Main, function: suspend () -> Unit): CSThrottler<Unit>

fun <T> CSHasRegistrations.throttler(dispatcher: CoroutineContext = Main, function: suspend (T) -> Unit): CSThrottler<T>

fun CSHasRegistrations.throttler(after: Duration, function: suspend () -> Unit): CSThrottler<Unit>

fun <T> CSHasRegistrations.throttler(after: Duration, function: suspend (T) -> Unit): CSThrottler<T>

fun CSHasRegistrations.throttler(dispatcher: CoroutineContext = Main, after: Duration, function: suspend () -> Unit): CSThrottler<Unit>

fun <T> CSHasRegistrations.throttler(dispatcher: CoroutineContext = Main, after: Duration, function: suspend (T) -> Unit): CSThrottler<T>

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

open override fun value(newValue: Boolean, 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()