com.r3corda.client.fxutils

Package com.r3corda.client.fxutils

Types

AggregatedList class AggregatedList<A, E : Any, K : Any> : TransformationList<A, E>

Given an ObservableList<E> and a grouping key K, AggregatedList groups the elements by the key into a fresh ObservableList<E> for each group and exposes the groups as an observable list of As by calling assemble on each.

AmountBindings object AmountBindings

Utility bindings for the Amount type, similar in spirit to Bindings

AssociatedList class AssociatedList<K, out A, B> : ReadOnlyBackedObservableMapBase<K, B, Unit>

AssociatedList creates an ObservableMap from an ObservableList by associating each list element with a unique key. It is not allowed to have several elements map to the same value

ChosenList class ChosenList<E> : ObservableListBase<E>

ChosenList manages an ObservableList that may be changed by the wrapping ObservableValue. Whenever the underlying ObservableValue changes the exposed list changes to the new value. Changes to the list are simply propagated.

ConcatenatedList class ConcatenatedList<A> : TransformationList<A, ObservableList<A>>

ConcatenatedList takes a list of lists and concatenates them. Any change to the underlying lists or the outer list is propagated as expected.

FlattenedList class FlattenedList<A> : TransformationList<A, ObservableValue<out A>>

FlattenedList flattens the passed in list of ObservableValues so that changes in individual updates to the values are reflected in the exposed list as expected.

LeftOuterJoinedMap class LeftOuterJoinedMap<K : Any, A, B, C> : ReadOnlyBackedObservableMapBase<K, C, SimpleObjectProperty<B?>>

LeftOuterJoinedMap implements a special case of a left outer join where were matching on primary keys of both tables.

MapValuesList class MapValuesList<K, A, C> : ObservableList<C>

MapValuesList takes an ObservableMap and returns its values as an ObservableList. The order of returned elements is deterministic but unspecified.

MappedList class MappedList<A, B> : TransformationList<B, A>

This is a variant of EasyBind.map where the mapped list is backed, therefore the mapping function will only be run when an element is inserted or updated. Use this instead of EasyBind.map to trade off memory vs CPU, or if (god forbid) the mapped function is side-effecting.

ReadOnlyBackedObservableMapBase open class ReadOnlyBackedObservableMapBase<K, A, B> : ObservableMap<K, A>

ReadOnlyBackedObservableMapBase is a base class implementing all abstract functions required for an ObservableMap using a backing HashMap that subclasses should modify.

ReplayedList class ReplayedList<A> : TransformationList<A, A>

This list type just replays changes propagated from the underlying source list. Used for testing changes and backing a non-backed observable

Extensions for External Classes

javafx.beans.value.ObservableValue
javafx.collections.ObservableList
javafx.collections.ObservableMap
kotlin.Function1
kotlin.Function2
kotlin.Function3
kotlin.Function4
kotlin.collections.Collection

Functions

foldToObservableList fun <A, B, C> <ERROR CLASS><A>.foldToObservableList(initialAccumulator: C, folderFun: (A, C, ObservableList<B>) -> C): ObservableList<B>

foldToObservableList takes an rx.Observable stream and creates an ObservableList out of it, while maintaining an accumulator.

foldToObservableMap fun <A, B, K, C> <ERROR CLASS><A>.foldToObservableMap(initialAccumulator: C, folderFun: (A, C, ObservableMap<K, B>) -> C): ObservableMap<K, out B>

foldToObservableMap takes an rx.Observable stream and creates an ObservableMap out of it, while maintaining an accumulator.

foldToObservableValue fun <A, B> <ERROR CLASS><A>.foldToObservableValue(initial: B, folderFun: (A, B) -> B): ObservableValue<B>

foldToObservableValue takes an rx.Observable stream and creates an ObservableValue out of it.

lift fun <A> A.lift(): ObservableValue<A>

val aliceHeight: ObservableValue = (..) val bobHeight: ObservableValue = (..) fun sumHeight(a: Long, b: Long): Long { .. }

recordAsAssociation fun <A, K> <ERROR CLASS><A>.recordAsAssociation(toKey: (A) -> K, merge: (K, A, A) -> A = { _key, _oldValue, newValue -> newValue }): ObservableMap<K, out A>

This variant simply associates each event with its key.

recordInSequence fun <A> <ERROR CLASS><A>.recordInSequence(): ObservableList<A>

recordInSequence records incoming events on the rx.Observable in sequence.