AssociatedList creates an ObservableMap from an ObservableList by associating each list element with a unique key.
+It is
An attachment is a ZIP (or an optionally signed JAR) that contains one or more files. Attachments are meant to @@ -331,6 +339,21 @@ the same transaction.
An object used to fully qualify the CashSchema family name (i.e. independent of version).
+First version of a cash contract ORM schema that maps all fields of the Cash contract state as it stood +at the time of writing.
+This check the certificatePath for certificates required to connect to the Corda network. @@ -410,12 +433,6 @@ provided directly by this clause.
Command data/content plus pubkey pair: the signature is stored at the end of the serialized bytes
@@ -466,6 +489,21 @@ provided directly by this clause.An object used to fully qualify the CommercialPaperSchema family name (i.e. independent of version).
+First version of a commercial paper contract ORM schema that maps all fields of the CommercialPaper contract state +as it stood at the time of writing.
+Class representing a commodity, as an equivalent to the Currency class. This exists purely to enable the @@ -492,6 +530,14 @@ internal accounting by the issuer (it might be, for example, a warehouse and/or
ConcatenatedList takes a list of lists and concatenates them. Any change to the underlying lists or the outer list +is propagated as expected.
+Primary purpose is to install Kotlin extensions for Jackson ObjectMapper so data classes work @@ -500,6 +546,12 @@ and to organise serializers / deserializers for java.time.* classes as necessary
RPC operations that the node exposes to clients using the Java client library. These can be called from client apps and are implemented by the node in the ServerRPCOps class.
@@ -605,6 +657,13 @@ client apps and are implemented by the node in the ServerRPCOpsSimple checkpoint key value storage in DB using the underlying JDBCHashMap and transactional context of the call sites.
+Accepts binary streams, finds the right AcceptsFileUpload implementor and hands the stream off to it.
@@ -666,18 +725,6 @@ implementation of general protocols that manipulate many agreement types.Marker interface for kotlin object definitions so that they are deserialized as the singleton instance.
@@ -685,6 +732,12 @@ implementation of general protocols that manipulate many agreement types.A wrapper around a digital signature. The covering field is a generic tag usable by whatever is interpreting the @@ -694,16 +747,6 @@ building partially signed transactions.
A message which specifies reply destination as a specific endpoint such as a monitoring client. This is of particular -use where we want to address a specific endpoint, not necessarily a specific user (for example if the same user logs -in on two machines, we want to consistently deliver messages as part of a session, to the same machine the session -started on).
-Filter the states that are passed through to the wrapped clause, to restrict them to a specific type.
+Finalise a transaction by notarising it, then recording it locally, and then sending it to all involved parties.
@@ -936,7 +986,7 @@ Assumes that the rate is valid.This is a temporary handler required for establishing random sessionIDs for the Fixer and Floater as part of +
This is a temporary handler required for establishing random sessionIDs for the Fixer and Floater as part of running scheduled fixings for the InterestRateSwap contract.
This model provides an observable list of states relating to the creation of a transaction not yet on ledger.
-This model provides an observable list of transactions and what state machines/protocols recorded them
A Handshake message is sent to initiate communication between two protocol instances. It contains the two session IDs -the two protocols will need to communicate. -Note: This is a temperary interface and will be removed once the protocol session work is implemented.
+A vault observer that extracts Object Relational Mappings for contract states that support it, and persists them with Hibernate.
This is a temporary in-memory storage of a state machine id -> txhash mapping
+A dummy Uniqueness provider that stores the whole history of consumed states in memory
@@ -1260,6 +1303,12 @@ quantifiable with integer quantities.LeftOuterJoinedMap implements a special case of a left outer join where were matching on primary keys of both +tables.
+Interpolates values between the given data points using straight lines.
@@ -1362,6 +1419,13 @@ call out to a hardware security module that enforces various auditing and frequeColumnType for marshalling to/from database on behalf of java.time.LocalDate.
+A configuration helper that allows modifying the log level for specific loggers
@@ -1375,6 +1439,31 @@ call out to a hardware security module that enforces various auditing and frequeMapValuesList takes an ObservableMap and returns its values as an ObservableList. +The order of returned elements is deterministic but unspecified.
+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.
+A database schema that might be configured for this node. As well as a name and version for identifying the schema, +also list the classes that may be used in the generated object graph in order to configure the ORM tool.
+Used in the RPC wire protocol to wrap an observation with the handle of the observable its intended for.
@@ -1606,12 +1695,6 @@ loads important data off disk and starts listening for connections.Info about a network node that acts on behalf of some form of contract party.
@@ -1642,24 +1725,9 @@ Artemis is a message queue broker and here we run a client connecting to the speThis model exposes raw event streams to and from the NodeMonitorService through a NodeMonitorClient
-Service which allows external clients to monitor the nodes vault and state machine manager, as well as trigger -actions within the node. The service also sends requests for user input back to clients, for example to enter -additional information while a protocol runs, or confirm an action.
+This model exposes raw event streams to and from the node.
Most basic implementation of SchemaService.
+Currently, the node vault service is a very simple RDBMS backed implementation. It will change significantly when @@ -1784,6 +1859,12 @@ to be netted/merged, with settlement only for any remainder amount.
PartiallyResolvedTransaction holds a SignedTransaction that has zero or more inputs resolved. The intent is +to prepare clients for cases where an input can only be resolved in the future/cannot be resolved at all (for example +because of permissioning)
+A Party is well known (name, pubkey) pair. In a real system this would probably be an X.509 certificate.
@@ -1856,13 +1946,13 @@ ledger. The reference is intended to be encrypted so its meaningless to anyone oA super class for all mapped states exported to a schema that ensures the StateRef appears on the database row. The +StateRef will be set to the correct value by the framework (theres no need to set during mapping generation by the state itself).
+Embedded StateRef representation used in state mapping.
+A RDBMS backed Uniqueness provider
@@ -1972,6 +2077,12 @@ a singleton).The interface of ProtocolStateMachineImpl exposing methods and properties required by ProtocolLogic for compilation.
+A ProtocolStateMachine instance is a suspendable fiber that delegates all actual logic to a ProtocolLogic instance. +For any given flow there is only one PSM, even if that protocol invokes subprotocols.
A ProtocolStateMachine instance is a suspendable fiber that delegates all actual logic to a ProtocolLogic instance. -For any given flow there is only one PSM, even if that protocol invokes subprotocols.
ColumnType for marshalling to/from database on behalf of PublicKey.
+A tree data structure that enables the representation of composite public keys.
+A contract state that may be mapped to database schemas configured for this node to support querying for, +or filtering of, states.
+Intended to service transient clients only (not p2p nodes) for short-lived, transient request/response pairs. @@ -2137,6 +2275,14 @@ for each step.
ReadOnlyBackedObservableMapBase is a base class implementing all abstract functions required for an ObservableMap +using a backing HashMap that subclasses should modify.
+Thread-safe storage of transactions.
@@ -2171,18 +2317,6 @@ e.g. LIBOR 6M as of 17 March 2016. Hence it requires a source (name) and a valuePlaceholder interface for regulator services.
@@ -2190,6 +2324,14 @@ e.g. LIBOR 6M as of 17 March 2016. Hence it requires a source (name) and a valueThis list type just replays changes propagated from the underlying source list. Used for testing changes and backing a +non-backed observable
+A configuration and customisation point for Object Relational Mapping of contract state objects.
+Container for a cryptographically secure hash value. @@ -2279,6 +2434,13 @@ Provides utilities for generating a cryptographic hash using different algorithm
ColumnType for marshalling to/from database on behalf of SecureHash.
+Information for an advertised service including the service specific identity information. +The identity can be used in protocols and is distinct from the Nodes legalIdentity
+A service hub simply vends references to the other services a node has. Some of those services may be missing or @@ -2371,17 +2541,16 @@ functionality and you dont want to hard-code which types in the interface.
Abstract superclass for request messages sent to services, which includes common -fields such as replyTo and sessionID.
+A container for additional information for an advertised service.
Events triggered by changes in the node, and sent to monitoring client(s).
+Abstract superclass for request messages sent to services which expect a reply.
A StateMachineManager is responsible for coordination and persistence of multiple ProtocolStateMachine objects. @@ -2487,12 +2668,38 @@ Each such object represents an instantiation of a (two-party) protocol that has
This is the interface to storage storing state machine -> recorded tx mappings. Any time a transaction is recorded +during a protocol run addMapping should be called.
+A stateref is a pointer (reference) to a state, this is an equivalent of an "outpoint" in Bitcoin. It records which @@ -2501,6 +2708,12 @@ transaction defined the state and where in that transaction it was.
Extremely rudimentary query language which should most likely be replaced with a product.
@@ -2554,6 +2755,20 @@ anything like that, this interface is only big enough to support the prototypingA relatively close copy of the ThreadLocalTransactionManager in Exposed but with the following adjustments to suit +our environment:
+ColumnType for marshalling to/from database on behalf of UUID, always using a string representation.
+This class provides a truly unique identifier of a trade, state, or other business object.
diff --git a/docs/build/html/api/com.r3corda.client.fxutils/-aggregated-list/-init-.html b/docs/build/html/api/com.r3corda.client.fxutils/-aggregated-list/-init-.html index 1d84b729d6..de1cb3e24b 100644 --- a/docs/build/html/api/com.r3corda.client.fxutils/-aggregated-list/-init-.html +++ b/docs/build/html/api/com.r3corda.client.fxutils/-aggregated-list/-init-.html @@ -13,7 +13,10 @@Changes done to elements of the input list are reflected in the observable list of the respective group, whereas additions/removals of elements in the underlying list are reflected in the exposed ObservableList<A> by adding/deleting aggregations as expected.
-The ordering of the exposed list is based on the hashCode of keys.
+The ordering of the exposed list is based on the hashCode of keys. +The ordering of the groups themselves is based on the hashCode of elements.
+Warning: If there are two elements E in the source list that have the same hashCode then it is not deterministic +which one will be removed if one is removed from the source list
Example:
val statesGroupedByCurrency = AggregatedList(states, { state -> state.currency }) { currency, group ->
object {
diff --git a/docs/build/html/api/com.r3corda.client.fxutils/-aggregated-list/index.html b/docs/build/html/api/com.r3corda.client.fxutils/-aggregated-list/index.html
index f84492aa58..42f9902162 100644
--- a/docs/build/html/api/com.r3corda.client.fxutils/-aggregated-list/index.html
+++ b/docs/build/html/api/com.r3corda.client.fxutils/-aggregated-list/index.html
@@ -7,13 +7,16 @@
com.r3corda.client.fxutils / AggregatedList
class AggregatedList<A, E, K : Any> : TransformationList<A, E>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.
Changes done to elements of the input list are reflected in the observable list of the respective group, whereas additions/removals of elements in the underlying list are reflected in the exposed ObservableList<A> by adding/deleting aggregations as expected.
-The ordering of the exposed list is based on the hashCode of keys.
+The ordering of the exposed list is based on the hashCode of keys. +The ordering of the groups themselves is based on the hashCode of elements.
+Warning: If there are two elements E in the source list that have the same hashCode then it is not deterministic +which one will be removed if one is removed from the source list
Example: val statesGroupedByCurrency = AggregatedList(states, { state -> state.currency }) { currency, group -> object { @@ -102,9 +105,30 @@ TODO Should we handle this case? It requires additional bookkeeping of sourceInd
fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>data class Person(val height: Long) +val people: ObservableList = (..) +val nameToHeight: ObservableMap<String, Long> = people.associateBy(Person::name) { name, person -> person.height }
+fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>val people: ObservableList = (..) +val nameToPerson: ObservableMap<String, Person> = people.associateBy(Person::name)
+fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>>val people: ObservableList = (..) +val heightToNames: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) { name, person -> person.name }
+fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>val people: ObservableList = (..) +val heightToPeople: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height)
+fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<out A>enum class FilterCriterion { HEIGHT, NAME }
+fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>
enum class FilterCriterion { HEIGHT, NAME } val filterCriterion: ObservableValue = (..) val people: ObservableList = (..) fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .. }
@@ -112,15 +136,36 @@ fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .fun <A, B> ObservableList<out A>.fold(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>val people: ObservableList = (..)
-val concatenatedNames = people.fold("", { names, person -> names + person.name })
+fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>
data class Dog(val owner: Person?) +val dogs: ObservableList = (..) +val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()
+fun <A> ObservableList<A>.first(): ObservableValue<A?>fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>val people: ObservableList = (..) +val concatenatedNames = people.foldObservable("", { names, person -> names + person.name }) val concatenatedNames2 = people.map(Person::name).fold("", String::plus)
fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?>fun <T> List<T>.indexOfOrThrow(item: T): IntReturns the index of the given item or throws IllegalArgumentException if not found.
@@ -128,9 +173,39 @@ val concatenatedNames2 = people.map(Person::name).fold("", String::plus)fun <T, I : Comparable<I>> Iterable<T>.isOrderedAndUnique(extractId: T.() -> I): BooleanDetermine if an iterable data types contents are ordered and unique, based on their Comparable.compareTo +function.
+fun <A> ObservableList<A>.last(): ObservableValue<A?>fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList<B>) -> C): ObservableList<C>data class Person(val name: String, val managerName: String) +val people: ObservableList = (..) +val managerEmployeeMapping: ObservableList<Pair<Person, ObservableList>> = +people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -> Pair(manager, employees) }
+fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, <ERROR CLASS><ObservableList<A>, ObservableList<B>>>data class Person(name: String, favouriteSpecies: Species) +data class Animal(name: String, species: Species) +val people: ObservableList = (..) +val animals: ObservableList = (..) +val peopleToFavouriteAnimals: ObservableMap<Species, Pair<ObservableList, ObservableList>> = +people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)
+fun <A, B> ObservableList<out A>.map(function: (A) -> B): ObservableList<B>val dogs: ObservableList = (..)
+fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList<B>
val dogs: ObservableList = (..) val dogOwners: ObservableList = dogs.map { it.owner }
AssociatedList(sourceList: ObservableList<out A>, toKey: (A) -> K, assemble: (K, A) -> B)AssociatedList creates an ObservableMap from an ObservableList by associating each list element with a unique key.
+It is
sourceList - The source list.toKey - Function returning the key.assemble - The function to assemble the final map element from the list element and the associated key.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
sourceList - The source list.toKey - Function returning the key.assemble - The function to assemble the final map element from the list element and the associated key.| +<init> | +
+AssociatedList(sourceList: ObservableList<out A>, toKey: (A) -> K, assemble: (K, A) -> B)AssociatedList creates an ObservableMap from an ObservableList by associating each list element with a unique key.
+It is |
+
| +sourceList | +
+val sourceList: ObservableList<out A> |
+
| +backingMap | +
+val backingMap: HashMap<K, <ERROR CLASS><A, B>> |
+
| +entries | +
+open val entries: MutableSet<MutableEntry<K, A>> |
+
| +keys | +
+open val keys: MutableSet<K> |
+
| +size | +
+open val size: Int |
+
| +values | +
+open val values: MutableCollection<A> |
+
| +addListener | +
+open fun addListener(listener: InvalidationListener): Unit |
+
| +clear | +
+open fun clear(): Unit |
+
| +isEmpty | +
+open fun isEmpty(): Boolean |
+
| +removeListener | +
+open fun removeListener(listener: InvalidationListener?): Unit |
+
| +createMapChange | +
+fun <A, K> ObservableMap<K, A>.createMapChange(key: K, removedValue: A?, addedValue: A?): Change<K, A> |
+
| +getObservableEntries | +
+fun <K, V> ObservableMap<K, V>.getObservableEntries(): ObservableList<Entry<K, V>>val nameToPerson: ObservableMap<String, Person> = (..) +val people: ObservableList = nameToPerson.getObservableValues() + |
+
| +getObservableValue | +
+fun <K, V> ObservableMap<K, V>.getObservableValue(key: K): ObservableValue<V?>val nameToPerson: ObservableMap<String, Person> = (..) +val john: ObservableValue<Person?> = nameToPerson.getObservableValue("John") + |
+
| +getObservableValues | +
+fun <K, V> ObservableMap<K, V>.getObservableValues(): ObservableList<V>val nameToPerson: ObservableMap<String, Person> = (..) +val people: ObservableList = nameToPerson.getObservableValues() + |
+
val sourceList: ObservableList<out A>fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>data class Person(val height: Long) +val people: ObservableList = (..) +val nameToHeight: ObservableMap<String, Long> = people.associateBy(Person::name) { name, person -> person.height }
+fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>val people: ObservableList = (..) +val nameToPerson: ObservableMap<String, Person> = people.associateBy(Person::name)
+fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>>val people: ObservableList = (..) +val heightToNames: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) { name, person -> person.name }
+fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>val people: ObservableList = (..) +val heightToPeople: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height)
+fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<out A>enum class FilterCriterion { HEIGHT, NAME }
+fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>
enum class FilterCriterion { HEIGHT, NAME } val filterCriterion: ObservableValue = (..) val people: ObservableList = (..) fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .. }
@@ -72,15 +93,36 @@ fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .fun <A, B> ObservableList<out A>.fold(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>val people: ObservableList = (..)
-val concatenatedNames = people.fold("", { names, person -> names + person.name })
+fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>
data class Dog(val owner: Person?) +val dogs: ObservableList = (..) +val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()
+fun <A> ObservableList<A>.first(): ObservableValue<A?>fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>val people: ObservableList = (..) +val concatenatedNames = people.foldObservable("", { names, person -> names + person.name }) val concatenatedNames2 = people.map(Person::name).fold("", String::plus)
fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?>fun <T> List<T>.indexOfOrThrow(item: T): IntReturns the index of the given item or throws IllegalArgumentException if not found.
@@ -88,9 +130,39 @@ val concatenatedNames2 = people.map(Person::name).fold("", String::plus)fun <T, I : Comparable<I>> Iterable<T>.isOrderedAndUnique(extractId: T.() -> I): BooleanDetermine if an iterable data types contents are ordered and unique, based on their Comparable.compareTo +function.
+fun <A> ObservableList<A>.last(): ObservableValue<A?>fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList<B>) -> C): ObservableList<C>data class Person(val name: String, val managerName: String) +val people: ObservableList = (..) +val managerEmployeeMapping: ObservableList<Pair<Person, ObservableList>> = +people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -> Pair(manager, employees) }
+fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, <ERROR CLASS><ObservableList<A>, ObservableList<B>>>data class Person(name: String, favouriteSpecies: Species) +data class Animal(name: String, species: Species) +val people: ObservableList = (..) +val animals: ObservableList = (..) +val peopleToFavouriteAnimals: ObservableMap<Species, Pair<ObservableList, ObservableList>> = +people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)
+fun <A, B> ObservableList<out A>.map(function: (A) -> B): ObservableList<B>val dogs: ObservableList = (..)
+fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList<B>
val dogs: ObservableList = (..) val dogOwners: ObservableList = dogs.map { it.owner }
ConcatenatedList(sourceList: ObservableList<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.
+fun getSourceIndex(index: Int): Intfun get(index: Int): Aclass 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.
+| +<init> | +
+ConcatenatedList(sourceList: ObservableList<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. + |
+
| +size | +
+val size: Int |
+
| +get | +
+fun get(index: Int): A |
+
| +getSourceIndex | +
+fun getSourceIndex(index: Int): Int |
+
| +sourceChanged | +
+fun sourceChanged(change: Change<out ObservableList<A>>): Unit |
+
| +associateBy | +
+fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>data class Person(val height: Long) +val people: ObservableList = (..) +val nameToHeight: ObservableMap<String, Long> = people.associateBy(Person::name) { name, person -> person.height } +fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>val people: ObservableList = (..) +val nameToPerson: ObservableMap<String, Person> = people.associateBy(Person::name) + |
+
| +associateByAggregation | +
+fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>>val people: ObservableList = (..) +val heightToNames: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) { name, person -> person.name } +fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>val people: ObservableList = (..) +val heightToPeople: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) + |
+
| +filter | +
+fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>enum class FilterCriterion { HEIGHT, NAME } +val filterCriterion: ObservableValue = (..) +val people: ObservableList = (..) +fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .. } + |
+
| +filterNotNull | +
+fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>data class Dog(val owner: Person?) +val dogs: ObservableList = (..) +val owners: ObservableList = dogs.map(Dog::owner).filterNotNull() + |
+
| +first | +
+fun <A> ObservableList<A>.first(): ObservableValue<A?> |
+
| +foldObservable | +
+fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>val people: ObservableList = (..) +val concatenatedNames = people.foldObservable("", { names, person -> names + person.name }) +val concatenatedNames2 = people.map(Person::name).fold("", String::plus) + |
+
| +getValueAt | +
+fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?> |
+
| +indexOfOrThrow | +
+fun <T> List<T>.indexOfOrThrow(item: T): IntReturns the index of the given item or throws IllegalArgumentException if not found. + |
+
| +isOrderedAndUnique | +
+fun <T, I : Comparable<I>> Iterable<T>.isOrderedAndUnique(extractId: T.() -> I): BooleanDetermine if an iterable data types contents are ordered and unique, based on their Comparable.compareTo +function. + |
+
| +last | +
+fun <A> ObservableList<A>.last(): ObservableValue<A?> |
+
| +leftOuterJoin | +
+fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList<B>) -> C): ObservableList<C>data class Person(val name: String, val managerName: String) +val people: ObservableList = (..) +val managerEmployeeMapping: ObservableList<Pair<Person, ObservableList>> = +people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -> Pair(manager, employees) } +fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, <ERROR CLASS><ObservableList<A>, ObservableList<B>>>data class Person(name: String, favouriteSpecies: Species) +data class Animal(name: String, species: Species) +val people: ObservableList = (..) +val animals: ObservableList = (..) +val peopleToFavouriteAnimals: ObservableMap<Species, Pair<ObservableList, ObservableList>> = +people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species) + |
+
| +map | +
+fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList<B>val dogs: ObservableList = (..) +val dogOwners: ObservableList = dogs.map { it.owner } + |
+
| +noneOrSingle | +
+fun <T> Iterable<T>.noneOrSingle(predicate: (T) -> Boolean): T?Returns the single element matching the given predicate, or fun <T> Iterable<T>.noneOrSingle(): T?Returns single element, or |
+
val size: Intprotected fun sourceChanged(change: Change<out ObservableList<A>>): Unitfun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>data class Person(val height: Long) +val people: ObservableList = (..) +val nameToHeight: ObservableMap<String, Long> = people.associateBy(Person::name) { name, person -> person.height }
+fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>val people: ObservableList = (..) +val nameToPerson: ObservableMap<String, Person> = people.associateBy(Person::name)
+fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>>val people: ObservableList = (..) +val heightToNames: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) { name, person -> person.name }
+fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>val people: ObservableList = (..) +val heightToPeople: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height)
+fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<out A>enum class FilterCriterion { HEIGHT, NAME }
+fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>
enum class FilterCriterion { HEIGHT, NAME } val filterCriterion: ObservableValue = (..) val people: ObservableList = (..) fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .. }
@@ -100,15 +121,36 @@ fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .fun <A, B> ObservableList<out A>.fold(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>val people: ObservableList = (..)
-val concatenatedNames = people.fold("", { names, person -> names + person.name })
+fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>
data class Dog(val owner: Person?) +val dogs: ObservableList = (..) +val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()
+fun <A> ObservableList<A>.first(): ObservableValue<A?>fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>val people: ObservableList = (..) +val concatenatedNames = people.foldObservable("", { names, person -> names + person.name }) val concatenatedNames2 = people.map(Person::name).fold("", String::plus)
fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?>fun <T> List<T>.indexOfOrThrow(item: T): IntReturns the index of the given item or throws IllegalArgumentException if not found.
@@ -116,9 +158,39 @@ val concatenatedNames2 = people.map(Person::name).fold("", String::plus)fun <T, I : Comparable<I>> Iterable<T>.isOrderedAndUnique(extractId: T.() -> I): BooleanDetermine if an iterable data types contents are ordered and unique, based on their Comparable.compareTo +function.
+fun <A> ObservableList<A>.last(): ObservableValue<A?>fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList<B>) -> C): ObservableList<C>data class Person(val name: String, val managerName: String) +val people: ObservableList = (..) +val managerEmployeeMapping: ObservableList<Pair<Person, ObservableList>> = +people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -> Pair(manager, employees) }
+fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, <ERROR CLASS><ObservableList<A>, ObservableList<B>>>data class Person(name: String, favouriteSpecies: Species) +data class Animal(name: String, species: Species) +val people: ObservableList = (..) +val animals: ObservableList = (..) +val peopleToFavouriteAnimals: ObservableMap<Species, Pair<ObservableList, ObservableList>> = +people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)
+fun <A, B> ObservableList<out A>.map(function: (A) -> B): ObservableList<B>val dogs: ObservableList = (..)
+fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList<B>
val dogs: ObservableList = (..) val dogOwners: ObservableList = dogs.map { it.owner }
LeftOuterJoinedMap(leftTable: ObservableMap<K, out A>, rightTable: ObservableMap<K, out B>, assemble: (K, A, ObservableValue<B?>) -> C)LeftOuterJoinedMap implements a special case of a left outer join where were matching on primary keys of both +tables.
+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.
+| +<init> | +
+LeftOuterJoinedMap(leftTable: ObservableMap<K, out A>, rightTable: ObservableMap<K, out B>, assemble: (K, A, ObservableValue<B?>) -> C)LeftOuterJoinedMap implements a special case of a left outer join where were matching on primary keys of both +tables. + |
+
| +leftTable | +
+val leftTable: ObservableMap<K, out A> |
+
| +rightTable | +
+val rightTable: ObservableMap<K, out B> |
+
| +backingMap | +
+val backingMap: HashMap<K, <ERROR CLASS><A, B>> |
+
| +entries | +
+open val entries: MutableSet<MutableEntry<K, A>> |
+
| +keys | +
+open val keys: MutableSet<K> |
+
| +size | +
+open val size: Int |
+
| +values | +
+open val values: MutableCollection<A> |
+
| +addListener | +
+open fun addListener(listener: InvalidationListener): Unit |
+
| +clear | +
+open fun clear(): Unit |
+
| +isEmpty | +
+open fun isEmpty(): Boolean |
+
| +removeListener | +
+open fun removeListener(listener: InvalidationListener?): Unit |
+
| +createMapChange | +
+fun <A, K> ObservableMap<K, A>.createMapChange(key: K, removedValue: A?, addedValue: A?): Change<K, A> |
+
| +getObservableEntries | +
+fun <K, V> ObservableMap<K, V>.getObservableEntries(): ObservableList<Entry<K, V>>val nameToPerson: ObservableMap<String, Person> = (..) +val people: ObservableList = nameToPerson.getObservableValues() + |
+
| +getObservableValue | +
+fun <K, V> ObservableMap<K, V>.getObservableValue(key: K): ObservableValue<V?>val nameToPerson: ObservableMap<String, Person> = (..) +val john: ObservableValue<Person?> = nameToPerson.getObservableValue("John") + |
+
| +getObservableValues | +
+fun <K, V> ObservableMap<K, V>.getObservableValues(): ObservableList<V>val nameToPerson: ObservableMap<String, Person> = (..) +val people: ObservableList = nameToPerson.getObservableValues() + |
+
val leftTable: ObservableMap<K, out A>val rightTable: ObservableMap<K, out B>fun <K, A, C> create(sourceMap: ObservableMap<K, A>, assemble: (Entry<K, A>) -> C): MapValuesList<K, A, C>create is the factory of MapValuesList.
+sourceMap - The source map.assemble - The function to be called for map each entry to construct the final list elements.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.
+| +sourceMap | +
+val sourceMap: ObservableMap<K, A> |
+
| +create | +
+fun <K, A, C> create(sourceMap: ObservableMap<K, A>, assemble: (Entry<K, A>) -> C): MapValuesList<K, A, C>create is the factory of MapValuesList. + |
+
| +associateBy | +
+fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>data class Person(val height: Long) +val people: ObservableList = (..) +val nameToHeight: ObservableMap<String, Long> = people.associateBy(Person::name) { name, person -> person.height } +fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>val people: ObservableList = (..) +val nameToPerson: ObservableMap<String, Person> = people.associateBy(Person::name) + |
+
| +associateByAggregation | +
+fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>>val people: ObservableList = (..) +val heightToNames: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) { name, person -> person.name } +fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>val people: ObservableList = (..) +val heightToPeople: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) + |
+
| +filter | +
+fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>enum class FilterCriterion { HEIGHT, NAME } +val filterCriterion: ObservableValue = (..) +val people: ObservableList = (..) +fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .. } + |
+
| +filterNotNull | +
+fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>data class Dog(val owner: Person?) +val dogs: ObservableList = (..) +val owners: ObservableList = dogs.map(Dog::owner).filterNotNull() + |
+
| +first | +
+fun <A> ObservableList<A>.first(): ObservableValue<A?> |
+
| +foldObservable | +
+fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>val people: ObservableList = (..) +val concatenatedNames = people.foldObservable("", { names, person -> names + person.name }) +val concatenatedNames2 = people.map(Person::name).fold("", String::plus) + |
+
| +getValueAt | +
+fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?> |
+
| +indexOfOrThrow | +
+fun <T> List<T>.indexOfOrThrow(item: T): IntReturns the index of the given item or throws IllegalArgumentException if not found. + |
+
| +isOrderedAndUnique | +
+fun <T, I : Comparable<I>> Iterable<T>.isOrderedAndUnique(extractId: T.() -> I): BooleanDetermine if an iterable data types contents are ordered and unique, based on their Comparable.compareTo +function. + |
+
| +last | +
+fun <A> ObservableList<A>.last(): ObservableValue<A?> |
+
| +leftOuterJoin | +
+fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList<B>) -> C): ObservableList<C>data class Person(val name: String, val managerName: String) +val people: ObservableList = (..) +val managerEmployeeMapping: ObservableList<Pair<Person, ObservableList>> = +people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -> Pair(manager, employees) } +fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, <ERROR CLASS><ObservableList<A>, ObservableList<B>>>data class Person(name: String, favouriteSpecies: Species) +data class Animal(name: String, species: Species) +val people: ObservableList = (..) +val animals: ObservableList = (..) +val peopleToFavouriteAnimals: ObservableMap<Species, Pair<ObservableList, ObservableList>> = +people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species) + |
+
| +map | +
+fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList<B>val dogs: ObservableList = (..) +val dogOwners: ObservableList = dogs.map { it.owner } + |
+
| +noneOrSingle | +
+fun <T> Iterable<T>.noneOrSingle(predicate: (T) -> Boolean): T?Returns the single element matching the given predicate, or fun <T> Iterable<T>.noneOrSingle(): T?Returns single element, or |
+
val sourceMap: ObservableMap<K, A>MappedList(list: ObservableList<A>, function: (A) -> B)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.
+val function: (A) -> Bfun getSourceIndex(index: Int): Intfun get(index: Int): Bclass 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.
+| +<init> | +
+MappedList(list: ObservableList<A>, function: (A) -> B)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. + |
+
| +function | +
+val function: (A) -> B |
+
| +size | +
+val size: Int |
+
| +get | +
+fun get(index: Int): B |
+
| +getSourceIndex | +
+fun getSourceIndex(index: Int): Int |
+
| +sourceChanged | +
+fun sourceChanged(change: Change<out A>): Unit |
+
| +associateBy | +
+fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>data class Person(val height: Long) +val people: ObservableList = (..) +val nameToHeight: ObservableMap<String, Long> = people.associateBy(Person::name) { name, person -> person.height } +fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>val people: ObservableList = (..) +val nameToPerson: ObservableMap<String, Person> = people.associateBy(Person::name) + |
+
| +associateByAggregation | +
+fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>>val people: ObservableList = (..) +val heightToNames: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) { name, person -> person.name } +fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>val people: ObservableList = (..) +val heightToPeople: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) + |
+
| +filter | +
+fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>enum class FilterCriterion { HEIGHT, NAME } +val filterCriterion: ObservableValue = (..) +val people: ObservableList = (..) +fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .. } + |
+
| +filterNotNull | +
+fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>data class Dog(val owner: Person?) +val dogs: ObservableList = (..) +val owners: ObservableList = dogs.map(Dog::owner).filterNotNull() + |
+
| +first | +
+fun <A> ObservableList<A>.first(): ObservableValue<A?> |
+
| +foldObservable | +
+fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>val people: ObservableList = (..) +val concatenatedNames = people.foldObservable("", { names, person -> names + person.name }) +val concatenatedNames2 = people.map(Person::name).fold("", String::plus) + |
+
| +getValueAt | +
+fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?> |
+
| +indexOfOrThrow | +
+fun <T> List<T>.indexOfOrThrow(item: T): IntReturns the index of the given item or throws IllegalArgumentException if not found. + |
+
| +isOrderedAndUnique | +
+fun <T, I : Comparable<I>> Iterable<T>.isOrderedAndUnique(extractId: T.() -> I): BooleanDetermine if an iterable data types contents are ordered and unique, based on their Comparable.compareTo +function. + |
+
| +last | +
+fun <A> ObservableList<A>.last(): ObservableValue<A?> |
+
| +leftOuterJoin | +
+fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList<B>) -> C): ObservableList<C>data class Person(val name: String, val managerName: String) +val people: ObservableList = (..) +val managerEmployeeMapping: ObservableList<Pair<Person, ObservableList>> = +people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -> Pair(manager, employees) } +fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, <ERROR CLASS><ObservableList<A>, ObservableList<B>>>data class Person(name: String, favouriteSpecies: Species) +data class Animal(name: String, species: Species) +val people: ObservableList = (..) +val animals: ObservableList = (..) +val peopleToFavouriteAnimals: ObservableMap<Species, Pair<ObservableList, ObservableList>> = +people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species) + |
+
| +map | +
+fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList<B>val dogs: ObservableList = (..) +val dogOwners: ObservableList = dogs.map { it.owner } + |
+
| +noneOrSingle | +
+fun <T> Iterable<T>.noneOrSingle(predicate: (T) -> Boolean): T?Returns the single element matching the given predicate, or fun <T> Iterable<T>.noneOrSingle(): T?Returns single element, or |
+
val size: Intprotected fun sourceChanged(change: Change<out A>): UnitReadOnlyBackedObservableMapBase()ReadOnlyBackedObservableMapBase is a base class implementing all abstract functions required for an ObservableMap +using a backing HashMap that subclasses should modify.
+Non-read-only API calls throw.
+K - The key type.A - The exposed map element type.B - Auxiliary data subclasses may wish to store in the backing map.open fun addListener(listener: InvalidationListener): Unitopen fun addListener(listener: MapChangeListener<in K, in A>?): Unitprotected val backingMap: HashMap<K, <ERROR CLASS><A, B>>open fun clear(): Unitopen fun containsKey(key: K): Booleanopen fun containsValue(value: A): <ERROR CLASS>open val entries: MutableSet<MutableEntry<K, A>>protected fun fireChange(change: Change<out K, out A>): Unitopen fun get(key: K): <ERROR CLASS>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.
+Non-read-only API calls throw.
+K - The key type.A - The exposed map element type.B - Auxiliary data subclasses may wish to store in the backing map.| +<init> | +
+ReadOnlyBackedObservableMapBase()ReadOnlyBackedObservableMapBase is a base class implementing all abstract functions required for an ObservableMap +using a backing HashMap that subclasses should modify. + |
+
| +backingMap | +
+val backingMap: HashMap<K, <ERROR CLASS><A, B>> |
+
| +entries | +
+open val entries: MutableSet<MutableEntry<K, A>> |
+
| +keys | +
+open val keys: MutableSet<K> |
+
| +size | +
+open val size: Int |
+
| +values | +
+open val values: MutableCollection<A> |
+
| +addListener | +
+open fun addListener(listener: InvalidationListener): Unit+ open fun addListener(listener: MapChangeListener<in K, in A>?): Unit |
+
| +clear | +
+open fun clear(): Unit |
+
| +containsKey | +
+open fun containsKey(key: K): Boolean |
+
| +containsValue | +
+open fun containsValue(value: A): <ERROR CLASS> |
+
| +fireChange | +
+fun fireChange(change: Change<out K, out A>): Unit |
+
| +get | +
+open fun get(key: K): <ERROR CLASS> |
+
| +isEmpty | +
+open fun isEmpty(): Boolean |
+
| +put | +
+open fun put(key: K, value: A): A |
+
| +putAll | +
+open fun putAll(from: Map<out K, A>): Unit |
+
| +remove | +
+open fun remove(key: K): A |
+
| +removeListener | +
+open fun removeListener(listener: InvalidationListener?): Unit+ open fun removeListener(listener: MapChangeListener<in K, in A>?): Unit |
+
| +createMapChange | +
+fun <A, K> ObservableMap<K, A>.createMapChange(key: K, removedValue: A?, addedValue: A?): Change<K, A> |
+
| +getObservableEntries | +
+fun <K, V> ObservableMap<K, V>.getObservableEntries(): ObservableList<Entry<K, V>>val nameToPerson: ObservableMap<String, Person> = (..) +val people: ObservableList = nameToPerson.getObservableValues() + |
+
| +getObservableValue | +
+fun <K, V> ObservableMap<K, V>.getObservableValue(key: K): ObservableValue<V?>val nameToPerson: ObservableMap<String, Person> = (..) +val john: ObservableValue<Person?> = nameToPerson.getObservableValue("John") + |
+
| +getObservableValues | +
+fun <K, V> ObservableMap<K, V>.getObservableValues(): ObservableList<V>val nameToPerson: ObservableMap<String, Person> = (..) +val people: ObservableList = nameToPerson.getObservableValues() + |
+
| +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 |
+
| +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. + |
+
open fun isEmpty(): Booleanopen val keys: MutableSet<K>open fun putAll(from: Map<out K, A>): Unitopen fun put(key: K, value: A): Aopen fun removeListener(listener: InvalidationListener?): Unitopen fun removeListener(listener: MapChangeListener<in K, in A>?): Unitopen fun remove(key: K): Aopen val size: Intopen val values: MutableCollection<A>ReplayedList(sourceList: ObservableList<A>)This list type just replays changes propagated from the underlying source list. Used for testing changes and backing a +non-backed observable
+fun getSourceIndex(index: Int): Intfun get(index: Int): Aclass 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
+| +<init> | +
+ReplayedList(sourceList: ObservableList<A>)This list type just replays changes propagated from the underlying source list. Used for testing changes and backing a +non-backed observable + |
+
| +replayedList | +
+val replayedList: ArrayList<A> |
+
| +size | +
+val size: Int |
+
| +get | +
+fun get(index: Int): A |
+
| +getSourceIndex | +
+fun getSourceIndex(index: Int): Int |
+
| +sourceChanged | +
+fun sourceChanged(c: Change<out A>): Unit |
+
| +associateBy | +
+fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>data class Person(val height: Long) +val people: ObservableList = (..) +val nameToHeight: ObservableMap<String, Long> = people.associateBy(Person::name) { name, person -> person.height } +fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>val people: ObservableList = (..) +val nameToPerson: ObservableMap<String, Person> = people.associateBy(Person::name) + |
+
| +associateByAggregation | +
+fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>>val people: ObservableList = (..) +val heightToNames: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) { name, person -> person.name } +fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>val people: ObservableList = (..) +val heightToPeople: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) + |
+
| +filter | +
+fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>enum class FilterCriterion { HEIGHT, NAME } +val filterCriterion: ObservableValue = (..) +val people: ObservableList = (..) +fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .. } + |
+
| +filterNotNull | +
+fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>data class Dog(val owner: Person?) +val dogs: ObservableList = (..) +val owners: ObservableList = dogs.map(Dog::owner).filterNotNull() + |
+
| +first | +
+fun <A> ObservableList<A>.first(): ObservableValue<A?> |
+
| +foldObservable | +
+fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>val people: ObservableList = (..) +val concatenatedNames = people.foldObservable("", { names, person -> names + person.name }) +val concatenatedNames2 = people.map(Person::name).fold("", String::plus) + |
+
| +getValueAt | +
+fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?> |
+
| +indexOfOrThrow | +
+fun <T> List<T>.indexOfOrThrow(item: T): IntReturns the index of the given item or throws IllegalArgumentException if not found. + |
+
| +isOrderedAndUnique | +
+fun <T, I : Comparable<I>> Iterable<T>.isOrderedAndUnique(extractId: T.() -> I): BooleanDetermine if an iterable data types contents are ordered and unique, based on their Comparable.compareTo +function. + |
+
| +last | +
+fun <A> ObservableList<A>.last(): ObservableValue<A?> |
+
| +leftOuterJoin | +
+fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList<B>) -> C): ObservableList<C>data class Person(val name: String, val managerName: String) +val people: ObservableList = (..) +val managerEmployeeMapping: ObservableList<Pair<Person, ObservableList>> = +people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -> Pair(manager, employees) } +fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, <ERROR CLASS><ObservableList<A>, ObservableList<B>>>data class Person(name: String, favouriteSpecies: Species) +data class Animal(name: String, species: Species) +val people: ObservableList = (..) +val animals: ObservableList = (..) +val peopleToFavouriteAnimals: ObservableMap<Species, Pair<ObservableList, ObservableList>> = +people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species) + |
+
| +map | +
+fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList<B>val dogs: ObservableList = (..) +val dogOwners: ObservableList = dogs.map { it.owner } + |
+
| +noneOrSingle | +
+fun <T> Iterable<T>.noneOrSingle(predicate: (T) -> Boolean): T?Returns the single element matching the given predicate, or fun <T> Iterable<T>.noneOrSingle(): T?Returns single element, or |
+
val replayedList: ArrayList<A>val size: Intprotected fun sourceChanged(c: Change<out A>): Unitfun <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.
+initialAccumulator - The initial value of the accumulator.folderFun - The transformation function to be called on the observable list when a new element is emitted on
+the stream, which should modify the list as needed.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.
+initialAccumulator - The initial value of the accumulator.folderFun - The transformation function to be called on the observable map when a new element is emitted on
+the stream, which should modify the map as needed.