Package com.jetbrains.rd.util.reactive

Types

AddRemove

enum AddRemove : Enum<AddRemove>

A type of change in a collection.

ConcurrentViewableSet

class ConcurrentViewableSet<T> : IViewableConcurrentSet<T>

IAppendOnlyViewableConcurrentSet

interface IAppendOnlyViewableConcurrentSet<T> : Iterable<T>

IAsyncSignal

interface IAsyncSignal<T> : ISignal<T> , IAsyncSource<T>

IAsyncSource

interface IAsyncSource<out T> : ISource<T>

An object that allows to subscribe to events of type T and to handle them on a different thread.

IAsyncViewableMap

interface IAsyncViewableMap<K : Any, V : Any> : IViewableMap<K, V> , IAsyncSource<IViewableMap.Event<K, V>>

IAsyncVoidSignal

typealias IAsyncVoidSignal = IAsyncSignal<Unit>

IMutablePropertyBase

interface IMutablePropertyBase<T> : IPropertyBase<T>

IMutableViewableList

interface IMutableViewableList<V : Any> : MutableList<V> , IViewableList<V>

IMutableViewableMap

interface IMutableViewableMap<K : Any, V : Any> : MutableMap<K, V> , IViewableMap<K, V>

IMutableViewableSet

interface IMutableViewableSet<T : Any> : MutableSet<T> , IViewableSet<T>

IOptProperty

interface IOptProperty<T : Any> : IOptPropertyView<T> , IMutablePropertyBase<T>

A mutable property that is created in an uninitialized state.

IOptPropertyView

interface IOptPropertyView<out T : Any> : IPropertyBase<T>

A read-only property that is created in an uninitialized state and can be observed.

IProperty

interface IProperty<T> : IPropertyView<T> , IMutablePropertyBase<T>

A mutable property.

IPropertyBase

interface IPropertyBase<out T> : ISource<T> , IViewable<T>

Common base class of optional and non-optional properties. Shouldn't be used in client code.

IPropertyView

interface IPropertyView<out T> : IPropertyBase<T>

A read-only property that can be observed.

IScheduler

interface IScheduler

Allows to queue the execution of actions on a different thread.

ISchedulerWithBackground

interface ISchedulerWithBackground : IScheduler

ISignal

interface ISignal<T> : ISource<T>

An object which has a collection of event listeners and can broadcast an event to the listeners.

ISource

interface ISource<out T>

An object that allows to subscribe to events of type T.

IViewable

interface IViewable<out T>

An object that allows to subscribe to changes of its contents.

IViewableConcurrentSet

interface IViewableConcurrentSet<T> : IAppendOnlyViewableConcurrentSet<T>

IViewableList

interface IViewableList<out V : Any> : List<V> , IViewable<Pair<Int, V>> , ISource<IViewableList.Event<V>>

A list allowing its contents to be observed.

IViewableMap

interface IViewableMap<K : Any, out V : Any> : Map<K, V> , IViewable<Map.Entry<K, V>> , ISource<IViewableMap.Event<K, V>>

A map allowing its contents to be observed.

IViewableSet

interface IViewableSet<T : Any> : Set<T> , IViewable<T> , ISource<IViewableSet.Event<T>>

A set allowing its contents to be observed.

IVoidSignal

typealias IVoidSignal = ISignal<Unit>

IVoidSource

typealias IVoidSource = ISource<Unit>

KeyValuePair

data class KeyValuePair<K, V>(val key: K, val value: V) : Map.Entry<K, V>

OptProperty

open class OptProperty<T : Any> : IOptProperty<T>

Property

class Property<T>(defaultValue: T) : IProperty<T>

Pump

class Pump(val pumpAction: () -> Unit, val pumpPauseMs: Long)

RdFault

class RdFault( val reasonTypeFqn: String, val reasonMessage: String, val reasonAsText: String, reason: Throwable? = null) : ExecutionException

Signal

open class Signal<T> : ISignal<T>

TaskResult

sealed class TaskResult<out T>

ViewableList

class ViewableList<T : Any>(storage: MutableList<T> = mutableListOf()) : IMutableViewableList<T>

ViewableMap

class ViewableMap<K : Any, V : Any>(map: MutableMap<K, V> = LinkedHashMap()) : IMutableViewableMap<K, V>

ViewableSet

class ViewableSet<T : Any>(set: MutableSet<T> = LinkedHashSet<T>()) : IMutableViewableSet<T>

WriteOnceProperty

class WriteOnceProperty<T : Any> : IOptProperty<T>

Functions

advise

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

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

adviseOn

fun IAsyncSource<Unit>.adviseOn( lifetime: Lifetime, scheduler: IScheduler, handler: () -> Unit)

adviseOnce

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

Executes handler exactly once then terminates the subscription

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)

and

fun IOptPropertyView<Boolean>.and(other: IOptPropertyView<Boolean>): IOptPropertyView<Boolean>

fun IPropertyView<Boolean>.and(other: IPropertyView<Boolean>): IPropertyView<Boolean>

asNullable

fun <T : Any> IOptPropertyView<T>.asNullable(): IPropertyView<T?>

Converts an optional property to a non-optional property with a nullable value type.

bind

fun <T> IMutablePropertyBase<T>.bind( lifetime: Lifetime, setValue: (value: T) -> Unit, valueUpdated: ((value: T) -> Unit) -> Unit)

compose

fun <T1 : Any, T2 : Any, TRes : Any> IOptPropertyView<T1>.compose(other: IOptPropertyView<T2>, composer: (T1, T2) -> TRes): IOptPropertyView<TRes>

fun <T1, T2, TRes> IPropertyView<T1>.compose(other: IPropertyView<T2>, composer: (T1, T2) -> TRes): IPropertyView<TRes>

createIsEmpty

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

fun <T : Any> IViewableSet<T>.createIsEmpty(): IPropertyView<Boolean>

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

fun <T : Any> IViewableSet<T>.createIsEmpty(lifetime: Lifetime): IPropertyView<Boolean>

createIsNotEmpty

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

fun <T : Any> IViewableSet<T>.createIsNotEmpty(): IPropertyView<Boolean>

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

fun <T : Any> IViewableSet<T>.createIsNotEmpty(lifetime: Lifetime): IPropertyView<Boolean>

distinct

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

filter

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

fire

fun IVoidSignal.fire()

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.

fold

fun <TSource, TResult : Any> Iterable<IPropertyView<TSource>>.fold( lifetime: Lifetime, initial: TResult, func: (TResult, TSource) -> TResult): OptProperty<TResult>

foldOpt

fun <TSource : Any, TResult : Any> Iterable<IOptPropertyView<TSource>>.foldOpt( lifetime: Lifetime, initial: TResult, func: (TResult, TSource) -> TResult): OptProperty<TResult>

foldRight

fun <TSource, TResult : Any> List<IPropertyView<TSource>>.foldRight( lifetime: Lifetime, initial: TResult, func: (TSource, TResult) -> TResult): OptProperty<TResult>

foldRightOpt

fun <TSource : Any, TResult : Any> List<IOptPropertyView<TSource>>.foldRightOpt( lifetime: Lifetime, initial: TResult, func: (TSource, TResult) -> TResult): OptProperty<TResult>

map

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

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

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.

not

fun IOptPropertyView<Boolean>.not(): IOptPropertyView<Boolean>

fun IPropertyView<Boolean>.not(): IPropertyView<Boolean>

fun IOptPropertyView<Boolean>.or(other: IOptPropertyView<Boolean>): IOptPropertyView<Boolean>

fun IPropertyView<Boolean>.or(other: IPropertyView<Boolean>): IPropertyView<Boolean>

setValue

fun <T> IProperty<T?>.setValue(lifetime: Lifetime, value: T?)

Sets the property value to the given value for the duration of the lifetime, and resets it to null when the lifetime is terminated.

switchMap

fun <T, K> IPropertyView<T>.switchMap(f: (T) -> IPropertyView<K>): IPropertyView<K>

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.

valueOrDefault

fun <T : Any> IOptProperty<T>.valueOrDefault(default: T): T

Returns the value of the property, or the given default value if the property was not initialized.

viewableTail

fun <T : Any> IViewableList<T>.viewableTail(): IPropertyView<T?>

Returns a property which evaluates to the last element of the list and is updated as elements are added to the list or removed from it.

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.

Properties

hasTrueValue

val IOptPropertyView<Boolean>.hasTrueValue: Boolean

hasValue

val <T : Any> IOptPropertyView<T>.hasValue: Boolean

Evaluates to true if the property has an initialized value.

valueOrThrow

val <T : Any> IOptPropertyView<T>.valueOrThrow: T

Returns the value of the property, or throws an exception if it was not initialized.