net.corda.client.fxutils

## Package net.corda.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.