Adds an event subscription. Every time an event occurs, the handler is called, receiving an instance of the event. The subscription is removed when the given lifetime expires.

advise

fun IVoidSource.advise(lifetime: Lifetime, handler: () -> Unit)

adviseAddRemove

open fun adviseAddRemove(lifetime: Lifetime, handler: (AddRemove, K, V) -> Unit)

Adds a subscription to additions and removals of map elements. When a map element is updated, the handler is called twice: to report the removal of the old element and the addition of the new one.

adviseEternal

fun <T> ISource<T>.adviseEternal(handler: (T) -> Unit)

Adds an event subscription that never gets removed.

adviseNotNull

fun <T : Any> ISource<T?>.adviseNotNull(lifetime: Lifetime, handler: (T) -> Unit)

Adds an event subscription that filters out null values.

adviseNotNullOnce

fun <T : Any> ISource<T?>.adviseNotNullOnce(lifetime: Lifetime, handler: (T) -> Unit): LifetimeDefinition

Executes handler exactly once when the source fires an event with a non-null value, then terminates the subscription

adviseOnce

fun <T> ISource<T>.adviseOnce(lifetime: Lifetime, handler: (T) -> Unit)

Executes handler exactly once then terminates the subscription

adviseSuspend

fun <T> ISource<T>.adviseSuspend(lifetime: Lifetime, scheduler: IScheduler, handler: suspend (T) -> Unit)

fun <T> ISource<T>.adviseSuspend(lifetime: Lifetime, context: CoroutineContext, handler: suspend (T) -> Unit)

adviseUntil

fun <T> ISource<T>.adviseUntil(lifetime: Lifetime, handler: (T) -> Boolean)

Holds subscription until handler returns true or lifetime is terminated

adviseWithPrev

fun <T> ISource<T>.adviseWithPrev(lifetime: Lifetime, handler: (prev: Maybe<T>, cur: T) -> Unit)

asProperty

fun <T> ISource<T>.asProperty(defaultValue: T): IPropertyView<T>

blockingPutUnique

fun <K, V> MutableMap<K, V>.blockingPutUnique(lf: Lifetime, lock: Any, key: K, value: V)

clear

open override fun clear()

containsKey

open override fun containsKey(key: K): Boolean

containsValue

open override fun containsValue(value: V): Boolean

createIsEmpty

fun <K : Any, V : Any> IViewableMap<K, V>.createIsEmpty(): IPropertyView<Boolean>

fun <K : Any, V : Any> IViewableMap<K, V>.createIsEmpty(lifetime: Lifetime): IPropertyView<Boolean>

createIsNotEmpty

fun <K : Any, V : Any> IViewableMap<K, V>.createIsNotEmpty(): IPropertyView<Boolean>

fun <K : Any, V : Any> IViewableMap<K, V>.createIsNotEmpty(lifetime: Lifetime): IPropertyView<Boolean>

distinct

fun <T> ISource<T>.distinct(): ISource<T>

filter

fun <T> ISource<T>.filter(f: (T) -> Boolean): ISource<T>

first

fun <TKey, TValue> Map<TKey, TValue>.first(): Map.Entry<TKey, TValue>

firstOrNull

fun <TKey, TValue> Map<TKey, TValue>.firstOrNull(): Map.Entry<TKey, TValue>?

flowInto

fun <TSrc> ISource<TSrc>.flowInto(lifetime: Lifetime, target: IMutablePropertyBase<TSrc>)

fun <TSrc : Any, TDst : Any> ISource<IViewableList.Event<TSrc>>.flowInto(lifetime: Lifetime, target: IMutableViewableList<TDst>, tf: (TSrc) -> TDst)

fun <TKey : Any, TValue : Any> ISource<IViewableMap.Event<TKey, TValue>>.flowInto(lifetime: Lifetime, target: IMutableViewableMap<TKey, TValue>, tf: (TValue) -> TValue)

fun <TSrc : Any, TDst : Any> ISource<IViewableSet.Event<TSrc>>.flowInto(lifetime: Lifetime, target: IMutableViewableSet<TDst>, tf: (TSrc) -> TDst)

fun <T> ISource<T>.flowInto(lifetime: Lifetime, target: ISignal<T>)

Whenever a change happens in this source, fires a change in the target signal of the same type.

fun <TSrc, TDst> ISource<TSrc>.flowInto(lifetime: Lifetime, target: IMutablePropertyBase<TDst>, tf: (TSrc) -> TDst)

Whenever a change happens in this source, changes the target property of the same type.

fun <TSource, TTarget> ISource<TSource>.flowInto(lifetime: Lifetime, target: ISignal<TTarget>, tf: (TSource) -> TTarget)

Whenever a change happens in this source, fires a change in the target signal obtained by running the given tf function.

get

open operator override fun get(key: K): V?

getOrCreate

inline fun <K : Any, V : Any> MutableMap<K, V>.getOrCreate(key: K, crossinline creator: (K) -> V): V

isEmpty

open override fun isEmpty(): Boolean

keySet

fun <K, V> MutableMap<K, V>.keySet(value: V): MutableSet<K>

map

fun <T, R> ISource<T>.map(f: (T) -> R): ISource<R>

Returns a new source which remaps events happening in this source using the given function f.

nextFalseValue

suspend fun ISource<Boolean>.nextFalseValue(): Boolean

nextFalseValueAsync

fun ISource<Boolean>.nextFalseValueAsync(lifetime: Lifetime): Deferred<Boolean>

nextNotNullValue

suspend fun <T : Any> ISource<T?>.nextNotNullValue(): T

nextNotNullValueAsync

fun <T : Any> ISource<T?>.nextNotNullValueAsync(lifetime: Lifetime): Deferred<T>

nextTrueValue

suspend fun ISource<Boolean>.nextTrueValue(): Boolean

nextTrueValueAsync

fun ISource<Boolean>.nextTrueValueAsync(lifetime: Lifetime): Deferred<Boolean>

nextValue

suspend fun <T> ISource<T>.nextValue(condition: (T) -> Boolean = { true }): T

nextValueAsync

fun <T> ISource<T>.nextValueAsync(lifetime: Lifetime, condition: (T) -> Boolean = { true }): Deferred<T>

put

open override fun put(key: K, value: V): V?

put

fun <K, V> MutableMap<K, V>.put(entry: Map.Entry<K, V>): V?

fun <K, V> MutableMap<K, V>.put(lf: Lifetime, key: K, value: V)

putAll

open override fun putAll(from: Map<out K, V>)

putUnique

fun <K, V> MutableMap<K, V>.putUnique(key: K, value: V): V

remove

open override fun remove(key: K): V?

open override fun remove(key: K, value: V): Boolean

throttleLast

fun <T : Any> ISource<T>.throttleLast(timeout: Duration, scheduler: IScheduler): ISource<T>

toViewableList

fun <K : Any, V : Any, T : Any> IMutableViewableMap<K, V>.toViewableList(lifetime: Lifetime, converter: (Lifetime, V) -> T): ViewableList<T>

Converts a viewable map to a viewable list of values, where the converter function is used to convert each map value to a list value.

view

open override fun view(lifetime: Lifetime, handler: (Lifetime, Map.Entry<K, V>) -> Unit)

Adds a subscription to changes of the contents of the map.

open fun view(lifetime: Lifetime, handler: (Lifetime, K, V) -> Unit)

Adds a subscription to changes of the contents of the map, with the handler receiving keys and values as separate parameters.

viewNotNull

fun <T : Any> IViewable<T?>.viewNotNull(lifetime: Lifetime, handler: (Lifetime, T) -> Unit)

Adds a subscription to changes to this viewable's contents and filters out null values. The subscription is removed when the given lifetime expires.

whenFalse

fun IViewable<Boolean>.whenFalse(lifetime: Lifetime, action: (Lifetime) -> Unit)

Executes the given action every time the value of the property changes to false.

whenTrue

fun IViewable<Boolean>.whenTrue(lifetime: Lifetime, action: (Lifetime) -> Unit)

Executes the given action every time the value of the property changes to true.