Regen docsite

docs/build/html/_sources/clientrpc.txt

@@ -15,6 +15,8 @@ detail on how to use this is provided in the docs for the proxy method.
    resources. When you're done with it, cast it to ``Closeable`` or ``AutoCloseable`` and close it. Don't create
    one for every call you make - create a proxy and reuse it.
 
+For a brief tutorial on how one can use the RPC API see :doc:`tutorial-clientrpc-api`.
+
 Observables
 -----------
 
@@ -72,4 +74,4 @@ The client RPC wire protocol is not currently documented. To use it you must use
 This is likely to change in a future release.
 
 .. _CordaRPCClient: api/com.r3corda.client/-corda-r-p-c-client/index.html
-.. _CordaRPCOps: api/com.r3corda.node.services.messaging/-corda-r-p-c-ops.html
+.. _CordaRPCOps: api/com.r3corda.node.services.messaging/-corda-r-p-c-ops/index.html

docs/build/html/_sources/consensus.txt

@@ -42,7 +42,7 @@ will not be regarded as confirmed. After the signature is obtained, the parties
 Hence it is the point at which we can say finality has occurred.
 
 Multiple notaries
------------------
+~~~~~~~~~~~~~~~~~
 
 More than one notary can exist in the network. This gives the following benefits:
 
@@ -56,6 +56,32 @@ This is achieved by using a special type of transaction that doesn't modify anyt
 Ensuring that all input states point to the same notary is the responsibility of each involved party
 (it is another condition for an output state of the transaction to be **valid**)
 
+Changing notaries
+~~~~~~~~~~~~~~~~~
+
+To change the notary for an input state, use the ``NotaryChangeProtocol``. For example:
+
+.. sourcecode:: kotlin
+
+    @Suspendable
+    fun changeNotary(originalState: StateAndRef<ContractState>,
+                     newNotary: Party): StateAndRef<ContractState> {
+        val protocol = NotaryChangeProtocol.Instigator(originalState, newNotary)
+        return subProtocol(protocol)
+    }
+
+The protocol will:
+
+1. Construct a transaction with the old state as the input and the new state as the output
+
+2. Obtain signatures from all *participants* (a participant is any party that is able to consume this state in a valid transaction, as defined by the state itself)
+
+3. Obtain the *old* notary signature
+
+4. Record and distribute the final transaction to the participants so that everyone possesses the new state
+
+.. note:: Eventually this will be handled automatically on demand.
+
 Validation
 ----------
 
@@ -114,7 +140,7 @@ By creating a range that can be either closed or open at one end, we allow all o
 .. note:: It is assumed that the time feed for a notary is GPS/NaviStar time as defined by the atomic
    clocks at the US Naval Observatory. This time feed is extremely accurate and available globally for free.
 
-Running a Notary Service
+Running a notary service
 ------------------------
 
 At present we have two basic implementations that store committed input states in memory:
@@ -167,28 +193,3 @@ On conflict the ``NotaryProtocol`` with throw a ``NotaryException`` containing t
     data class ConsumingTx(val id: SecureHash, val inputIndex: Int, val requestingParty: Party)
 
 Conflict handling and resolution is currently the responsibility of the protocol author.
-
-Changing notaries
------------------
-
-To change the notary for an input state, use the ``NotaryChangeProtocol``. For example:
-
-.. sourcecode:: kotlin
-
-    fun changeNotary(originalState: StateAndRef<ContractState>,
-                     newNotary: Party): StateAndRef<ContractState> {
-        val protocol = NotaryChangeProtocol.Instigator(originalState, newNotary)
-        return subProtocol(protocol)
-    }
-
-The protocol will:
-
-1. Construct a transaction with the old state as the input and the new state as the output
-
-2. Obtain signatures from all *participants* (a participant is any party that is able to consume this state in a valid transaction, as defined by the state itself)
-
-3. Obtain the *old* notary signature
-
-4. Record and distribute the final transaction to the participants so that everyone possesses the new state
-
-.. note:: Eventually this will be handled automatically on demand.

docs/build/html/_sources/corda-configuration-files.txt

@@ -38,7 +38,6 @@ General node configuration file for hosting the IRSDemo services.
     }
     artemisAddress : "localhost:31337"
     webAddress : "localhost:31339"
-    hostNotaryServiceLocally: false
     extraAdvertisedServiceIds: "corda.interest_rates"
     networkMapAddress : "localhost:12345"
     useHTTPS : false
@@ -54,7 +53,6 @@ NetworkMapService plus Simple Notary configuration file.
     trustStorePassword : "trustpass"
     artemisAddress : "localhost:12345"
     webAddress : "localhost:12346"
-    hostNotaryServiceLocally: true
     extraAdvertisedServiceIds: ""
     useHTTPS : false
 
@@ -85,14 +83,15 @@ Configuration File Fields
 
     .. note:: In practice the ArtemisMQ messaging services bind to all local addresses on the specified port. However, note that the host is the included as the advertised entry in the NetworkMapService. As a result the value listed here must be externally accessible when running nodes across a cluster of machines.
 
+:messagingServerAddress:
+    The address of the ArtemisMQ broker instance. If not provided the node will run one locally.
+
 :webAddress:
     The host and port on which the node is available for web operations.
 
     .. note:: If HTTPS is enabled then the browser security checks will require that the accessing url host name is one of either the machine name, fully qualified machine name, or server IP address to line up with the Subject Alternative Names contained within the development certificates. This is addition to requiring the ``/config/dev/corda_dev_ca.cer`` root certificate be installed as a Trusted CA.
 
-:hostNotaryServiceLocally: If true the Node will host and advertise a verifying Notary service.
-
-:extraAdvertisedServiceIds: A list of ServiceType id strings to be advertised to the NetworkMapService and thus be available when other nodes query the NetworkMapCache for supporting nodes. This can also include plugin services loaded from .jar files in the 
+:extraAdvertisedServiceIds: A list of ServiceType id strings to be advertised to the NetworkMapService and thus be available when other nodes query the NetworkMapCache for supporting nodes. This can also include plugin services loaded from .jar files in the plugins folder.
 
 :networkMapAddress: If `null`, or missing the node is declaring itself as the NetworkMapService host. Otherwise the configuration value is the remote HostAndPort string for the ArtemisMQ service on the hosting node.
 

docs/build/html/_sources/creating-a-cordapp.txt

@@ -75,6 +75,50 @@ To enable remote debugging of the corda process use a command line such as:
 
 This command line will start the debugger on port 5005 and pause the process awaiting debugger attachment.
 
+Viewing persisted state of your Node
+------------------------------------
+
+To make examining the persisted contract states of your node or the internal node database tables easier, and providing you are
+using the default database configuration used for demos, you should be able to connect to the internal node database over
+a JDBC connection at the URL that is output to the logs at node start up.  That URL will be of the form ``jdbc:h2:tcp://<host>:<port>/node``.
+
+The user name and password for the login are as per the node data source configuration.
+
+The name and column layout of the internal node tables is in a state of flux and should not be relied upon to remain static
+at the present time, and should certainly be treated as read-only.
+
 .. _CordaPluginRegistry: api/com.r3corda.core.node/-corda-plugin-registry/index.html
 .. _ServiceHubInternal: api/com.r3corda.node.services.api/-service-hub-internal/index.html
-.. _ServiceHub: api/com.r3corda.node.services.api/-service-hub/index.html
+.. _ServiceHub: api/com.r3corda.node.services.api/-service-hub/index.html
+
+Building Against Corda
+----------------------
+
+.. warning:: This feature is subject to rapid change
+
+Corda now supports publishing to Maven local to build against it. To publish to Maven local run the following in the
+root directory of Corda
+
+.. code-block:: shell
+
+    ./gradlew publishToMavenLocal
+
+This will publish corda-$version.jar, contracts-$version.jar, core-$version.jar and node-$version.jar to the
+group com.r3corda. You can now depend on these as you normally would a Maven dependency.
+
+In Gradle you can depend on these by adding/modifying your build.gradle file to contain the following:
+
+.. code-block:: groovy
+
+    repositories {
+        mavenLocal()
+        ... other repositories here ...
+    }
+
+    dependencies {
+        compile "com.r3corda:core:$corda_version"
+        compile "com.r3corda:contracts:$corda_version"
+        compile "com.r3corda:node:$corda_version"
+        compile "com.r3corda:corda:$corda_version"
+        ... other dependencies here ...
+    }

docs/build/html/_sources/index.txt

@@ -34,6 +34,7 @@ Read on to learn:
    transaction-data-types
    consensus
    messaging
+   persistence
    creating-a-cordapp
    running-the-demos
    node-administration
@@ -47,8 +48,10 @@ Read on to learn:
    tutorial-contract
    tutorial-contract-clauses
    tutorial-test-dsl
+   tutorial-clientrpc-api
    protocol-state-machines
    oracles
+   tutorial-attachments
    event-scheduling
    secure-coding-guidelines
 
@@ -74,4 +77,3 @@ Read on to learn:
    network-simulator
    codestyle
    building-the-docs
-

docs/build/html/_sources/node-administration.txt

@@ -1,8 +1,23 @@
 Node administration
 ===================
 
-When a node is running, it exposes an embedded web server that lets you monitor it, upload and download attachments,
-access a REST API and so on.
+When a node is running, it exposes an embedded database server, an embedded web server that lets you monitor it,
+you can upload and download attachments, access a REST API and so on.
+
+Database access
+---------------
+
+The node exposes its internal database over a socket which can be browsed using any tool that can use JDBC drivers.
+The JDBC URL is printed during node startup to the log and will typically look like this:
+
+     ``jdbc:h2:tcp://192.168.0.31:31339/node``
+
+The username and password can be altered in the :doc:`corda-config-files` but default to username "sa" and a blank
+password.
+
+Any database browsing tool that supports JDBC can be used, but if you have IntelliJ Ultimate edition then there is
+a tool integrated with your IDE. Just open the database window and add an H2 data source with the above details.
+You will now be able to browse the tables and row data within them.
 
 Monitoring your node
 --------------------
@@ -15,7 +30,7 @@ some monitoring systems provide a "Java Agent", which is essentially a JVM plugi
 them out to a statistics collector over the network. For those systems, follow the instructions provided by the vendor.
 
 Sometimes though, you just want raw access to the data and operations itself. So nodes export them over HTTP on the
-`/monitoring/json` HTTP endpoint, using a program called `Jolokia <https://jolokia.org/>`_. Jolokia defines the JSON
+``/monitoring/json`` HTTP endpoint, using a program called `Jolokia <https://jolokia.org/>`_. Jolokia defines the JSON
 and REST formats for accessing MBeans, and provides client libraries to work with that protocol as well.
 
 Here are a few ways to build dashboards and extract monitoring data for a node:

docs/build/html/_sources/persistence.txt

@@ -0,0 +1,89 @@
+Persistence
+===========
+
+Corda offers developers the option to expose all or some part of a contract state to an *Object Relational Mapping* (ORM) tool
+to be persisted in a RDBMS.  The purpose of this is to assist *vault* development by effectively indexing
+persisted contract states held in the vault for the purpose of running queries over them and to allow relational joins
+between Corda data and private data local to the organisation owning a node.
+
+The ORM mapping is specified using the `Java Persistence API <https://en.wikipedia.org/wiki/Java_Persistence_API>`_ (JPA)
+as annotations and is converted to database table rows by the node automatically every time a state is recorded in the
+node's local vault as part of a transaction.
+
+.. note:: Presently the node includes an instance of the H2 database but any database that supports JDBC is a candidate and
+   the node will in the future support a range of database implementations via their JDBC drivers.  Much of the node
+   internal state is also persisted there. You can access the internal H2 database via JDBC, please see the info
+   in ":doc:`node-administration`" for details.
+
+Schemas
+-------
+
+Every ``ContractState`` can implement the ``QueryableState`` interface if it wishes to be inserted into the node's local
+database and accessible using SQL.
+
+.. literalinclude:: ../../core/src/main/kotlin/com/r3corda/core/schemas/PersistentTypes.kt
+    :language: kotlin
+    :start-after: DOCSTART QueryableState
+    :end-before: DOCEND QueryableState
+
+The ``QueryableState`` interface requires the state to enumerate the different relational schemas it supports, for instance in
+cases where the schema has evolved, with each one being represented by a ``MappedSchema`` object return by the
+``supportedSchemas()`` method.  Once a schema is selected it must generate that representation when requested via the
+``generateMappedObject()`` method which is then passed to the ORM.
+
+Nodes have an internal ``SchemaService`` which decides what to persist and what not by selecting the ``MappedSchema``
+to use.
+
+.. literalinclude:: ../../node/src/main/kotlin/com/r3corda/node/services/api/SchemaService.kt
+    :language: kotlin
+    :start-after: DOCSTART SchemaService
+    :end-before: DOCEND SchemaService
+
+.. literalinclude:: ../../core/src/main/kotlin/com/r3corda/core/schemas/PersistentTypes.kt
+    :language: kotlin
+    :start-after: DOCSTART MappedSchema
+    :end-before: DOCEND MappedSchema
+
+The ``SchemaService`` can be configured by a node administrator to select the schemas used by each app. In this way the
+relational view of ledger states can evolve in a controlled fashion in lock-step with internal systems or other
+integration points and not necessarily with every upgrade to the contract code.
+It can select from the ``MappedSchema`` offered by a ``QueryableState``, automatically upgrade to a
+later version of a schema or even provide a ``MappedSchema`` not originally offered by the ``QueryableState``.
+
+It is expected that multiple different contract state implementations might provide mappings to some common schema.
+For example an Interest Rate Swap contract and an Equity OTC Option contract might both provide a mapping to a common
+Derivative schema. The schemas should typically not be part of the contract itself and should exist independently of it
+to encourage re-use of a common set within a particular business area or Cordapp.
+
+``MappedSchema`` offer a family name that is disambiguated using Java package style name-spacing derived from the class name
+of a *schema family* class that is constant across versions, allowing the ``SchemaService`` to select a preferred version
+of a schema.
+
+The ``SchemaService`` is also responsible for the ``SchemaOptions`` that can be configured for a particular ``MappedSchema``
+which allow the configuration of a database schema or table name prefixes to avoid any clash with other ``MappedSchema``.
+
+.. note:: It is intended that there should be plugin support for the ``SchemaService`` to offer the version upgrading and
+   additional schemas as part of Cordapps, and that the active schemas be confgurable.  However the present implementation
+   offers none of this and simply results in all versions of all schemas supported by a ``QueryableState`` being persisted.
+   This will change in due course.  Similarly, it does not currently support configuring ``SchemaOptions`` but will do so in
+   the future.
+
+Object Relational Mapping
+-------------------------
+
+The persisted representation of a ``QueryableState`` should be an instance of a ``PersistentState`` subclass, constructed
+either by the state itself or a plugin to the ``SchemaService``.  This allows the ORM layer to always associate a
+``StateRef`` with a persisted representation of a ``ContractState`` and allows joining with the set of unconsumed states
+in the vault.
+
+The ``PersistentState`` subclass should be marked up as a JPA 2.1 *Entity* with a defined table name and having
+properties (in Kotlin, getters/setters in Java) annotated to map to the appropriate columns and SQL types.  Additional
+entities can be included to model these properties where they are more complex, for example collections, so the mapping
+does not have to be *flat*. The ``MappedSchema`` must provide a list of all of the JPA entity classes for that schema in order
+to initialise the ORM layer.
+
+Several examples of entities and mappings are provided in the codebase, including ``Cash.State`` and
+``CommercialPaper.State``.  For example, here's the first version of the cash schema.
+
+.. literalinclude:: ../../contracts/src/main/kotlin/com/r3corda/schemas/CashSchemaV1.kt
+    :language: kotlin

docs/build/html/_sources/protocol-state-machines.txt

@@ -91,7 +91,7 @@ Our protocol has two parties (B and S for buyer and seller) and will proceed as
    it lacks a signature from S authorising movement of the asset.
 3. S signs it and hands the now finalised ``SignedTransaction`` back to B.
 
-You can find the implementation of this protocol in the file ``contracts/protocols/TwoPartyTradeProtocol.kt``.
+You can find the implementation of this protocol in the file ``contracts/src/main/kotlin/com/r3corda/protocols/TwoPartyTradeProtocol.kt``.
 
 Assuming no malicious termination, they both end the protocol being in posession of a valid, signed transaction that
 represents an atomic asset swap.
@@ -110,7 +110,6 @@ each side.
    .. sourcecode:: kotlin
 
       object TwoPartyTradeProtocol {
-          val TOPIC = "platform.trade"
 
           class UnacceptablePriceException(val givenPrice: Amount<Currency>) : Exception("Unacceptable price: $givenPrice")
           class AssetMismatchException(val expectedTypeName: String, val typeName: String) : Exception() {
@@ -118,21 +117,20 @@ each side.
           }
 
           // This object is serialised to the network and is the first protocol message the seller sends to the buyer.
-          class SellerTradeInfo(
+          data class SellerTradeInfo(
                   val assetForSale: StateAndRef<OwnableState>,
-                  val price: Amount,
-                  val sellerOwnerKey: PublicKey,
-                  val sessionID: Long
+                  val price: Amount<Currency>,
+                  val sellerOwnerKey: PublicKey
           )
 
-          class SignaturesFromSeller(val timestampAuthoritySig: DigitalSignature.WithKey, val sellerSig: DigitalSignature.WithKey)
+          data class SignaturesFromSeller(val sellerSig: DigitalSignature.WithKey,
+                                          val notarySig: DigitalSignature.LegallyIdentifiable)
 
           open class Seller(val otherSide: Party,
                             val notaryNode: NodeInfo,
                             val assetToSell: StateAndRef<OwnableState>,
                             val price: Amount<Currency>,
                             val myKeyPair: KeyPair,
-                            val buyerSessionID: Long,
                             override val progressTracker: ProgressTracker = Seller.tracker()) : ProtocolLogic<SignedTransaction>() {
               @Suspendable
               override fun call(): SignedTransaction {
@@ -143,8 +141,7 @@ each side.
           open class Buyer(val otherSide: Party,
                            val notary: Party,
                            val acceptablePrice: Amount<Currency>,
-                           val typeToBuy: Class<out OwnableState>,
-                           val sessionID: Long) : ProtocolLogic<SignedTransaction>() {
+                           val typeToBuy: Class<out OwnableState>) : ProtocolLogic<SignedTransaction>() {
               @Suspendable
               override fun call(): SignedTransaction {
                   TODO()
@@ -152,25 +149,17 @@ each side.
           }
       }
 
-Let's unpack what this code does:
-
-- It defines a several classes nested inside the main ``TwoPartyTradeProtocol`` singleton. Some of the classes
-  are simply protocol messages or exceptions. The other two represent the buyer and seller side of the protocol.
-- It defines the "trade topic", which is just a string that namespaces this protocol. The prefix "platform." is reserved
-  by Corda, but you can define your own protocol namespaces using standard Java-style reverse DNS notation.
+This code defines several classes nested inside the main ``TwoPartyTradeProtocol`` singleton. Some of the classes are
+simply protocol messages or exceptions. The other two represent the buyer and seller side of the protocol.
 
 Going through the data needed to become a seller, we have:
 
-- ``otherSide: SingleMessageRecipient`` - the network address of the node with which you are trading.
+- ``otherSide: Party`` - the party with which you are trading.
 - ``notaryNode: NodeInfo`` - the entry in the network map for the chosen notary. See ":doc:`consensus`" for more
   information on notaries.
 - ``assetToSell: StateAndRef<OwnableState>`` - a pointer to the ledger entry that represents the thing being sold.
 - ``price: Amount<Currency>`` - the agreed on price that the asset is being sold for (without an issuer constraint).
 - ``myKeyPair: KeyPair`` - the key pair that controls the asset being sold. It will be used to sign the transaction.
-- ``buyerSessionID: Long`` - a unique number that identifies this trade to the buyer. It is expected that the buyer
-  knows that the trade is going to take place and has sent you such a number already.
-
-.. note:: Session IDs will be automatically handled in a future version of the framework.
 
 And for the buyer:
 
@@ -178,7 +167,6 @@ And for the buyer:
   a price less than or equal to this, then the trade will go ahead.
 - ``typeToBuy: Class<out OwnableState>`` - the type of state that is being purchased. This is used to check that the
   sell side of the protocol isn't trying to sell us the wrong thing, whether by accident or on purpose.
-- ``sessionID: Long`` - the session ID that was handed to the seller in order to start the protocol.
 
 Alright, so using this protocol shouldn't be too hard: in the simplest case we can just create a Buyer or Seller
 with the details of the trade, depending on who we are. We then have to start the protocol in some way. Just
@@ -221,6 +209,27 @@ protocol are checked against a whitelist, which can be extended by apps themselv
 The process of starting a protocol returns a ``ListenableFuture`` that you can use to either block waiting for
 the result, or register a callback that will be invoked when the result is ready.
 
+In a two party protocol only one side is to be manually started using ``ServiceHub.invokeProtocolAsync``. The other side
+has to be registered by its node to respond to the initiating protocol via ``ServiceHubInternal.registerProtocolInitiator``.
+In our example it doesn't matter which protocol is the initiator and which is the initiated. For example, if we are to
+take the seller as the initiator then we would register the buyer as such:
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      val services: ServiceHubInternal = TODO()
+
+      services.registerProtocolInitiator(Seller::class) { otherParty ->
+        val notary = services.networkMapCache.notaryNodes[0]
+        val acceptablePrice = TODO()
+        val typeToBuy = TODO()
+        Buyer(otherParty, notary, acceptablePrice, typeToBuy)
+      }
+
+This is telling the buyer node to fire up an instance of ``Buyer`` (the code in the lambda) when the initiating protocol
+is a seller (``Seller::class``).
+
 Implementing the seller
 -----------------------
 
@@ -253,12 +262,10 @@ Let's fill out the ``receiveAndCheckProposedTransaction()`` method.
 
       @Suspendable
       private fun receiveAndCheckProposedTransaction(): SignedTransaction {
-          val sessionID = random63BitValue()
-
           // Make the first message we'll send to kick off the protocol.
-          val hello = SellerTradeInfo(assetToSell, price, myKeyPair.public, sessionID)
+          val hello = SellerTradeInfo(assetToSell, price, myKeyPair.public)
 
-          val maybeSTX = sendAndReceive<SignedTransaction>(otherSide, buyerSessionID, sessionID, hello)
+          val maybeSTX = sendAndReceive<SignedTransaction>(otherSide, hello)
 
           maybeSTX.unwrap {
               // Check that the tx proposed by the buyer is valid.
@@ -281,11 +288,10 @@ Let's fill out the ``receiveAndCheckProposedTransaction()`` method.
           }
       }
 
-Let's break this down. We generate a session ID to identify what's happening on the seller side, fill out
-the initial protocol message, and then call ``sendAndReceive``. This function takes a few arguments:
+Let's break this down. We fill out the initial protocol message with the trade info, and then call ``sendAndReceive``.
+This function takes a few arguments:
 
-- The topic string that ensures the message is routed to the right bit of code in the other side's node.
-- The session IDs that ensure the messages don't get mixed up with other simultaneous trades.
+- The party on the other side.
 - The thing to send. It'll be serialised and sent automatically.
 - Finally a type argument, which is the kind of object we're expecting to receive from the other side. If we get
   back something else an exception is thrown.
@@ -370,7 +376,7 @@ Here's the rest of the code:
                                  notarySignature: DigitalSignature.LegallyIdentifiable): SignedTransaction {
           val fullySigned = partialTX + ourSignature + notarySignature
           logger.trace { "Built finished transaction, sending back to secondary!" }
-          send(otherSide, buyerSessionID, SignaturesFromSeller(ourSignature, notarySignature))
+          send(otherSide, SignaturesFromSeller(ourSignature, notarySignature))
           return fullySigned
       }
 
@@ -406,7 +412,7 @@ OK, let's do the same for the buyer side:
           val (ptx, cashSigningPubKeys) = assembleSharedTX(tradeRequest)
           val stx = signWithOurKeys(cashSigningPubKeys, ptx)
 
-          val signatures = swapSignaturesWithSeller(stx, tradeRequest.sessionID)
+          val signatures = swapSignaturesWithSeller(stx)
 
           logger.trace { "Got signatures from seller, verifying ... " }
 
@@ -419,16 +425,14 @@ OK, let's do the same for the buyer side:
 
       @Suspendable
       private fun receiveAndValidateTradeRequest(): SellerTradeInfo {
-          // Wait for a trade request to come in on our pre-provided session ID.
-          val maybeTradeRequest = receive<SellerTradeInfo>(sessionID)
+          // Wait for a trade request to come in from the other side
+          val maybeTradeRequest = receive<SellerTradeInfo>(otherParty)
           maybeTradeRequest.unwrap {
               // What is the seller trying to sell us?
               val asset = it.assetForSale.state.data
               val assetTypeName = asset.javaClass.name
               logger.trace { "Got trade request for a $assetTypeName: ${it.assetForSale}" }
 
-              // Check the start message for acceptability.
-              check(it.sessionID > 0)
               if (it.price > acceptablePrice)
                   throw UnacceptablePriceException(it.price)
               if (!typeToBuy.isInstance(asset))
@@ -443,13 +447,13 @@ OK, let's do the same for the buyer side:
       }
 
       @Suspendable
-      private fun swapSignaturesWithSeller(stx: SignedTransaction, theirSessionID: Long): SignaturesFromSeller {
+      private fun swapSignaturesWithSeller(stx: SignedTransaction): SignaturesFromSeller {
           progressTracker.currentStep = SWAPPING_SIGNATURES
           logger.trace { "Sending partially signed transaction to seller" }
 
           // TODO: Protect against the seller terminating here and leaving us in the lurch without the final tx.
 
-          return sendAndReceive<SignaturesFromSeller>(otherSide, theirSessionID, sessionID, stx).unwrap { it }
+          return sendAndReceive<SignaturesFromSeller>(otherSide, stx).unwrap { it }
       }
 
       private fun signWithOurKeys(cashSigningPubKeys: List<PublicKey>, ptx: TransactionBuilder): SignedTransaction {
@@ -676,7 +680,6 @@ Future features
 The protocol framework is a key part of the platform and will be extended in major ways in future. Here are some of
 the features we have planned:
 
-* Automatic session ID management
 * Identity based addressing
 * Exposing progress trackers to local (inside the firewall) clients using message queues and/or WebSockets
 * Exception propagation and management, with a "protocol hospital" tool to manually provide solutions to unavoidable

docs/build/html/_sources/release-notes.txt

@@ -3,8 +3,95 @@ Release notes
 
 Here are brief summaries of what's changed between each snapshot release.
 
-Unreleased
-----------
+Milestone 4
+-----------
+
+New features in this release:
+
+* Persistence:
+
+    * States can now be written into a relational database and queried using JDBC. The schemas are defined by the
+      smart contracts and schema versioning is supported. It is reasonable to write an app that stores data in a mix
+      of global ledger transactions and local database tables which are joined on demand, using join key slots that
+      are present in many state definitions. Read more about :doc:`persistence`.
+    * The embedded H2 SQL database is now exposed by default to any tool that can speak JDBC. The database URL is
+      printed during node startup and can be used to explore the database, which contains both node internal data
+      and tables generated from ledger states.
+    * Protocol checkpoints are now stored in the database as well. Message processing is now atomic with protocol
+      checkpointing and run under the same RDBMS transaction.
+    * MQ message deduplication is now handled at the app layer and performed under the RDMS transaction, so
+      ensuring messages are only replayed if the RDMS transaction rolled back.
+    * "The wallet" has been renamed to "the vault".
+
+* Client RPC:
+
+    * New RPCs added to subscribe to snapshots and update streams state of the vault, currently executing protocols
+      and other important node information.
+    * New tutorial added that shows how to use the RPC API to draw live transaction graphs on screen.
+
+* Protocol framework:
+
+    * Large simplifications to the API. Session management is now handled automatically. Messages are now routed
+      based on identities rather than node IP addresses.
+
+* Decentralised consensus:
+
+    * A standalone one-node notary backed by a JDBC store has been added.
+    * A prototype RAFT based notary composed of multiple nodes is available on a branch.
+
+* Data model:
+
+    * Compound keys have been added as preparation for merging a distributed RAFT based notary. Compound keys
+      are trees of public keys in which interior nodes can have validity thresholds attached, thus allowing
+      boolean formulas of keys to be created. This is similar to Bitcoin's multi-sig support and the data model
+      is the same as the InterLedger Crypto-Conditions spec, which should aid interop in future. Read more about
+      key trees in the ":doc:`transaction-data-types`" article.
+    * A new tutorial has been added showing how to use transaction attachments in more detail.
+
+* Testnet
+
+    * Permissioning infrastructure phase one is built out. The node now has a notion of developer mode vs normal
+      mode. In developer mode it works like M3 and the SSL certificates used by nodes running on your local
+      machine all self-sign using a developer key included in the source tree. When developer mode is not active,
+      the node won't start until it has a signed certificate. Such a certificate can be obtained by simply running
+      an included command line utility which generates a CSR and submits it to a permissioning service, then waits
+      for the signed certificate to be returned. Note that currently there is no public Corda testnet, so we are
+      not currently running a permissioning service.
+
+* Standalone app development:
+
+    * The Corda libraries that app developers need to link against can now be installed into your local Maven
+      repository, where they can then be used like any other JAR. See :doc:`creating-a-cordapp`.
+
+* User interfaces:
+
+    * Infrastructure work on the node explorer is now complete: it is fully switched to using the MQ based RPC system.
+    * A library of additional reactive collections has been added. This API builds on top of Rx and the observable
+      collections API in Java 8 to give "live" data structures in which the state of the node and ledger can be
+      viewed as an ordinary Java ``List``, ``Map`` and ``Set``, but which also emit callbacks when these views
+      change, and which can have additional views derived in a functional manner (filtered, mapped, sorted, etc).
+      Finally, these views can then be bound directly into JavaFX UIs. This makes for a concise and functional
+      way of building application UIs that render data from the node, and the API is available for third party
+      app developers to use as well. We believe this will be highly productive and enjoyable for developers who
+      have the option of building JavaFX apps (vs web apps).
+    * The visual network simulator tool that was demoed back in April as part of the first Corda live demo has
+      been merged into the main repository.
+
+* Documentation
+
+    * New secure coding guidelines. Corda tries to eliminate as many security mistakes as practical via the type
+      system and other mechanically checkable processes, but there are still things that one must be aware of.
+    * New attachments tutorial.
+    * New Client RPC tutorial.
+    * More tutorials on how to build a standalone CorDapp.
+
+* Testing
+
+    * More integration testing support
+    * New micro-DSLs for expressing expected sequences of operations with more or less relaxed ordering constraints.
+    * QuickCheck generators to create streams of randomised transactions and other basic types. QuickCheck is a way
+      of writing unit tests that perform randomised fuzz testing of code, originally developed by the Haskell
+      community and now also available in Java.
 
 API changes:
 
@@ -15,6 +102,8 @@ API changes:
 * The ``UntrustworthyData<T>.validate`` method has been renamed to ``unwrap`` - the old name is now deprecated.
 * The wallet, wallet service, etc. are now vault, vault service, etc. These better reflect the intent that they
   are a generic secure data store, rather than something which holds cash.
+* The protocol send/receive APIs have changed to no longer require a session id. Please check the current version
+  of the protocol framework tutorial for more details.
 
 Milestone 3
 -----------
@@ -49,7 +138,7 @@ Milestone 2
 
 * Big improvements to the interest rate swap app:
 
-    * A new web app demonstrating the IRS contract has been added. This can x``be used as an example for how to interact with
+    * A new web app demonstrating the IRS contract has been added. This can be used as an example for how to interact with
       the Corda API from the web.
     * Simplifications to the way the demo is used from the command line.
     * :doc:`Detailed documentation on how the contract works and can be used <contract-irs>` has been written.

docs/build/html/_sources/running-the-demos.txt

@@ -143,4 +143,34 @@ Now open your web browser to this URL:
 
 To use the demos click the "Create Deal" button, fill in the form, then click the "Submit" button. Now you will be
 able to use the time controls at the top left of the home page to run the fixings. Click any individual trade in the
-blotter to view it.
+blotter to view it.
+
+
+
+Attachment demo
+----------------
+
+Open two terminals, and in the first run:
+
+**Windows**::
+
+    gradlew.bat & .\build\install\r3prototyping\bin\attachment-demo --role=RECIPIENT
+
+**Other**::
+
+    ./gradlew installDist && ./build/install/r3prototyping/bin/attachment-demo --role=RECIPIENT
+
+It will compile things, if necessary, then create a directory named attachment-demo/buyer with a bunch of files inside and
+start the node. You should see it waiting for a trade to begin.
+
+In the second terminal, run:
+
+**Windows**::
+
+    .\build\install\r3prototyping\bin\attachment-demo --role=SENDER
+
+**Other**::
+
+    ./build/install/r3prototyping/bin/attachment-demo --role=SENDER
+
+You should see some log lines scroll past, and within a few seconds the message "File received - we're happy!" should be printed.

docs/build/html/_sources/secure-coding-guidelines.txt

@@ -1,5 +1,5 @@
 Secure coding guidelines
-------------------------
+========================
 
 The platform does what it can to be secure by default and safe by design. Unfortunately the platform cannot
 prevent every kind of security mistake. This document describes what to think about when writing applications

docs/build/html/_sources/transaction-data-types.txt

@@ -145,6 +145,40 @@ that has been signed by a set of parties.
 .. note:: These types are provisional and will change significantly in future as the identity framework becomes more
    fleshed out.
 
+Multi-signature support
+-----------------------
+
+Corda supports scenarios where more than one key or party is required to authorise a state object transition, for example:
+"Either the CEO or 3 out of 5 of his assistants need to provide signatures".
+
+Key Trees
+^^^^^^^^^
+
+This is achieved by public key composition, using a tree data structure ``PublicKeyTree``. A ``PublicKeyTree`` stores the
+cryptographic public key primitives in its leaves and the composition logic in the intermediary nodes. Every intermediary
+node specifies a *threshold* of how many child signatures it requires.
+
+An illustration of an *"either Alice and Bob, or Charlie"* public key tree:
+
+.. image:: resources/public-key-tree.png
+:width: 300px
+
+To allow further flexibility, each child node can have an associated custom *weight* (the default is 1). The *threshold*
+then specifies the minimum total weight of all children required. Our previous example can also be expressed as:
+
+.. image:: resources/public-key-tree-2.png
+:width: 300px
+
+Verification
+^^^^^^^^^^^^
+
+Signature verification is performed in two stages:
+
+  1. Given a list of signatures, each signature is verified against the expected content.
+  2. The public keys corresponding to the signatures are matched against the leaves of the public key tree in question,
+     and the total combined weight of all children is calculated for every intermediary node. If all thresholds are satisfied,
+     the public key tree requirement is considered to be met.
+
 Date support
 ------------
 

docs/build/html/_sources/tutorial-attachments.txt

@@ -0,0 +1,99 @@
+.. highlight:: kotlin
+.. raw:: html
+
+Using attachments
+=================
+
+Attachments are (typically large) Zip/Jar files referenced within a transaction, but not included in the transaction
+itself. These files can be requested from the originating node as needed, although in many cases will be cached within
+nodes already. Examples include:
+
+* Contract executable code
+* Metadata about a transaction, such as PDF version of an invoice being settled
+* Shared information to be permanently recorded on the ledger
+
+To add attachments the file must first be added to the node's storage service using ``StorageService.importAttachment()``,
+which returns a unique ID that can be added using ``TransactionBuilder.addAttachment()``. Attachments can also be
+uploaded and downloaded via HTTP, to enable integration with external systems. For instructions on HTTP upload/download
+please see ":doc:`node-administration`".
+
+Normally attachments on transactions are fetched automatically via the ``ResolveTransactionsProtocol`` when verifying
+received transactions. Attachments are needed in order to validate a transaction (they include, for example, the
+contract code), so must be fetched before the validation process can run. ``ResolveTransactionsProtocol`` calls
+``FetchTransactionsProtocol`` to perform the actual retrieval.
+
+It is encouraged that where possible attachments are reusable data, so that nodes can meaningfully cache them.
+
+Attachments demo
+----------------
+
+There is a worked example of attachments, which relays a simple document from one node to another. The "two party
+trade protocol" also includes an attachment, however it is a significantly more complex demo, and less well suited
+for a tutorial.
+
+The demo code is in the file "src/main/kotlin/com/r3corda/demos/attachment/AttachmentDemo.kt", with the core logic
+contained within the two functions ``runRecipient()`` and ``runSender()``. We'll look at the recipient function first;
+this subscribes to notifications of new validated transactions, and if it receives a transaction containing attachments,
+loads the first attachment from storage, and checks it matches the expected attachment ID. ``ResolveTransactionsProtocol``
+has already fetched all attachments from the remote node, and as such the attachments are available from the node's
+storage service. Once the attachment is verified, the node shuts itself down.
+
+.. sourcecode:: kotlin
+
+    private fun runRecipient(node: Node) {
+        val serviceHub = node.services
+
+        // Normally we would receive the transaction from a more specific protocol, but in this case we let [FinalityProtocol]
+        // handle receiving it for us.
+        serviceHub.storageService.validatedTransactions.updates.subscribe { event ->
+            // When the transaction is received, it's passed through [ResolveTransactionsProtocol], which first fetches any
+            // attachments for us, then verifies the transaction. As such, by the time it hits the validated transaction store,
+            // we have a copy of the attachment.
+            val tx = event.tx
+            if (tx.attachments.isNotEmpty()) {
+                val attachment = serviceHub.storageService.attachments.openAttachment(tx.attachments.first())
+                assertEquals(PROSPECTUS_HASH, attachment?.id)
+
+                println("File received - we're happy!\n\nFinal transaction is:\n\n${Emoji.renderIfSupported(event.tx)}")
+                thread {
+                    node.stop()
+                }
+            }
+        }
+    }
+
+The sender correspondingly builds a transaction with the attachment, then calls ``FinalityProtocol`` to complete the
+transaction and send it to the recipient node:
+
+
+.. sourcecode:: kotlin
+
+    private fun runSender(node: Node, otherSide: Party) {
+        val serviceHub = node.services
+        // Make sure we have the file in storage
+        if (serviceHub.storageService.attachments.openAttachment(PROSPECTUS_HASH) == null) {
+            com.r3corda.demos.Role::class.java.getResourceAsStream("bank-of-london-cp.jar").use {
+                val id = node.storage.attachments.importAttachment(it)
+                assertEquals(PROSPECTUS_HASH, id)
+            }
+        }
+
+        // Create a trivial transaction that just passes across the attachment - in normal cases there would be
+        // inputs, outputs and commands that refer to this attachment.
+        val ptx = TransactionType.General.Builder(notary = null)
+        ptx.addAttachment(serviceHub.storageService.attachments.openAttachment(PROSPECTUS_HASH)!!.id)
+
+        // Despite not having any states, we have to have at least one signature on the transaction
+        ptx.signWith(ALICE_KEY)
+
+        // Send the transaction to the other recipient
+        val tx = ptx.toSignedTransaction()
+        serviceHub.startProtocol(LOG_SENDER, FinalityProtocol(tx, emptySet(), setOf(otherSide))).success {
+            thread {
+                Thread.sleep(1000L) // Give the other side time to request the attachment
+                node.stop()
+            }
+        }.failure {
+            println("Failed to relay message ")
+        }
+    }

docs/build/html/_sources/tutorial-clientrpc-api.txt

@@ -0,0 +1,83 @@
+.. _graphstream: http://graphstream-project.org/
+
+Client RPC API
+==============
+
+In this tutorial we will build a simple command line utility that connects to a node and dumps the transaction graph to
+the standard output. We will then put some simple visualisation on top. For an explanation on how the RPC works see
+:doc:`clientrpc`.
+
+We start off by connecting to the node itself. For the purposes of the tutorial we will run the Trader demo on some
+local port and connect to the Buyer side. We will pass in the address as a command line argument. To connect to the node
+we also need to access the certificates of the node, we will access the node's ``certificates`` directory directly.
+
+.. literalinclude:: example-code/src/main/kotlin/com/r3corda/docs/ClientRpcTutorial.kt
+    :language: kotlin
+    :start-after: START 1
+    :end-before: END 1
+
+Now we can connect to the node itself:
+
+.. literalinclude:: example-code/src/main/kotlin/com/r3corda/docs/ClientRpcTutorial.kt
+    :language: kotlin
+    :start-after: START 2
+    :end-before: END 2
+
+``proxy`` now exposes the full RPC interface of the node:
+
+.. literalinclude:: ../../node/src/main/kotlin/com/r3corda/node/services/messaging/CordaRPCOps.kt
+    :language: kotlin
+    :start-after: interface CordaRPCOps
+    :end-before: }
+
+The one we need in order to dump the transaction graph is ``verifiedTransactions``. The type signature tells us that the
+RPC will return a list of transactions and an Observable stream. This is a general pattern, we query some data and the
+node will return the current snapshot and future updates done to it.
+
+.. literalinclude:: example-code/src/main/kotlin/com/r3corda/docs/ClientRpcTutorial.kt
+    :language: kotlin
+    :start-after: START 3
+    :end-before: END 3
+
+The graph will be defined by nodes and edges between them. Each node represents a transaction and edges represent
+output-input relations. For now let's just print ``NODE <txhash>`` for the former and ``EDGE <txhash> <txhash>`` for the
+latter.
+
+.. literalinclude:: example-code/src/main/kotlin/com/r3corda/docs/ClientRpcTutorial.kt
+    :language: kotlin
+    :start-after: START 4
+    :end-before: END 4
+
+Now we can start the trader demo as per described in :doc:`running-the-demos`::
+
+    # Build the demo
+    ./gradlew installDist
+    # Start the buyer
+    ./build/install/r3prototyping/bin/trader-demo --role=BUYER
+
+In another terminal we can connect to it with our client::
+
+    # Connect to localhost:31337
+    ./docs/source/example-code/build/install/docs/source/example-code/bin/client-rpc-tutorial localhost:31337 Print
+
+We should see some ``NODE``-s printed. This is because the buyer self-issues some cash for the demo.
+Unless we ran the seller before we shouldn't see any ``EDGE``-s because the cash hasn't been spent yet.
+
+In another terminal we can now start the seller::
+
+    # Start sellers in a loop
+    for i in {0..9} ; do ./build/install/r3prototyping/bin/trader-demo --role=SELLER ; done
+
+We should start seeing new ``NODE``-s and ``EDGE``-s appearing.
+
+Now let's try to visualise the transaction graph. We will use a graph drawing library called graphstream_
+
+.. literalinclude:: example-code/src/main/kotlin/com/r3corda/docs/ClientRpcTutorial.kt
+    :language: kotlin
+    :start-after: START 5
+    :end-before: END 5
+
+If we run the client with ``Visualise`` we should see a simple graph being drawn as new transactions are being created
+by the seller runs.
+
+That's it! We saw how to connect to the node and stream data from it.

docs/build/html/api/alltypes/index.html

@@ -214,6 +214,14 @@ properties loaded from the attachments.  And perhaps the authenticated user for
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.fxutils/-associated-list/index.html">com.r3corda.client.fxutils.AssociatedList</a></td>
+<td>
+<p><a href="../com.r3corda.client.fxutils/-associated-list/index.html">AssociatedList</a> creates an <a href="#">ObservableMap</a> from an <a href="#">ObservableList</a> by associating each list element with a unique key.
+It is <emph>not</emph> allowed to have several elements map to the same value</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.contracts/-attachment/index.html">com.r3corda.core.contracts.Attachment</a></td>
 <td>
 <p>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.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.schemas/-cash-schema.html">com.r3corda.schemas.CashSchema</a></td>
+<td>
+<p>An object used to fully qualify the <a href="../com.r3corda.schemas/-cash-schema.html">CashSchema</a> family name (i.e. independent of version).</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../com.r3corda.schemas/-cash-schema-v1/index.html">com.r3corda.schemas.CashSchemaV1</a></td>
+<td>
+<p>First version of a cash contract ORM schema that maps all fields of the <a href="#">Cash</a> contract state as it stood
+at the time of writing.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.utilities.certsigning/-certificate-signer/index.html">com.r3corda.node.utilities.certsigning.CertificateSigner</a></td>
 <td>
 <p>This check the <a href="#">certificatePath</a> for certificates required to connect to the Corda network.
@@ -410,12 +433,6 @@ provided directly by this clause.</p>
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.node.services.monitor/-client-to-service-command-message/index.html">com.r3corda.node.services.monitor.ClientToServiceCommandMessage</a></td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
 <a href="../com.r3corda.node.utilities/java.time.-clock/index.html">java.time.Clock</a> (extensions in package com.r3corda.node.utilities)</td>
 <td>
 </td>
@@ -428,6 +445,12 @@ provided directly by this clause.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.fxutils/kotlin.collections.-collection/index.html">kotlin.collections.Collection</a> (extensions in package com.r3corda.client.fxutils)</td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.contracts/-command/index.html">com.r3corda.core.contracts.Command</a></td>
 <td>
 <p>Command data/content plus pubkey pair: the signature is stored at the end of the serialized bytes</p>
@@ -466,6 +489,21 @@ provided directly by this clause.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.schemas/-commercial-paper-schema.html">com.r3corda.schemas.CommercialPaperSchema</a></td>
+<td>
+<p>An object used to fully qualify the <a href="../com.r3corda.schemas/-commercial-paper-schema.html">CommercialPaperSchema</a> family name (i.e. independent of version).</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../com.r3corda.schemas/-commercial-paper-schema-v1/index.html">com.r3corda.schemas.CommercialPaperSchemaV1</a></td>
+<td>
+<p>First version of a commercial paper contract ORM schema that maps all fields of the <a href="#">CommercialPaper</a> contract state
+as it stood at the time of writing.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.contracts/-commodity/index.html">com.r3corda.core.contracts.Commodity</a></td>
 <td>
 <p>Class representing a commodity, as an equivalent to the <a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html">Currency</a> 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
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.fxutils/-concatenated-list/index.html">com.r3corda.client.fxutils.ConcatenatedList</a></td>
+<td>
+<p><a href="../com.r3corda.client.fxutils/-concatenated-list/index.html">ConcatenatedList</a> takes a list of lists and concatenates them. Any change to the underlying lists or the outer list
+is propagated as expected.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.servlets/-config/index.html">com.r3corda.node.servlets.Config</a></td>
 <td>
 <p>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
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.services.config/-config-helper/index.html">com.r3corda.node.services.config.ConfigHelper</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.internal/-configuration-exception/index.html">com.r3corda.node.internal.ConfigurationException</a></td>
 <td>
 </td>
@@ -578,7 +630,7 @@ useful tasks. See the documentation for <a href="../com.r3corda.client/-corda-r-
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.node.services.messaging/-corda-r-p-c-ops.html">com.r3corda.node.services.messaging.CordaRPCOps</a></td>
+<a href="../com.r3corda.node.services.messaging/-corda-r-p-c-ops/index.html">com.r3corda.node.services.messaging.CordaRPCOps</a></td>
 <td>
 <p>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 <a href="#">ServerRPCOps</a> class.</p>
@@ -605,6 +657,13 @@ client apps and are implemented by the node in the <a href="#">ServerRPCOps</a>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.services.persistence/-d-b-checkpoint-storage/index.html">com.r3corda.node.services.persistence.DBCheckpointStorage</a></td>
+<td>
+<p>Simple checkpoint key value storage in DB using the underlying JDBCHashMap and transactional context of the call sites.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.servlets/-data-upload-servlet/index.html">com.r3corda.node.servlets.DataUploadServlet</a></td>
 <td>
 <p>Accepts binary streams, finds the right <a href="../com.r3corda.node.services.api/-accepts-file-upload/index.html">AcceptsFileUpload</a> implementor and hands the stream off to it.</p>
@@ -666,18 +725,6 @@ implementation of general protocols that manipulate many agreement types.</p>
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.node.services.monitor/-deregister-request/index.html">com.r3corda.node.services.monitor.DeregisterRequest</a></td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
-<a href="../com.r3corda.node.services.monitor/-deregister-response/index.html">com.r3corda.node.services.monitor.DeregisterResponse</a></td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
 <a href="../com.r3corda.core.serialization/-deserialize-as-kotlin-object-def.html">com.r3corda.core.serialization.DeserializeAsKotlinObjectDef</a></td>
 <td>
 <p>Marker interface for kotlin object definitions so that they are deserialized as the singleton instance.</p>
@@ -685,6 +732,12 @@ implementation of general protocols that manipulate many agreement types.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.model/-diff/index.html">com.r3corda.client.model.Diff</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.crypto/-digital-signature/index.html">com.r3corda.core.crypto.DigitalSignature</a></td>
 <td>
 <p>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.</p>
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.protocols/-direct-request-message/index.html">com.r3corda.protocols.DirectRequestMessage</a></td>
-<td>
-<p>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).</p>
-</td>
-</tr>
-<tr>
-<td>
 <a href="../com.r3corda.core.contracts/kotlin.-double/index.html">kotlin.Double</a> (extensions in package com.r3corda.core.contracts)</td>
 <td>
 </td>
@@ -884,6 +927,13 @@ attachments are saved to local storage automatically.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.core.contracts.clauses/-filter-on/index.html">com.r3corda.core.contracts.clauses.FilterOn</a></td>
+<td>
+<p>Filter the states that are passed through to the wrapped clause, to restrict them to a specific type.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.protocols/-finality-protocol/index.html">com.r3corda.protocols.FinalityProtocol</a></td>
 <td>
 <p>Finalise a transaction by notarising it, then recording it locally, and then sending it to all involved parties.</p>
@@ -936,7 +986,7 @@ Assumes that the rate is valid.</p>
 <td>
 <a href="../com.r3corda.node.services.clientapi/-fixing-session-initiation/index.html">com.r3corda.node.services.clientapi.FixingSessionInitiation</a></td>
 <td>
-<p>This is a temporary handler required for establishing random sessionIDs for the <a href="#">Fixer</a> and <a href="#">Floater</a> as part of
+<p>This is a temporary handler required for establishing random sessionIDs for the <a href="../com.r3corda.protocols/-two-party-deal-protocol/-fixer/index.html">Fixer</a> and <a href="../com.r3corda.protocols/-two-party-deal-protocol/-floater/index.html">Floater</a> as part of
 running scheduled fixings for the <a href="#">InterestRateSwap</a> contract.</p>
 </td>
 </tr>
@@ -1015,12 +1065,6 @@ container), shares of the same class in a specific company are fungible and coun
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.core/java.util.concurrent.-future/index.html">java.util.concurrent.Future</a> (extensions in package com.r3corda.core)</td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
 <a href="../com.r3corda.client.model/-gathered-transaction-data/index.html">com.r3corda.client.model.GatheredTransactionData</a></td>
 <td>
 </td>
@@ -1029,13 +1073,7 @@ container), shares of the same class in a specific company are fungible and coun
 <td>
 <a href="../com.r3corda.client.model/-gathered-transaction-data-model/index.html">com.r3corda.client.model.GatheredTransactionDataModel</a></td>
 <td>
-<p>This model provides an observable list of states relating to the creation of a transaction not yet on ledger.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="../com.r3corda.client.model/-gathered-transaction-data-writable/index.html">com.r3corda.client.model.GatheredTransactionDataWritable</a></td>
-<td>
+<p>This model provides an observable list of transactions and what state machines/protocols recorded them</p>
 </td>
 </tr>
 <tr>
@@ -1059,11 +1097,9 @@ container), shares of the same class in a specific company are fungible and coun
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.protocols/-handshake-message/index.html">com.r3corda.protocols.HandshakeMessage</a></td>
+<a href="../com.r3corda.node.services.schema/-hibernate-observer/index.html">com.r3corda.node.services.schema.HibernateObserver</a></td>
 <td>
-<p>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.</p>
+<p>A vault observer that extracts Object Relational Mappings for contract states that support it, and persists them with Hibernate.</p>
 </td>
 </tr>
 <tr>
@@ -1137,6 +1173,13 @@ set via the constructor and the class is immutable.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.services.persistence/-in-memory-state-machine-recorded-transaction-mapping-storage/index.html">com.r3corda.node.services.persistence.InMemoryStateMachineRecordedTransactionMappingStorage</a></td>
+<td>
+<p>This is a temporary in-memory storage of a state machine id -&gt; txhash mapping</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.services.transactions/-in-memory-uniqueness-provider/index.html">com.r3corda.node.services.transactions.InMemoryUniquenessProvider</a></td>
 <td>
 <p>A dummy Uniqueness provider that stores the whole history of consumed states in memory</p>
@@ -1260,6 +1303,12 @@ quantifiable with integer quantities.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.core.node.services/kotlin.collections.-iterable/index.html">kotlin.collections.Iterable</a> (extensions in package com.r3corda.core.node.services)</td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core/kotlin.collections.-iterable/index.html">kotlin.collections.Iterable</a> (extensions in package com.r3corda.core)</td>
 <td>
 </td>
@@ -1336,6 +1385,14 @@ call out to a hardware security module that enforces various auditing and freque
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.fxutils/-left-outer-joined-map/index.html">com.r3corda.client.fxutils.LeftOuterJoinedMap</a></td>
+<td>
+<p><a href="../com.r3corda.client.fxutils/-left-outer-joined-map/index.html">LeftOuterJoinedMap</a> implements a special case of a left outer join where were matching on primary keys of both
+tables.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.math/-linear-interpolator/index.html">com.r3corda.core.math.LinearInterpolator</a></td>
 <td>
 <p>Interpolates values between the given data points using straight lines.</p>
@@ -1362,6 +1419,13 @@ call out to a hardware security module that enforces various auditing and freque
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.utilities/-local-date-column-type/index.html">com.r3corda.node.utilities.LocalDateColumnType</a></td>
+<td>
+<p><a href="#">ColumnType</a> for marshalling to/from database on behalf of <a href="#">java.time.LocalDate</a>.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.utilities/-log-helper/index.html">com.r3corda.core.utilities.LogHelper</a></td>
 <td>
 <p>A configuration helper that allows modifying the log level for specific loggers</p>
@@ -1375,6 +1439,31 @@ call out to a hardware security module that enforces various auditing and freque
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.fxutils/-map-values-list/index.html">com.r3corda.client.fxutils.MapValuesList</a></td>
+<td>
+<p><a href="../com.r3corda.client.fxutils/-map-values-list/index.html">MapValuesList</a> takes an <a href="#">ObservableMap</a> and returns its values as an <a href="#">ObservableList</a>.
+The order of returned elements is deterministic but unspecified.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../com.r3corda.client.fxutils/-mapped-list/index.html">com.r3corda.client.fxutils.MappedList</a></td>
+<td>
+<p>This is a variant of <a href="#">EasyBind.map</a> 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 <a href="#">EasyBind.map</a> to trade off memory vs CPU, or if (god forbid) the mapped function is side-effecting.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../com.r3corda.core.schemas/-mapped-schema/index.html">com.r3corda.core.schemas.MappedSchema</a></td>
+<td>
+<p>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.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.services.messaging/-marshalled-observation/index.html">com.r3corda.node.services.messaging.MarshalledObservation</a></td>
 <td>
 <p>Used in the RPC wire protocol to wrap an observation with the handle of the observable its intended for.</p>
@@ -1606,12 +1695,6 @@ loads important data off disk and starts listening for connections.</p>
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.node.services.config/-node-configuration-from-config/index.html">com.r3corda.node.services.config.NodeConfigurationFromConfig</a></td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
 <a href="../com.r3corda.core.node/-node-info/index.html">com.r3corda.core.node.NodeInfo</a></td>
 <td>
 <p>Info about a network node that acts on behalf of some form of contract party.</p>
@@ -1642,24 +1725,9 @@ Artemis is a message queue broker and here we run a client connecting to the spe
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.client/-node-monitor-client/index.html">com.r3corda.client.NodeMonitorClient</a></td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
 <a href="../com.r3corda.client.model/-node-monitor-model/index.html">com.r3corda.client.model.NodeMonitorModel</a></td>
 <td>
-<p>This model exposes raw event streams to and from the <a href="#">NodeMonitorService</a> through a <a href="../com.r3corda.client/-node-monitor-client/index.html">NodeMonitorClient</a></p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="../com.r3corda.node.services.monitor/-node-monitor-service/index.html">com.r3corda.node.services.monitor.NodeMonitorService</a></td>
-<td>
-<p>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.</p>
+<p>This model exposes raw event streams to and from the node.</p>
 </td>
 </tr>
 <tr>
@@ -1691,6 +1759,13 @@ that also encompasses the <a href="#">Vault</a> observer for processing transact
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.services.schema/-node-schema-service/index.html">com.r3corda.node.services.schema.NodeSchemaService</a></td>
+<td>
+<p>Most basic implementation of <a href="../com.r3corda.node.services.api/-schema-service/index.html">SchemaService</a>.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.services.vault/-node-vault-service/index.html">com.r3corda.node.services.vault.NodeVaultService</a></td>
 <td>
 <p>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.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.fxutils/javafx.collections.-observable-map/index.html">javafx.collections.ObservableMap</a> (extensions in package com.r3corda.client.fxutils)</td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.client.fxutils/javafx.beans.value.-observable-value/index.html">javafx.beans.value.ObservableValue</a> (extensions in package com.r3corda.client.fxutils)</td>
 <td>
 </td>
@@ -1835,6 +1916,15 @@ functionality to Java, but it wont arrive for a few years yet</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.model/-partially-resolved-transaction/index.html">com.r3corda.client.model.PartiallyResolvedTransaction</a></td>
+<td>
+<p><a href="../com.r3corda.client.model/-partially-resolved-transaction/index.html">PartiallyResolvedTransaction</a> holds a <a href="../com.r3corda.core.transactions/-signed-transaction/index.html">SignedTransaction</a> 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)</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.crypto/-party/index.html">com.r3corda.core.crypto.Party</a></td>
 <td>
 <p>A <a href="../com.r3corda.core.crypto/-party/index.html">Party</a> is well known (name, pubkey) pair. In a real system this would probably be an X.509 certificate.</p>
@@ -1856,13 +1946,13 @@ ledger. The reference is intended to be encrypted so its meaningless to anyone o
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.core.testing/-party-generator/index.html">com.r3corda.core.testing.PartyGenerator</a></td>
+<a href="../com.r3corda.node.utilities/-party-columns/index.html">com.r3corda.node.utilities.PartyColumns</a></td>
 <td>
 </td>
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.protocols/-party-request-message/index.html">com.r3corda.protocols.PartyRequestMessage</a></td>
+<a href="../com.r3corda.core.testing/-party-generator/index.html">com.r3corda.core.testing.PartyGenerator</a></td>
 <td>
 </td>
 </tr>
@@ -1923,6 +2013,21 @@ ledger. The reference is intended to be encrypted so its meaningless to anyone o
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.core.schemas/-persistent-state/index.html">com.r3corda.core.schemas.PersistentState</a></td>
+<td>
+<p>A super class for all mapped states exported to a schema that ensures the <a href="../com.r3corda.core.contracts/-state-ref/index.html">StateRef</a> appears on the database row.  The
+<a href="../com.r3corda.core.contracts/-state-ref/index.html">StateRef</a> will be set to the correct value by the framework (theres no need to set during mapping generation by the state itself).</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../com.r3corda.core.schemas/-persistent-state-ref/index.html">com.r3corda.core.schemas.PersistentStateRef</a></td>
+<td>
+<p>Embedded <a href="../com.r3corda.core.contracts/-state-ref/index.html">StateRef</a> representation used in state mapping.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.services.transactions/-persistent-uniqueness-provider/index.html">com.r3corda.node.services.transactions.PersistentUniquenessProvider</a></td>
 <td>
 <p>A RDBMS backed Uniqueness provider</p>
@@ -1972,6 +2077,12 @@ a singleton).</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.model/-progress-tracking-event/index.html">com.r3corda.client.model.ProgressTrackingEvent</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.api/-protocol-class-ref/index.html">com.r3corda.node.api.ProtocolClassRef</a></td>
 <td>
 </td>
@@ -2027,17 +2138,22 @@ a node crash, how many instances of your protocol there are running and so on.</
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.core.protocols/-protocol-session-exception/index.html">com.r3corda.core.protocols.ProtocolSessionException</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.protocols/-protocol-state-machine/index.html">com.r3corda.core.protocols.ProtocolStateMachine</a></td>
 <td>
-<p>The interface of <a href="#">ProtocolStateMachineImpl</a> exposing methods and properties required by ProtocolLogic for compilation.</p>
+<p>A ProtocolStateMachine instance is a suspendable fiber that delegates all actual logic to a <a href="../com.r3corda.core.protocols/-protocol-logic/index.html">ProtocolLogic</a> instance.
+For any given flow there is only one PSM, even if that protocol invokes subprotocols.</p>
 </td>
 </tr>
 <tr>
 <td>
 <a href="../com.r3corda.node.services.statemachine/-protocol-state-machine-impl/index.html">com.r3corda.node.services.statemachine.ProtocolStateMachineImpl</a></td>
 <td>
-<p>A ProtocolStateMachine instance is a suspendable fiber that delegates all actual logic to a <a href="../com.r3corda.core.protocols/-protocol-logic/index.html">ProtocolLogic</a> instance.
-For any given flow there is only one PSM, even if that protocol invokes subprotocols.</p>
 </td>
 </tr>
 <tr>
@@ -2054,12 +2170,34 @@ For any given flow there is only one PSM, even if that protocol invokes subproto
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.utilities/-public-key-column-type/index.html">com.r3corda.node.utilities.PublicKeyColumnType</a></td>
+<td>
+<p><a href="#">ColumnType</a> for marshalling to/from database on behalf of <a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html">PublicKey</a>.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.testing/-public-key-generator/index.html">com.r3corda.core.testing.PublicKeyGenerator</a></td>
 <td>
 </td>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.core.crypto/-public-key-tree/index.html">com.r3corda.core.crypto.PublicKeyTree</a></td>
+<td>
+<p>A tree data structure that enables the representation of composite public keys.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../com.r3corda.core.schemas/-queryable-state/index.html">com.r3corda.core.schemas.QueryableState</a></td>
+<td>
+<p>A contract state that may be mapped to database schemas configured for this node to support querying for,
+or filtering of, states.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.services.messaging/-r-p-c-dispatcher/index.html">com.r3corda.node.services.messaging.RPCDispatcher</a></td>
 <td>
 <p>Intended to service transient clients only (not p2p nodes) for short-lived, transient request/response pairs.
@@ -2137,6 +2275,14 @@ for each step.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.fxutils/-read-only-backed-observable-map-base/index.html">com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase</a></td>
+<td>
+<p><a href="../com.r3corda.client.fxutils/-read-only-backed-observable-map-base/index.html">ReadOnlyBackedObservableMapBase</a> is a base class implementing all abstract functions required for an <a href="#">ObservableMap</a>
+using a backing HashMap that subclasses should modify.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.node.services/-read-only-transaction-storage/index.html">com.r3corda.core.node.services.ReadOnlyTransactionStorage</a></td>
 <td>
 <p>Thread-safe storage of transactions.</p>
@@ -2171,18 +2317,6 @@ e.g. LIBOR 6M as of 17 March 2016. Hence it requires a source (name) and a value
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.node.services.monitor/-register-request/index.html">com.r3corda.node.services.monitor.RegisterRequest</a></td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
-<a href="../com.r3corda.node.services.monitor/-register-response/index.html">com.r3corda.node.services.monitor.RegisterResponse</a></td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
 <a href="../com.r3corda.node.services.api/-regulator-service/index.html">com.r3corda.node.services.api.RegulatorService</a></td>
 <td>
 <p>Placeholder interface for regulator services.</p>
@@ -2190,6 +2324,14 @@ e.g. LIBOR 6M as of 17 March 2016. Hence it requires a source (name) and a value
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.fxutils/-replayed-list/index.html">com.r3corda.client.fxutils.ReplayedList</a></td>
+<td>
+<p>This list type just replays changes propagated from the underlying source list. Used for testing changes and backing a
+non-backed observable</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.contracts/-requirements/index.html">com.r3corda.core.contracts.Requirements</a></td>
 <td>
 </td>
@@ -2220,6 +2362,12 @@ again.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.demos.attachment/-role/index.html">com.r3corda.demos.attachment.Role</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.demos/-role/index.html">com.r3corda.demos.Role</a></td>
 <td>
 </td>
@@ -2271,6 +2419,13 @@ increase the feature set in the future.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.services.api/-schema-service/index.html">com.r3corda.node.services.api.SchemaService</a></td>
+<td>
+<p>A configuration and customisation point for Object Relational Mapping of contract state objects.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.crypto/-secure-hash/index.html">com.r3corda.core.crypto.SecureHash</a></td>
 <td>
 <p>Container for a cryptographically secure hash value.
@@ -2279,6 +2434,13 @@ Provides utilities for generating a cryptographic hash using different algorithm
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.utilities/-secure-hash-column-type/index.html">com.r3corda.node.utilities.SecureHashColumnType</a></td>
+<td>
+<p><a href="#">ColumnType</a> for marshalling to/from database on behalf of <a href="../com.r3corda.core.crypto/-secure-hash/index.html">SecureHash</a>.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.testing/-secure-hash-generator/index.html">com.r3corda.core.testing.SecureHashGenerator</a></td>
 <td>
 </td>
@@ -2356,6 +2518,14 @@ thread (i.e. serially). Arguments are serialised and deserialised automatically.
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.core.node/-service-entry/index.html">com.r3corda.core.node.ServiceEntry</a></td>
+<td>
+<p>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</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.node/-service-hub/index.html">com.r3corda.core.node.ServiceHub</a></td>
 <td>
 <p>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.</p>
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.protocols/-service-request-message/index.html">com.r3corda.protocols.ServiceRequestMessage</a></td>
+<a href="../com.r3corda.core.node.services/-service-info/index.html">com.r3corda.core.node.services.ServiceInfo</a></td>
 <td>
-<p>Abstract superclass for request messages sent to services, which includes common
-fields such as replyTo and sessionID.</p>
+<p>A container for additional information for an advertised service.</p>
 </td>
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.node.services.monitor/-service-to-client-event/index.html">com.r3corda.node.services.monitor.ServiceToClientEvent</a></td>
+<a href="../com.r3corda.protocols/-service-request-message/index.html">com.r3corda.protocols.ServiceRequestMessage</a></td>
 <td>
-<p>Events triggered by changes in the node, and sent to monitoring client(s).</p>
+<p>Abstract superclass for request messages sent to services which expect a reply.</p>
 </td>
 </tr>
 <tr>
@@ -2479,6 +2648,18 @@ Points at which polynomial pieces connect are known as <emph>knots</emph>.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.client.model/-state-machine-data/index.html">com.r3corda.client.model.StateMachineData</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../com.r3corda.node.services.messaging/-state-machine-info/index.html">com.r3corda.node.services.messaging.StateMachineInfo</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.node.services.statemachine/-state-machine-manager/index.html">com.r3corda.node.services.statemachine.StateMachineManager</a></td>
 <td>
 <p>A StateMachineManager is responsible for coordination and persistence of multiple <a href="../com.r3corda.core.protocols/-protocol-state-machine/index.html">ProtocolStateMachine</a> objects.
@@ -2487,12 +2668,38 @@ Each such object represents an instantiation of a (two-party) protocol that has
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.core.node.services/-state-machine-recorded-transaction-mapping-storage/index.html">com.r3corda.core.node.services.StateMachineRecordedTransactionMappingStorage</a></td>
+<td>
+<p>This is the interface to storage storing state machine -&gt; recorded tx mappings. Any time a transaction is recorded
+during a protocol run <a href="../com.r3corda.core.node.services/-state-machine-recorded-transaction-mapping-storage/add-mapping.html">addMapping</a> should be called.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../com.r3corda.core.protocols/-state-machine-run-id/index.html">com.r3corda.core.protocols.StateMachineRunId</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.client.model/-state-machine-status/index.html">com.r3corda.client.model.StateMachineStatus</a></td>
 <td>
 </td>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.core.node.services/-state-machine-transaction-mapping/index.html">com.r3corda.core.node.services.StateMachineTransactionMapping</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../com.r3corda.node.services.messaging/-state-machine-update/index.html">com.r3corda.node.services.messaging.StateMachineUpdate</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.contracts/-state-ref/index.html">com.r3corda.core.contracts.StateRef</a></td>
 <td>
 <p>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.</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.utilities/-state-ref-columns/index.html">com.r3corda.node.utilities.StateRefColumns</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.testing/-state-ref-generator/index.html">com.r3corda.core.testing.StateRefGenerator</a></td>
 <td>
 </td>
@@ -2520,18 +2733,6 @@ transaction defined the state and where in that transaction it was.</p>
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.node.services.monitor/-state-snapshot-message/index.html">com.r3corda.node.services.monitor.StateSnapshotMessage</a></td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
-<a href="../com.r3corda.client.model/-states-modification/index.html">com.r3corda.client.model.StatesModification</a></td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
 <a href="../com.r3corda.node.api/-states-query/index.html">com.r3corda.node.api.StatesQuery</a></td>
 <td>
 <p>Extremely rudimentary query language which should most likely be replaced with a product.</p>
@@ -2554,6 +2755,20 @@ anything like that, this interface is only big enough to support the prototyping
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.utilities/-strand-local-transaction-manager/index.html">com.r3corda.node.utilities.StrandLocalTransactionManager</a></td>
+<td>
+<p>A relatively close copy of the <a href="#">ThreadLocalTransactionManager</a> in Exposed but with the following adjustments to suit
+our environment:</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../com.r3corda.core.serialization/kotlin.-string/index.html">kotlin.String</a> (extensions in package com.r3corda.core.serialization)</td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core/kotlin.-string/index.html">kotlin.String</a> (extensions in package com.r3corda.core)</td>
 <td>
 </td>
@@ -2651,7 +2866,7 @@ then B and C trade with each other, then C and A etc).</p>
 </tr>
 <tr>
 <td>
-<a href="../com.r3corda.node.services.monitor/-transaction-build-result/index.html">com.r3corda.node.services.monitor.TransactionBuildResult</a></td>
+<a href="../com.r3corda.node.services.messaging/-transaction-build-result/index.html">com.r3corda.node.services.messaging.TransactionBuildResult</a></td>
 <td>
 </td>
 </tr>
@@ -2779,6 +2994,13 @@ and seller) and the following steps:</p>
 </tr>
 <tr>
 <td>
+<a href="../com.r3corda.node.utilities/-u-u-i-d-string-column-type/index.html">com.r3corda.node.utilities.UUIDStringColumnType</a></td>
+<td>
+<p><a href="#">ColumnType</a> for marshalling to/from database on behalf of <a href="http://docs.oracle.com/javase/6/docs/api/java/util/UUID.html">UUID</a>, always using a string representation.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../com.r3corda.core.contracts/-unique-identifier/index.html">com.r3corda.core.contracts.UniqueIdentifier</a></td>
 <td>
 <p>This class provides a truly unique identifier of a trade, state, or other business object.</p>

docs/build/html/api/com.r3corda.client.fxutils/-aggregated-list/-init-.html

@@ -13,7 +13,10 @@
 <p>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 <a href="#">ObservableList</a>&lt;<a href="#">A</a>&gt; by
 adding/deleting aggregations as expected.</p>
-<p>The ordering of the exposed list is based on the <a href="#">hashCode</a> of keys.</p>
+<p>The ordering of the exposed list is based on the <a href="#">hashCode</a> of keys.
+The ordering of the groups themselves is based on the <a href="#">hashCode</a> of elements.</p>
+<p>Warning: If there are two elements <a href="#">E</a> in the source list that have the same <a href="#">hashCode</a> then it is not deterministic
+which one will be removed if one is removed from the source list</p>
 <p>Example:
 val statesGroupedByCurrency = AggregatedList(states, { state -&gt; state.currency }) { currency, group -&gt;
 object {

docs/build/html/api/com.r3corda.client.fxutils/-aggregated-list/index.html

@@ -7,13 +7,16 @@
 <a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">AggregatedList</a><br/>
 <br/>
 <h1>AggregatedList</h1>
-<code><span class="keyword">class </span><span class="identifier">AggregatedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">E</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">E</span><span class="symbol">&gt;</span></code><br/>
+<code><span class="keyword">class </span><span class="identifier">AggregatedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">E</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">E</span><span class="symbol">&gt;</span></code><br/>
 <p>Given an <a href="#">ObservableList</a>&lt;<a href="#">E</a>&gt; and a grouping key <a href="#">K</a>, AggregatedList groups the elements by the key into a fresh
 <a href="#">ObservableList</a>&lt;<a href="#">E</a>&gt; for each group and exposes the groups as an observable list of <a href="#">A</a>s by calling <a href="assemble.html">assemble</a> on each.</p>
 <p>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 <a href="#">ObservableList</a>&lt;<a href="#">A</a>&gt; by
 adding/deleting aggregations as expected.</p>
-<p>The ordering of the exposed list is based on the <a href="#">hashCode</a> of keys.</p>
+<p>The ordering of the exposed list is based on the <a href="#">hashCode</a> of keys.
+The ordering of the groups themselves is based on the <a href="#">hashCode</a> of elements.</p>
+<p>Warning: If there are two elements <a href="#">E</a> in the source list that have the same <a href="#">hashCode</a> then it is not deterministic
+which one will be removed if one is removed from the source list</p>
 <p>Example:
 val statesGroupedByCurrency = AggregatedList(states, { state -&gt; state.currency }) { currency, group -&gt;
 object {
@@ -102,9 +105,30 @@ TODO Should we handle this case? It requires additional bookkeeping of sourceInd
 <tbody>
 <tr>
 <td>
+<a href="../javafx.collections.-observable-list/associate-by.html">associateBy</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p>data class Person(val height: Long)
+val people: ObservableList = (..)
+val nameToHeight: ObservableMap&lt;String, Long&gt; = people.associateBy(Person::name) { name, person -&gt; person.height }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val nameToPerson: ObservableMap&lt;String, Person&gt; = people.associateBy(Person::name)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by-aggregation.html">associateByAggregation</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToNames: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height) { name, person -&gt; person.name }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToPeople: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height)</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../javafx.collections.-observable-list/filter.html">filter</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
 val filterCriterion: ObservableValue = (..)
 val people: ObservableList = (..)
 fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .. }</p>
@@ -112,15 +136,36 @@ fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .
 </tr>
 <tr>
 <td>
-<a href="../javafx.collections.-observable-list/fold.html">fold</a></td>
+<a href="../javafx.collections.-observable-list/filter-not-null.html">filterNotNull</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">fold</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
-val concatenatedNames = people.fold("", { names, person -&gt; names + person.name })
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filterNotNull</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Dog(val owner: Person?)
+val dogs: ObservableList = (..)
+val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/first.html">first</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">first</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/fold-observable.html">foldObservable</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldObservable</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val concatenatedNames = people.foldObservable("", { names, person -&gt; names + person.name })
 val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
 </td>
 </tr>
 <tr>
 <td>
+<a href="../javafx.collections.-observable-list/get-value-at.html">getValueAt</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getValueAt</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getValueAt(javafx.collections.ObservableList((com.r3corda.client.fxutils.getValueAt.A)), kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
 <a href="../../com.r3corda.core/kotlin.collections.-list/index-of-or-throw.html">indexOfOrThrow</a></td>
 <td>
 <code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">List</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">indexOfOrThrow</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$indexOfOrThrow(kotlin.collections.List((com.r3corda.core.indexOfOrThrow.T)), com.r3corda.core.indexOfOrThrow.T)/item">item</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code><p>Returns the index of the given item or throws <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/IllegalArgumentException.html">IllegalArgumentException</a> if not found.</p>
@@ -128,9 +173,39 @@ val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
 </tr>
 <tr>
 <td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/is-ordered-and-unique.html">isOrderedAndUnique</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">, </span><span class="identifier">I</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Comparable</span><span class="symbol">&lt;</span><span class="identifier">I</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">isOrderedAndUnique</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$isOrderedAndUnique(kotlin.collections.Iterable((com.r3corda.core.isOrderedAndUnique.T)), kotlin.Function1((com.r3corda.core.isOrderedAndUnique.T, com.r3corda.core.isOrderedAndUnique.I)))/extractId">extractId</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">.</span><span class="symbol">(</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">I</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code><p>Determine if an iterable data types contents are ordered and unique, based on their <a href="#">Comparable</a>.compareTo
+function.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/last.html">last</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">last</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/left-outer-join.html">leftOuterJoin</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><p>data class Person(val name: String, val managerName: String)
+val people: ObservableList = (..)
+val managerEmployeeMapping: ObservableList&lt;Pair&lt;Person, ObservableList&gt;&gt; =
+people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -&gt; Pair(manager, employees) }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>data class Person(name: String, favouriteSpecies: Species)
+data class Animal(name: String, species: Species)
+val people: ObservableList = (..)
+val animals: ObservableList = (..)
+val peopleToFavouriteAnimals: ObservableMap&lt;Species, Pair&lt;ObservableList, ObservableList&gt;&gt; =
+people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../javafx.collections.-observable-list/map.html">map</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/cached">cached</span><span class="symbol">:</span>&nbsp;<span class="identifier">Boolean</span>&nbsp;<span class="symbol">=</span>&nbsp;true<span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
 val dogOwners: ObservableList = dogs.map { it.owner }</p>
 </td>
 </tr>

docs/build/html/api/com.r3corda.client.fxutils/-associated-list/-init-.html

@@ -0,0 +1,25 @@
+<HTML>
+<HEAD>
+<title>AssociatedList.<init> - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">AssociatedList</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
+<br/>
+<h1>&lt;init&gt;</h1>
+<code><span class="identifier">AssociatedList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.AssociatedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.AssociatedList.A)), kotlin.Function1((com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.K)), kotlin.Function2((com.r3corda.client.fxutils.AssociatedList.K, com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.B)))/sourceList">sourceList</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.AssociatedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.AssociatedList.A)), kotlin.Function1((com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.K)), kotlin.Function2((com.r3corda.client.fxutils.AssociatedList.K, com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.AssociatedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.AssociatedList.A)), kotlin.Function1((com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.K)), kotlin.Function2((com.r3corda.client.fxutils.AssociatedList.K, com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span></code><br/>
+<p><a href="index.html">AssociatedList</a> creates an <a href="#">ObservableMap</a> from an <a href="#">ObservableList</a> by associating each list element with a unique key.
+It is <emph>not</emph> allowed to have several elements map to the same value</p>
+<h3>Parameters</h3>
+<a name="sourceList"></a>
+<code>sourceList</code> - The source list.<br/>
+<br/>
+<a name="toKey"></a>
+<code>toKey</code> - Function returning the key.<br/>
+<br/>
+<a name="assemble"></a>
+<code>assemble</code> - The function to assemble the final map element from the list element and the associated key.<br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-associated-list/index.html

@@ -0,0 +1,148 @@
+<HTML>
+<HEAD>
+<title>AssociatedList - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">AssociatedList</a><br/>
+<br/>
+<h1>AssociatedList</h1>
+<code><span class="keyword">class </span><span class="identifier">AssociatedList</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-read-only-backed-observable-map-base/index.html"><span class="identifier">ReadOnlyBackedObservableMapBase</span></a><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">Unit</span><span class="symbol">&gt;</span></code><br/>
+<p>AssociatedList creates an <a href="#">ObservableMap</a> from an <a href="#">ObservableList</a> by associating each list element with a unique key.
+It is <emph>not</emph> allowed to have several elements map to the same value</p>
+<h3>Parameters</h3>
+<a name="sourceList"></a>
+<code>sourceList</code> - The source list.<br/>
+<br/>
+<a name="toKey"></a>
+<code>toKey</code> - Function returning the key.<br/>
+<br/>
+<a name="assemble"></a>
+<code>assemble</code> - The function to assemble the final map element from the list element and the associated key.<br/>
+<br/>
+<br/>
+<h3>Constructors</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="-init-.html">&lt;init&gt;</a></td>
+<td>
+<code><span class="identifier">AssociatedList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.AssociatedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.AssociatedList.A)), kotlin.Function1((com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.K)), kotlin.Function2((com.r3corda.client.fxutils.AssociatedList.K, com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.B)))/sourceList">sourceList</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.AssociatedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.AssociatedList.A)), kotlin.Function1((com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.K)), kotlin.Function2((com.r3corda.client.fxutils.AssociatedList.K, com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.AssociatedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.AssociatedList.A)), kotlin.Function1((com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.K)), kotlin.Function2((com.r3corda.client.fxutils.AssociatedList.K, com.r3corda.client.fxutils.AssociatedList.A, com.r3corda.client.fxutils.AssociatedList.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span></code><p>AssociatedList creates an <a href="#">ObservableMap</a> from an <a href="#">ObservableList</a> by associating each list element with a unique key.
+It is <emph>not</emph> allowed to have several elements map to the same value</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="source-list.html">sourceList</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">sourceList</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Inherited Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/backing-map.html">backingMap</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">backingMap</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/HashMap.html"><span class="identifier">HashMap</span></a><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/entries.html">entries</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">entries</span><span class="symbol">: </span><span class="identifier">MutableSet</span><span class="symbol">&lt;</span><span class="identifier">MutableEntry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/keys.html">keys</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">keys</span><span class="symbol">: </span><span class="identifier">MutableSet</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/size.html">size</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">size</span><span class="symbol">: </span><span class="identifier">Int</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/values.html">values</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">values</span><span class="symbol">: </span><span class="identifier">MutableCollection</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Inherited Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/add-listener.html">addListener</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">addListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$addListener(javafx.beans.InvalidationListener)/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">InvalidationListener</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/clear.html">clear</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">clear</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/is-empty.html">isEmpty</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">isEmpty</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/remove-listener.html">removeListener</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">removeListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$removeListener(javafx.beans.InvalidationListener)/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">InvalidationListener</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Extension Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/create-map-change.html">createMapChange</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">K</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">createMapChange</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/removedValue">removedValue</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/addedValue">addedValue</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Change</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/get-observable-entries.html">getObservableEntries</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableEntries</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">Entry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val people: ObservableList = nameToPerson.getObservableValues()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/get-observable-value.html">getObservableValue</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableValue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getObservableValue(javafx.collections.ObservableMap((com.r3corda.client.fxutils.getObservableValue.K, com.r3corda.client.fxutils.getObservableValue.V)), com.r3corda.client.fxutils.getObservableValue.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">V</span><span class="symbol">?</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val john: ObservableValue&lt;Person?&gt; = nameToPerson.getObservableValue("John")</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/get-observable-values.html">getObservableValues</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableValues</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">V</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val people: ObservableList = nameToPerson.getObservableValues()</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-associated-list/source-list.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>AssociatedList.sourceList - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">AssociatedList</a>&nbsp;/&nbsp;<a href=".">sourceList</a><br/>
+<br/>
+<h1>sourceList</h1>
+<a name="com.r3corda.client.fxutils.AssociatedList$sourceList"></a>
+<code><span class="keyword">val </span><span class="identifier">sourceList</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-chosen-list/index.html

@@ -62,9 +62,30 @@ is (ByIssuer) -> statesFilteredByIssuer
 <tbody>
 <tr>
 <td>
+<a href="../javafx.collections.-observable-list/associate-by.html">associateBy</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p>data class Person(val height: Long)
+val people: ObservableList = (..)
+val nameToHeight: ObservableMap&lt;String, Long&gt; = people.associateBy(Person::name) { name, person -&gt; person.height }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val nameToPerson: ObservableMap&lt;String, Person&gt; = people.associateBy(Person::name)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by-aggregation.html">associateByAggregation</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToNames: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height) { name, person -&gt; person.name }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToPeople: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height)</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../javafx.collections.-observable-list/filter.html">filter</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
 val filterCriterion: ObservableValue = (..)
 val people: ObservableList = (..)
 fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .. }</p>
@@ -72,15 +93,36 @@ fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .
 </tr>
 <tr>
 <td>
-<a href="../javafx.collections.-observable-list/fold.html">fold</a></td>
+<a href="../javafx.collections.-observable-list/filter-not-null.html">filterNotNull</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">fold</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
-val concatenatedNames = people.fold("", { names, person -&gt; names + person.name })
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filterNotNull</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Dog(val owner: Person?)
+val dogs: ObservableList = (..)
+val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/first.html">first</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">first</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/fold-observable.html">foldObservable</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldObservable</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val concatenatedNames = people.foldObservable("", { names, person -&gt; names + person.name })
 val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
 </td>
 </tr>
 <tr>
 <td>
+<a href="../javafx.collections.-observable-list/get-value-at.html">getValueAt</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getValueAt</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getValueAt(javafx.collections.ObservableList((com.r3corda.client.fxutils.getValueAt.A)), kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
 <a href="../../com.r3corda.core/kotlin.collections.-list/index-of-or-throw.html">indexOfOrThrow</a></td>
 <td>
 <code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">List</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">indexOfOrThrow</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$indexOfOrThrow(kotlin.collections.List((com.r3corda.core.indexOfOrThrow.T)), com.r3corda.core.indexOfOrThrow.T)/item">item</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code><p>Returns the index of the given item or throws <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/IllegalArgumentException.html">IllegalArgumentException</a> if not found.</p>
@@ -88,9 +130,39 @@ val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
 </tr>
 <tr>
 <td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/is-ordered-and-unique.html">isOrderedAndUnique</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">, </span><span class="identifier">I</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Comparable</span><span class="symbol">&lt;</span><span class="identifier">I</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">isOrderedAndUnique</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$isOrderedAndUnique(kotlin.collections.Iterable((com.r3corda.core.isOrderedAndUnique.T)), kotlin.Function1((com.r3corda.core.isOrderedAndUnique.T, com.r3corda.core.isOrderedAndUnique.I)))/extractId">extractId</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">.</span><span class="symbol">(</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">I</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code><p>Determine if an iterable data types contents are ordered and unique, based on their <a href="#">Comparable</a>.compareTo
+function.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/last.html">last</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">last</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/left-outer-join.html">leftOuterJoin</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><p>data class Person(val name: String, val managerName: String)
+val people: ObservableList = (..)
+val managerEmployeeMapping: ObservableList&lt;Pair&lt;Person, ObservableList&gt;&gt; =
+people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -&gt; Pair(manager, employees) }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>data class Person(name: String, favouriteSpecies: Species)
+data class Animal(name: String, species: Species)
+val people: ObservableList = (..)
+val animals: ObservableList = (..)
+val peopleToFavouriteAnimals: ObservableMap&lt;Species, Pair&lt;ObservableList, ObservableList&gt;&gt; =
+people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../javafx.collections.-observable-list/map.html">map</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/cached">cached</span><span class="symbol">:</span>&nbsp;<span class="identifier">Boolean</span>&nbsp;<span class="symbol">=</span>&nbsp;true<span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
 val dogOwners: ObservableList = dogs.map { it.owner }</p>
 </td>
 </tr>

docs/build/html/api/com.r3corda.client.fxutils/-concatenated-list/-init-.html

@@ -0,0 +1,16 @@
+<HTML>
+<HEAD>
+<title>ConcatenatedList.<init> - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ConcatenatedList</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
+<br/>
+<h1>&lt;init&gt;</h1>
+<code><span class="identifier">ConcatenatedList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ConcatenatedList$<init>(javafx.collections.ObservableList((javafx.collections.ObservableList((com.r3corda.client.fxutils.ConcatenatedList.A)))))/sourceList">sourceList</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><br/>
+<p><a href="index.html">ConcatenatedList</a> takes a list of lists and concatenates them. Any change to the underlying lists or the outer list
+is propagated as expected.</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-concatenated-list/get-source-index.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ConcatenatedList.getSourceIndex - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ConcatenatedList</a>&nbsp;/&nbsp;<a href=".">getSourceIndex</a><br/>
+<br/>
+<h1>getSourceIndex</h1>
+<a name="com.r3corda.client.fxutils.ConcatenatedList$getSourceIndex(kotlin.Int)"></a>
+<code><span class="keyword">fun </span><span class="identifier">getSourceIndex</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ConcatenatedList$getSourceIndex(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-concatenated-list/get.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ConcatenatedList.get - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ConcatenatedList</a>&nbsp;/&nbsp;<a href=".">get</a><br/>
+<br/>
+<h1>get</h1>
+<a name="com.r3corda.client.fxutils.ConcatenatedList$get(kotlin.Int)"></a>
+<code><span class="keyword">fun </span><span class="identifier">get</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ConcatenatedList$get(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">A</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-concatenated-list/index.html

@@ -0,0 +1,183 @@
+<HTML>
+<HEAD>
+<title>ConcatenatedList - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">ConcatenatedList</a><br/>
+<br/>
+<h1>ConcatenatedList</h1>
+<code><span class="keyword">class </span><span class="identifier">ConcatenatedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
+<p>ConcatenatedList takes a list of lists and concatenates them. Any change to the underlying lists or the outer list
+is propagated as expected.</p>
+<br/>
+<br/>
+<h3>Constructors</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="-init-.html">&lt;init&gt;</a></td>
+<td>
+<code><span class="identifier">ConcatenatedList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ConcatenatedList$<init>(javafx.collections.ObservableList((javafx.collections.ObservableList((com.r3corda.client.fxutils.ConcatenatedList.A)))))/sourceList">sourceList</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><p>ConcatenatedList takes a list of lists and concatenates them. Any change to the underlying lists or the outer list
+is propagated as expected.</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="size.html">size</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">size</span><span class="symbol">: </span><span class="identifier">Int</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="get.html">get</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">get</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ConcatenatedList$get(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">A</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="get-source-index.html">getSourceIndex</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">getSourceIndex</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ConcatenatedList$getSourceIndex(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="source-changed.html">sourceChanged</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">sourceChanged</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ConcatenatedList$sourceChanged(javafx.collections.ListChangeListener.Change((javafx.collections.ObservableList((com.r3corda.client.fxutils.ConcatenatedList.A)))))/change">change</span><span class="symbol">:</span>&nbsp;<span class="identifier">Change</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Extension Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by.html">associateBy</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p>data class Person(val height: Long)
+val people: ObservableList = (..)
+val nameToHeight: ObservableMap&lt;String, Long&gt; = people.associateBy(Person::name) { name, person -&gt; person.height }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val nameToPerson: ObservableMap&lt;String, Person&gt; = people.associateBy(Person::name)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by-aggregation.html">associateByAggregation</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToNames: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height) { name, person -&gt; person.name }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToPeople: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/filter.html">filter</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
+val filterCriterion: ObservableValue = (..)
+val people: ObservableList = (..)
+fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .. }</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/filter-not-null.html">filterNotNull</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filterNotNull</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Dog(val owner: Person?)
+val dogs: ObservableList = (..)
+val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/first.html">first</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">first</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/fold-observable.html">foldObservable</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldObservable</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val concatenatedNames = people.foldObservable("", { names, person -&gt; names + person.name })
+val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/get-value-at.html">getValueAt</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getValueAt</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getValueAt(javafx.collections.ObservableList((com.r3corda.client.fxutils.getValueAt.A)), kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-list/index-of-or-throw.html">indexOfOrThrow</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">List</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">indexOfOrThrow</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$indexOfOrThrow(kotlin.collections.List((com.r3corda.core.indexOfOrThrow.T)), com.r3corda.core.indexOfOrThrow.T)/item">item</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code><p>Returns the index of the given item or throws <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/IllegalArgumentException.html">IllegalArgumentException</a> if not found.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/is-ordered-and-unique.html">isOrderedAndUnique</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">, </span><span class="identifier">I</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Comparable</span><span class="symbol">&lt;</span><span class="identifier">I</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">isOrderedAndUnique</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$isOrderedAndUnique(kotlin.collections.Iterable((com.r3corda.core.isOrderedAndUnique.T)), kotlin.Function1((com.r3corda.core.isOrderedAndUnique.T, com.r3corda.core.isOrderedAndUnique.I)))/extractId">extractId</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">.</span><span class="symbol">(</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">I</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code><p>Determine if an iterable data types contents are ordered and unique, based on their <a href="#">Comparable</a>.compareTo
+function.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/last.html">last</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">last</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/left-outer-join.html">leftOuterJoin</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><p>data class Person(val name: String, val managerName: String)
+val people: ObservableList = (..)
+val managerEmployeeMapping: ObservableList&lt;Pair&lt;Person, ObservableList&gt;&gt; =
+people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -&gt; Pair(manager, employees) }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>data class Person(name: String, favouriteSpecies: Species)
+data class Animal(name: String, species: Species)
+val people: ObservableList = (..)
+val animals: ObservableList = (..)
+val peopleToFavouriteAnimals: ObservableMap&lt;Species, Pair&lt;ObservableList, ObservableList&gt;&gt; =
+people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/map.html">map</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/cached">cached</span><span class="symbol">:</span>&nbsp;<span class="identifier">Boolean</span>&nbsp;<span class="symbol">=</span>&nbsp;true<span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
+val dogOwners: ObservableList = dogs.map { it.owner }</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/none-or-single.html">noneOrSingle</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">noneOrSingle</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$noneOrSingle(kotlin.collections.Iterable((com.r3corda.core.noneOrSingle.T)), kotlin.Function1((com.r3corda.core.noneOrSingle.T, kotlin.Boolean)))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">T</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">T</span><span class="symbol">?</span></code><p>Returns the single element matching the given <a href="../../com.r3corda.core/kotlin.collections.-iterable/none-or-single.html#com.r3corda.core$noneOrSingle(kotlin.collections.Iterable((com.r3corda.core.noneOrSingle.T)), kotlin.Function1((com.r3corda.core.noneOrSingle.T, kotlin.Boolean)))/predicate">predicate</a>, or <code>null</code> if element was not found,
+or throws if more than one element was found.</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">noneOrSingle</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">T</span><span class="symbol">?</span></code><p>Returns single element, or <code>null</code> if element was not found, or throws if more than one element was found.</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-concatenated-list/size.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ConcatenatedList.size - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ConcatenatedList</a>&nbsp;/&nbsp;<a href=".">size</a><br/>
+<br/>
+<h1>size</h1>
+<a name="com.r3corda.client.fxutils.ConcatenatedList$size"></a>
+<code><span class="keyword">val </span><span class="identifier">size</span><span class="symbol">: </span><span class="identifier">Int</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-concatenated-list/source-changed.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ConcatenatedList.sourceChanged - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ConcatenatedList</a>&nbsp;/&nbsp;<a href=".">sourceChanged</a><br/>
+<br/>
+<h1>sourceChanged</h1>
+<a name="com.r3corda.client.fxutils.ConcatenatedList$sourceChanged(javafx.collections.ListChangeListener.Change((javafx.collections.ObservableList((com.r3corda.client.fxutils.ConcatenatedList.A)))))"></a>
+<code><span class="keyword">protected</span> <span class="keyword">fun </span><span class="identifier">sourceChanged</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ConcatenatedList$sourceChanged(javafx.collections.ListChangeListener.Change((javafx.collections.ObservableList((com.r3corda.client.fxutils.ConcatenatedList.A)))))/change">change</span><span class="symbol">:</span>&nbsp;<span class="identifier">Change</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-flattened-list/index.html

@@ -90,9 +90,30 @@ are reflected in the exposed list as expected.</p>
 <tbody>
 <tr>
 <td>
+<a href="../javafx.collections.-observable-list/associate-by.html">associateBy</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p>data class Person(val height: Long)
+val people: ObservableList = (..)
+val nameToHeight: ObservableMap&lt;String, Long&gt; = people.associateBy(Person::name) { name, person -&gt; person.height }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val nameToPerson: ObservableMap&lt;String, Person&gt; = people.associateBy(Person::name)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by-aggregation.html">associateByAggregation</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToNames: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height) { name, person -&gt; person.name }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToPeople: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height)</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../javafx.collections.-observable-list/filter.html">filter</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
 val filterCriterion: ObservableValue = (..)
 val people: ObservableList = (..)
 fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .. }</p>
@@ -100,15 +121,36 @@ fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .
 </tr>
 <tr>
 <td>
-<a href="../javafx.collections.-observable-list/fold.html">fold</a></td>
+<a href="../javafx.collections.-observable-list/filter-not-null.html">filterNotNull</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">fold</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
-val concatenatedNames = people.fold("", { names, person -&gt; names + person.name })
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filterNotNull</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Dog(val owner: Person?)
+val dogs: ObservableList = (..)
+val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/first.html">first</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">first</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/fold-observable.html">foldObservable</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldObservable</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val concatenatedNames = people.foldObservable("", { names, person -&gt; names + person.name })
 val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
 </td>
 </tr>
 <tr>
 <td>
+<a href="../javafx.collections.-observable-list/get-value-at.html">getValueAt</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getValueAt</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getValueAt(javafx.collections.ObservableList((com.r3corda.client.fxutils.getValueAt.A)), kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
 <a href="../../com.r3corda.core/kotlin.collections.-list/index-of-or-throw.html">indexOfOrThrow</a></td>
 <td>
 <code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">List</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">indexOfOrThrow</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$indexOfOrThrow(kotlin.collections.List((com.r3corda.core.indexOfOrThrow.T)), com.r3corda.core.indexOfOrThrow.T)/item">item</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code><p>Returns the index of the given item or throws <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/IllegalArgumentException.html">IllegalArgumentException</a> if not found.</p>
@@ -116,9 +158,39 @@ val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
 </tr>
 <tr>
 <td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/is-ordered-and-unique.html">isOrderedAndUnique</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">, </span><span class="identifier">I</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Comparable</span><span class="symbol">&lt;</span><span class="identifier">I</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">isOrderedAndUnique</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$isOrderedAndUnique(kotlin.collections.Iterable((com.r3corda.core.isOrderedAndUnique.T)), kotlin.Function1((com.r3corda.core.isOrderedAndUnique.T, com.r3corda.core.isOrderedAndUnique.I)))/extractId">extractId</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">.</span><span class="symbol">(</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">I</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code><p>Determine if an iterable data types contents are ordered and unique, based on their <a href="#">Comparable</a>.compareTo
+function.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/last.html">last</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">last</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/left-outer-join.html">leftOuterJoin</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><p>data class Person(val name: String, val managerName: String)
+val people: ObservableList = (..)
+val managerEmployeeMapping: ObservableList&lt;Pair&lt;Person, ObservableList&gt;&gt; =
+people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -&gt; Pair(manager, employees) }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>data class Person(name: String, favouriteSpecies: Species)
+data class Animal(name: String, species: Species)
+val people: ObservableList = (..)
+val animals: ObservableList = (..)
+val peopleToFavouriteAnimals: ObservableMap&lt;Species, Pair&lt;ObservableList, ObservableList&gt;&gt; =
+people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="../javafx.collections.-observable-list/map.html">map</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/cached">cached</span><span class="symbol">:</span>&nbsp;<span class="identifier">Boolean</span>&nbsp;<span class="symbol">=</span>&nbsp;true<span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
 val dogOwners: ObservableList = dogs.map { it.owner }</p>
 </td>
 </tr>

docs/build/html/api/com.r3corda.client.fxutils/-left-outer-joined-map/-init-.html

@@ -0,0 +1,16 @@
+<HTML>
+<HEAD>
+<title>LeftOuterJoinedMap.<init> - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">LeftOuterJoinedMap</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
+<br/>
+<h1>&lt;init&gt;</h1>
+<code><span class="identifier">LeftOuterJoinedMap</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.LeftOuterJoinedMap$<init>(javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A)), javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), kotlin.Function3((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), com.r3corda.client.fxutils.LeftOuterJoinedMap.C)))/leftTable">leftTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.LeftOuterJoinedMap$<init>(javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A)), javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), kotlin.Function3((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), com.r3corda.client.fxutils.LeftOuterJoinedMap.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.LeftOuterJoinedMap$<init>(javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A)), javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), kotlin.Function3((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), com.r3corda.client.fxutils.LeftOuterJoinedMap.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span></code><br/>
+<p><a href="index.html">LeftOuterJoinedMap</a> implements a special case of a left outer join where were matching on primary keys of both
+tables.</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-left-outer-joined-map/index.html

@@ -0,0 +1,145 @@
+<HTML>
+<HEAD>
+<title>LeftOuterJoinedMap - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">LeftOuterJoinedMap</a><br/>
+<br/>
+<h1>LeftOuterJoinedMap</h1>
+<code><span class="keyword">class </span><span class="identifier">LeftOuterJoinedMap</span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-read-only-backed-observable-map-base/index.html"><span class="identifier">ReadOnlyBackedObservableMapBase</span></a><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">C</span><span class="symbol">,</span>&nbsp;<span class="identifier">SimpleObjectProperty</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
+<p>LeftOuterJoinedMap implements a special case of a left outer join where were matching on primary keys of both
+tables.</p>
+<br/>
+<br/>
+<h3>Constructors</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="-init-.html">&lt;init&gt;</a></td>
+<td>
+<code><span class="identifier">LeftOuterJoinedMap</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.LeftOuterJoinedMap$<init>(javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A)), javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), kotlin.Function3((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), com.r3corda.client.fxutils.LeftOuterJoinedMap.C)))/leftTable">leftTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.LeftOuterJoinedMap$<init>(javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A)), javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), kotlin.Function3((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), com.r3corda.client.fxutils.LeftOuterJoinedMap.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.LeftOuterJoinedMap$<init>(javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A)), javafx.collections.ObservableMap((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), kotlin.Function3((com.r3corda.client.fxutils.LeftOuterJoinedMap.K, com.r3corda.client.fxutils.LeftOuterJoinedMap.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.LeftOuterJoinedMap.B)), com.r3corda.client.fxutils.LeftOuterJoinedMap.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span></code><p>LeftOuterJoinedMap implements a special case of a left outer join where were matching on primary keys of both
+tables.</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="left-table.html">leftTable</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">leftTable</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="right-table.html">rightTable</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">rightTable</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Inherited Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/backing-map.html">backingMap</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">backingMap</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/HashMap.html"><span class="identifier">HashMap</span></a><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/entries.html">entries</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">entries</span><span class="symbol">: </span><span class="identifier">MutableSet</span><span class="symbol">&lt;</span><span class="identifier">MutableEntry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/keys.html">keys</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">keys</span><span class="symbol">: </span><span class="identifier">MutableSet</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/size.html">size</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">size</span><span class="symbol">: </span><span class="identifier">Int</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/values.html">values</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">values</span><span class="symbol">: </span><span class="identifier">MutableCollection</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Inherited Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/add-listener.html">addListener</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">addListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$addListener(javafx.beans.InvalidationListener)/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">InvalidationListener</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/clear.html">clear</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">clear</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/is-empty.html">isEmpty</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">isEmpty</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../-read-only-backed-observable-map-base/remove-listener.html">removeListener</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">removeListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$removeListener(javafx.beans.InvalidationListener)/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">InvalidationListener</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Extension Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/create-map-change.html">createMapChange</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">K</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">createMapChange</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/removedValue">removedValue</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/addedValue">addedValue</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Change</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/get-observable-entries.html">getObservableEntries</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableEntries</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">Entry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val people: ObservableList = nameToPerson.getObservableValues()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/get-observable-value.html">getObservableValue</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableValue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getObservableValue(javafx.collections.ObservableMap((com.r3corda.client.fxutils.getObservableValue.K, com.r3corda.client.fxutils.getObservableValue.V)), com.r3corda.client.fxutils.getObservableValue.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">V</span><span class="symbol">?</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val john: ObservableValue&lt;Person?&gt; = nameToPerson.getObservableValue("John")</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/get-observable-values.html">getObservableValues</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableValues</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">V</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val people: ObservableList = nameToPerson.getObservableValues()</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-left-outer-joined-map/left-table.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>LeftOuterJoinedMap.leftTable - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">LeftOuterJoinedMap</a>&nbsp;/&nbsp;<a href=".">leftTable</a><br/>
+<br/>
+<h1>leftTable</h1>
+<a name="com.r3corda.client.fxutils.LeftOuterJoinedMap$leftTable"></a>
+<code><span class="keyword">val </span><span class="identifier">leftTable</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-left-outer-joined-map/right-table.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>LeftOuterJoinedMap.rightTable - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">LeftOuterJoinedMap</a>&nbsp;/&nbsp;<a href=".">rightTable</a><br/>
+<br/>
+<h1>rightTable</h1>
+<a name="com.r3corda.client.fxutils.LeftOuterJoinedMap$rightTable"></a>
+<code><span class="keyword">val </span><span class="identifier">rightTable</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-map-values-list/create.html

@@ -0,0 +1,22 @@
+<HTML>
+<HEAD>
+<title>MapValuesList.create - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">MapValuesList</a>&nbsp;/&nbsp;<a href=".">create</a><br/>
+<br/>
+<h1>create</h1>
+<a name="com.r3corda.client.fxutils.MapValuesList.Companion$create(javafx.collections.ObservableMap((com.r3corda.client.fxutils.MapValuesList.Companion.create.K, com.r3corda.client.fxutils.MapValuesList.Companion.create.A)), kotlin.Function1((kotlin.collections.Map.Entry((com.r3corda.client.fxutils.MapValuesList.Companion.create.K, com.r3corda.client.fxutils.MapValuesList.Companion.create.A)), com.r3corda.client.fxutils.MapValuesList.Companion.create.C)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span> <span class="identifier">create</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.MapValuesList.Companion$create(javafx.collections.ObservableMap((com.r3corda.client.fxutils.MapValuesList.Companion.create.K, com.r3corda.client.fxutils.MapValuesList.Companion.create.A)), kotlin.Function1((kotlin.collections.Map.Entry((com.r3corda.client.fxutils.MapValuesList.Companion.create.K, com.r3corda.client.fxutils.MapValuesList.Companion.create.A)), com.r3corda.client.fxutils.MapValuesList.Companion.create.C)))/sourceMap">sourceMap</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.MapValuesList.Companion$create(javafx.collections.ObservableMap((com.r3corda.client.fxutils.MapValuesList.Companion.create.K, com.r3corda.client.fxutils.MapValuesList.Companion.create.A)), kotlin.Function1((kotlin.collections.Map.Entry((com.r3corda.client.fxutils.MapValuesList.Companion.create.K, com.r3corda.client.fxutils.MapValuesList.Companion.create.A)), com.r3corda.client.fxutils.MapValuesList.Companion.create.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">Entry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><a href="index.html"><span class="identifier">MapValuesList</span></a><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">C</span><span class="symbol">&gt;</span></code><br/>
+<p>create is the factory of <a href="index.html">MapValuesList</a>.</p>
+<h3>Parameters</h3>
+<a name="sourceMap"></a>
+<code>sourceMap</code> - The source map.<br/>
+<br/>
+<a name="assemble"></a>
+<code>assemble</code> - The function to be called for map each entry to construct the final list elements.<br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-map-values-list/index.html

@@ -0,0 +1,159 @@
+<HTML>
+<HEAD>
+<title>MapValuesList - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">MapValuesList</a><br/>
+<br/>
+<h1>MapValuesList</h1>
+<code><span class="keyword">class </span><span class="identifier">MapValuesList</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><br/>
+<p>MapValuesList takes an <a href="#">ObservableMap</a> and returns its values as an <a href="#">ObservableList</a>.
+The order of returned elements is deterministic but unspecified.</p>
+<br/>
+<br/>
+<h3>Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="source-map.html">sourceMap</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">sourceMap</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Companion Object Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="create.html">create</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span> <span class="identifier">create</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.MapValuesList.Companion$create(javafx.collections.ObservableMap((com.r3corda.client.fxutils.MapValuesList.Companion.create.K, com.r3corda.client.fxutils.MapValuesList.Companion.create.A)), kotlin.Function1((kotlin.collections.Map.Entry((com.r3corda.client.fxutils.MapValuesList.Companion.create.K, com.r3corda.client.fxutils.MapValuesList.Companion.create.A)), com.r3corda.client.fxutils.MapValuesList.Companion.create.C)))/sourceMap">sourceMap</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.MapValuesList.Companion$create(javafx.collections.ObservableMap((com.r3corda.client.fxutils.MapValuesList.Companion.create.K, com.r3corda.client.fxutils.MapValuesList.Companion.create.A)), kotlin.Function1((kotlin.collections.Map.Entry((com.r3corda.client.fxutils.MapValuesList.Companion.create.K, com.r3corda.client.fxutils.MapValuesList.Companion.create.A)), com.r3corda.client.fxutils.MapValuesList.Companion.create.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">Entry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">MapValuesList</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">C</span><span class="symbol">&gt;</span></code><p><a href="create.html">create</a> is the factory of MapValuesList.</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Extension Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by.html">associateBy</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p>data class Person(val height: Long)
+val people: ObservableList = (..)
+val nameToHeight: ObservableMap&lt;String, Long&gt; = people.associateBy(Person::name) { name, person -&gt; person.height }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val nameToPerson: ObservableMap&lt;String, Person&gt; = people.associateBy(Person::name)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by-aggregation.html">associateByAggregation</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToNames: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height) { name, person -&gt; person.name }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToPeople: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/filter.html">filter</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
+val filterCriterion: ObservableValue = (..)
+val people: ObservableList = (..)
+fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .. }</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/filter-not-null.html">filterNotNull</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filterNotNull</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Dog(val owner: Person?)
+val dogs: ObservableList = (..)
+val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/first.html">first</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">first</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/fold-observable.html">foldObservable</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldObservable</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val concatenatedNames = people.foldObservable("", { names, person -&gt; names + person.name })
+val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/get-value-at.html">getValueAt</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getValueAt</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getValueAt(javafx.collections.ObservableList((com.r3corda.client.fxutils.getValueAt.A)), kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-list/index-of-or-throw.html">indexOfOrThrow</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">List</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">indexOfOrThrow</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$indexOfOrThrow(kotlin.collections.List((com.r3corda.core.indexOfOrThrow.T)), com.r3corda.core.indexOfOrThrow.T)/item">item</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code><p>Returns the index of the given item or throws <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/IllegalArgumentException.html">IllegalArgumentException</a> if not found.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/is-ordered-and-unique.html">isOrderedAndUnique</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">, </span><span class="identifier">I</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Comparable</span><span class="symbol">&lt;</span><span class="identifier">I</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">isOrderedAndUnique</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$isOrderedAndUnique(kotlin.collections.Iterable((com.r3corda.core.isOrderedAndUnique.T)), kotlin.Function1((com.r3corda.core.isOrderedAndUnique.T, com.r3corda.core.isOrderedAndUnique.I)))/extractId">extractId</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">.</span><span class="symbol">(</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">I</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code><p>Determine if an iterable data types contents are ordered and unique, based on their <a href="#">Comparable</a>.compareTo
+function.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/last.html">last</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">last</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/left-outer-join.html">leftOuterJoin</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><p>data class Person(val name: String, val managerName: String)
+val people: ObservableList = (..)
+val managerEmployeeMapping: ObservableList&lt;Pair&lt;Person, ObservableList&gt;&gt; =
+people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -&gt; Pair(manager, employees) }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>data class Person(name: String, favouriteSpecies: Species)
+data class Animal(name: String, species: Species)
+val people: ObservableList = (..)
+val animals: ObservableList = (..)
+val peopleToFavouriteAnimals: ObservableMap&lt;Species, Pair&lt;ObservableList, ObservableList&gt;&gt; =
+people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/map.html">map</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/cached">cached</span><span class="symbol">:</span>&nbsp;<span class="identifier">Boolean</span>&nbsp;<span class="symbol">=</span>&nbsp;true<span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
+val dogOwners: ObservableList = dogs.map { it.owner }</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/none-or-single.html">noneOrSingle</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">noneOrSingle</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$noneOrSingle(kotlin.collections.Iterable((com.r3corda.core.noneOrSingle.T)), kotlin.Function1((com.r3corda.core.noneOrSingle.T, kotlin.Boolean)))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">T</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">T</span><span class="symbol">?</span></code><p>Returns the single element matching the given <a href="../../com.r3corda.core/kotlin.collections.-iterable/none-or-single.html#com.r3corda.core$noneOrSingle(kotlin.collections.Iterable((com.r3corda.core.noneOrSingle.T)), kotlin.Function1((com.r3corda.core.noneOrSingle.T, kotlin.Boolean)))/predicate">predicate</a>, or <code>null</code> if element was not found,
+or throws if more than one element was found.</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">noneOrSingle</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">T</span><span class="symbol">?</span></code><p>Returns single element, or <code>null</code> if element was not found, or throws if more than one element was found.</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-map-values-list/source-map.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>MapValuesList.sourceMap - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">MapValuesList</a>&nbsp;/&nbsp;<a href=".">sourceMap</a><br/>
+<br/>
+<h1>sourceMap</h1>
+<a name="com.r3corda.client.fxutils.MapValuesList$sourceMap"></a>
+<code><span class="keyword">val </span><span class="identifier">sourceMap</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-mapped-list/-init-.html

@@ -0,0 +1,17 @@
+<HTML>
+<HEAD>
+<title>MappedList.<init> - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">MappedList</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
+<br/>
+<h1>&lt;init&gt;</h1>
+<code><span class="identifier">MappedList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.MappedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.MappedList.A)), kotlin.Function1((com.r3corda.client.fxutils.MappedList.A, com.r3corda.client.fxutils.MappedList.B)))/list">list</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.MappedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.MappedList.A)), kotlin.Function1((com.r3corda.client.fxutils.MappedList.A, com.r3corda.client.fxutils.MappedList.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span></code><br/>
+<p>This is a variant of <a href="#">EasyBind.map</a> 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 <a href="#">EasyBind.map</a> to trade off memory vs CPU, or if (god forbid) the mapped function is side-effecting.</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-mapped-list/function.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>MappedList.function - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">MappedList</a>&nbsp;/&nbsp;<a href=".">function</a><br/>
+<br/>
+<h1>function</h1>
+<a name="com.r3corda.client.fxutils.MappedList$function"></a>
+<code><span class="keyword">val </span><span class="identifier">function</span><span class="symbol">: </span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-mapped-list/get-source-index.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>MappedList.getSourceIndex - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">MappedList</a>&nbsp;/&nbsp;<a href=".">getSourceIndex</a><br/>
+<br/>
+<h1>getSourceIndex</h1>
+<a name="com.r3corda.client.fxutils.MappedList$getSourceIndex(kotlin.Int)"></a>
+<code><span class="keyword">fun </span><span class="identifier">getSourceIndex</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.MappedList$getSourceIndex(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-mapped-list/get.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>MappedList.get - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">MappedList</a>&nbsp;/&nbsp;<a href=".">get</a><br/>
+<br/>
+<h1>get</h1>
+<a name="com.r3corda.client.fxutils.MappedList$get(kotlin.Int)"></a>
+<code><span class="keyword">fun </span><span class="identifier">get</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.MappedList$get(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">B</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-mapped-list/index.html

@@ -0,0 +1,191 @@
+<HTML>
+<HEAD>
+<title>MappedList - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">MappedList</a><br/>
+<br/>
+<h1>MappedList</h1>
+<code><span class="keyword">class </span><span class="identifier">MappedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<p>This is a variant of <a href="#">EasyBind.map</a> 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 <a href="#">EasyBind.map</a> to trade off memory vs CPU, or if (god forbid) the mapped function is side-effecting.</p>
+<br/>
+<br/>
+<h3>Constructors</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="-init-.html">&lt;init&gt;</a></td>
+<td>
+<code><span class="identifier">MappedList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.MappedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.MappedList.A)), kotlin.Function1((com.r3corda.client.fxutils.MappedList.A, com.r3corda.client.fxutils.MappedList.B)))/list">list</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.MappedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.MappedList.A)), kotlin.Function1((com.r3corda.client.fxutils.MappedList.A, com.r3corda.client.fxutils.MappedList.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span></code><p>This is a variant of <a href="#">EasyBind.map</a> 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 <a href="#">EasyBind.map</a> to trade off memory vs CPU, or if (god forbid) the mapped function is side-effecting.</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="function.html">function</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">function</span><span class="symbol">: </span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="size.html">size</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">size</span><span class="symbol">: </span><span class="identifier">Int</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="get.html">get</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">get</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.MappedList$get(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">B</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="get-source-index.html">getSourceIndex</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">getSourceIndex</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.MappedList$getSourceIndex(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="source-changed.html">sourceChanged</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">sourceChanged</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.MappedList$sourceChanged(javafx.collections.ListChangeListener.Change((com.r3corda.client.fxutils.MappedList.A)))/change">change</span><span class="symbol">:</span>&nbsp;<span class="identifier">Change</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Extension Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by.html">associateBy</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p>data class Person(val height: Long)
+val people: ObservableList = (..)
+val nameToHeight: ObservableMap&lt;String, Long&gt; = people.associateBy(Person::name) { name, person -&gt; person.height }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val nameToPerson: ObservableMap&lt;String, Person&gt; = people.associateBy(Person::name)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by-aggregation.html">associateByAggregation</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToNames: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height) { name, person -&gt; person.name }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToPeople: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/filter.html">filter</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
+val filterCriterion: ObservableValue = (..)
+val people: ObservableList = (..)
+fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .. }</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/filter-not-null.html">filterNotNull</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filterNotNull</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Dog(val owner: Person?)
+val dogs: ObservableList = (..)
+val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/first.html">first</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">first</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/fold-observable.html">foldObservable</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldObservable</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val concatenatedNames = people.foldObservable("", { names, person -&gt; names + person.name })
+val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/get-value-at.html">getValueAt</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getValueAt</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getValueAt(javafx.collections.ObservableList((com.r3corda.client.fxutils.getValueAt.A)), kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-list/index-of-or-throw.html">indexOfOrThrow</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">List</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">indexOfOrThrow</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$indexOfOrThrow(kotlin.collections.List((com.r3corda.core.indexOfOrThrow.T)), com.r3corda.core.indexOfOrThrow.T)/item">item</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code><p>Returns the index of the given item or throws <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/IllegalArgumentException.html">IllegalArgumentException</a> if not found.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/is-ordered-and-unique.html">isOrderedAndUnique</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">, </span><span class="identifier">I</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Comparable</span><span class="symbol">&lt;</span><span class="identifier">I</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">isOrderedAndUnique</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$isOrderedAndUnique(kotlin.collections.Iterable((com.r3corda.core.isOrderedAndUnique.T)), kotlin.Function1((com.r3corda.core.isOrderedAndUnique.T, com.r3corda.core.isOrderedAndUnique.I)))/extractId">extractId</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">.</span><span class="symbol">(</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">I</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code><p>Determine if an iterable data types contents are ordered and unique, based on their <a href="#">Comparable</a>.compareTo
+function.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/last.html">last</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">last</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/left-outer-join.html">leftOuterJoin</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><p>data class Person(val name: String, val managerName: String)
+val people: ObservableList = (..)
+val managerEmployeeMapping: ObservableList&lt;Pair&lt;Person, ObservableList&gt;&gt; =
+people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -&gt; Pair(manager, employees) }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>data class Person(name: String, favouriteSpecies: Species)
+data class Animal(name: String, species: Species)
+val people: ObservableList = (..)
+val animals: ObservableList = (..)
+val peopleToFavouriteAnimals: ObservableMap&lt;Species, Pair&lt;ObservableList, ObservableList&gt;&gt; =
+people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/map.html">map</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/cached">cached</span><span class="symbol">:</span>&nbsp;<span class="identifier">Boolean</span>&nbsp;<span class="symbol">=</span>&nbsp;true<span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
+val dogOwners: ObservableList = dogs.map { it.owner }</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/none-or-single.html">noneOrSingle</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">noneOrSingle</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$noneOrSingle(kotlin.collections.Iterable((com.r3corda.core.noneOrSingle.T)), kotlin.Function1((com.r3corda.core.noneOrSingle.T, kotlin.Boolean)))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">T</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">T</span><span class="symbol">?</span></code><p>Returns the single element matching the given <a href="../../com.r3corda.core/kotlin.collections.-iterable/none-or-single.html#com.r3corda.core$noneOrSingle(kotlin.collections.Iterable((com.r3corda.core.noneOrSingle.T)), kotlin.Function1((com.r3corda.core.noneOrSingle.T, kotlin.Boolean)))/predicate">predicate</a>, or <code>null</code> if element was not found,
+or throws if more than one element was found.</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">noneOrSingle</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">T</span><span class="symbol">?</span></code><p>Returns single element, or <code>null</code> if element was not found, or throws if more than one element was found.</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-mapped-list/size.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>MappedList.size - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">MappedList</a>&nbsp;/&nbsp;<a href=".">size</a><br/>
+<br/>
+<h1>size</h1>
+<a name="com.r3corda.client.fxutils.MappedList$size"></a>
+<code><span class="keyword">val </span><span class="identifier">size</span><span class="symbol">: </span><span class="identifier">Int</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-mapped-list/source-changed.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>MappedList.sourceChanged - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">MappedList</a>&nbsp;/&nbsp;<a href=".">sourceChanged</a><br/>
+<br/>
+<h1>sourceChanged</h1>
+<a name="com.r3corda.client.fxutils.MappedList$sourceChanged(javafx.collections.ListChangeListener.Change((com.r3corda.client.fxutils.MappedList.A)))"></a>
+<code><span class="keyword">protected</span> <span class="keyword">fun </span><span class="identifier">sourceChanged</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.MappedList$sourceChanged(javafx.collections.ListChangeListener.Change((com.r3corda.client.fxutils.MappedList.A)))/change">change</span><span class="symbol">:</span>&nbsp;<span class="identifier">Change</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/-init-.html

@@ -0,0 +1,28 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.<init> - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
+<br/>
+<h1>&lt;init&gt;</h1>
+<code><span class="identifier">ReadOnlyBackedObservableMapBase</span><span class="symbol">(</span><span class="symbol">)</span></code><br/>
+<p><a href="index.html">ReadOnlyBackedObservableMapBase</a> is a base class implementing all abstract functions required for an <a href="#">ObservableMap</a>
+using a backing HashMap that subclasses should modify.</p>
+<p>Non-read-only API calls throw.</p>
+<br/>
+<br/>
+<h3>Parameters</h3>
+<a name="K"></a>
+<code>K</code> - The key type.<br/>
+<br/>
+<a name="A"></a>
+<code>A</code> - The exposed map element type.<br/>
+<br/>
+<a name="B"></a>
+<code>B</code> - Auxiliary data subclasses may wish to store in the backing map.<br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/add-listener.html

@@ -0,0 +1,17 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.addListener - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">addListener</a><br/>
+<br/>
+<h1>addListener</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$addListener(javafx.beans.InvalidationListener)"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">addListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$addListener(javafx.beans.InvalidationListener)/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">InvalidationListener</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$addListener(javafx.collections.MapChangeListener((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">addListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$addListener(javafx.collections.MapChangeListener((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">MapChangeListener</span><span class="symbol">&lt;</span><span class="keyword">in</span>&nbsp;<span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">in</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/backing-map.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.backingMap - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">backingMap</a><br/>
+<br/>
+<h1>backingMap</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$backingMap"></a>
+<code><span class="keyword">protected</span> <span class="keyword">val </span><span class="identifier">backingMap</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/HashMap.html"><span class="identifier">HashMap</span></a><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/clear.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.clear - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">clear</a><br/>
+<br/>
+<h1>clear</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$clear()"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">clear</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/contains-key.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.containsKey - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">containsKey</a><br/>
+<br/>
+<h1>containsKey</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$containsKey(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K)"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">containsKey</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$containsKey(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/contains-value.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.containsValue - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">containsValue</a><br/>
+<br/>
+<h1>containsValue</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$containsValue(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">containsValue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$containsValue(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)/value">value</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/entries.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.entries - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">entries</a><br/>
+<br/>
+<h1>entries</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$entries"></a>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">entries</span><span class="symbol">: </span><span class="identifier">MutableSet</span><span class="symbol">&lt;</span><span class="identifier">MutableEntry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/fire-change.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.fireChange - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">fireChange</a><br/>
+<br/>
+<h1>fireChange</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$fireChange(javafx.collections.MapChangeListener.Change((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))"></a>
+<code><span class="keyword">protected</span> <span class="keyword">fun </span><span class="identifier">fireChange</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$fireChange(javafx.collections.MapChangeListener.Change((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))/change">change</span><span class="symbol">:</span>&nbsp;<span class="identifier">Change</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/get.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.get - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">get</a><br/>
+<br/>
+<h1>get</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$get(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K)"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">get</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$get(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/index.html

@@ -0,0 +1,205 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">ReadOnlyBackedObservableMapBase</a><br/>
+<br/>
+<h1>ReadOnlyBackedObservableMapBase</h1>
+<code><span class="keyword">open</span> <span class="keyword">class </span><span class="identifier">ReadOnlyBackedObservableMapBase</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<p>ReadOnlyBackedObservableMapBase is a base class implementing all abstract functions required for an <a href="#">ObservableMap</a>
+using a backing HashMap that subclasses should modify.</p>
+<p>Non-read-only API calls throw.</p>
+<br/>
+<br/>
+<h3>Parameters</h3>
+<a name="K"></a>
+<code>K</code> - The key type.<br/>
+<br/>
+<a name="A"></a>
+<code>A</code> - The exposed map element type.<br/>
+<br/>
+<a name="B"></a>
+<code>B</code> - Auxiliary data subclasses may wish to store in the backing map.<br/>
+<br/>
+<br/>
+<h3>Constructors</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="-init-.html">&lt;init&gt;</a></td>
+<td>
+<code><span class="identifier">ReadOnlyBackedObservableMapBase</span><span class="symbol">(</span><span class="symbol">)</span></code><p>ReadOnlyBackedObservableMapBase is a base class implementing all abstract functions required for an <a href="#">ObservableMap</a>
+using a backing HashMap that subclasses should modify.</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="backing-map.html">backingMap</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">backingMap</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/HashMap.html"><span class="identifier">HashMap</span></a><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="entries.html">entries</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">entries</span><span class="symbol">: </span><span class="identifier">MutableSet</span><span class="symbol">&lt;</span><span class="identifier">MutableEntry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="keys.html">keys</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">keys</span><span class="symbol">: </span><span class="identifier">MutableSet</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="size.html">size</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">size</span><span class="symbol">: </span><span class="identifier">Int</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="values.html">values</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">values</span><span class="symbol">: </span><span class="identifier">MutableCollection</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="add-listener.html">addListener</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">addListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$addListener(javafx.beans.InvalidationListener)/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">InvalidationListener</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">addListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$addListener(javafx.collections.MapChangeListener((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">MapChangeListener</span><span class="symbol">&lt;</span><span class="keyword">in</span>&nbsp;<span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">in</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="clear.html">clear</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">clear</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="contains-key.html">containsKey</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">containsKey</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$containsKey(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="contains-value.html">containsValue</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">containsValue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$containsValue(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)/value">value</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="fire-change.html">fireChange</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">fireChange</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$fireChange(javafx.collections.MapChangeListener.Change((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))/change">change</span><span class="symbol">:</span>&nbsp;<span class="identifier">Change</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="get.html">get</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">get</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$get(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="is-empty.html">isEmpty</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">isEmpty</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="put.html">put</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">put</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$put(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$put(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)/value">value</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">A</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="put-all.html">putAll</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">putAll</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$putAll(kotlin.collections.Map((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))/from">from</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="remove.html">remove</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">remove</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$remove(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">A</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="remove-listener.html">removeListener</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">removeListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$removeListener(javafx.beans.InvalidationListener)/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">InvalidationListener</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">removeListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$removeListener(javafx.collections.MapChangeListener((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">MapChangeListener</span><span class="symbol">&lt;</span><span class="keyword">in</span>&nbsp;<span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">in</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Extension Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/create-map-change.html">createMapChange</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">K</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">createMapChange</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/removedValue">removedValue</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/addedValue">addedValue</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Change</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/get-observable-entries.html">getObservableEntries</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableEntries</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">Entry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val people: ObservableList = nameToPerson.getObservableValues()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/get-observable-value.html">getObservableValue</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableValue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getObservableValue(javafx.collections.ObservableMap((com.r3corda.client.fxutils.getObservableValue.K, com.r3corda.client.fxutils.getObservableValue.V)), com.r3corda.client.fxutils.getObservableValue.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">V</span><span class="symbol">?</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val john: ObservableValue&lt;Person?&gt; = nameToPerson.getObservableValue("John")</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-map/get-observable-values.html">getObservableValues</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableValues</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">V</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val people: ObservableList = nameToPerson.getObservableValues()</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Inheritors</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../-associated-list/index.html">AssociatedList</a></td>
+<td>
+<code><span class="keyword">class </span><span class="identifier">AssociatedList</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">ReadOnlyBackedObservableMapBase</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">Unit</span><span class="symbol">&gt;</span></code><p><a href="../-associated-list/index.html">AssociatedList</a> creates an <a href="#">ObservableMap</a> from an <a href="#">ObservableList</a> by associating each list element with a unique key.
+It is <emph>not</emph> allowed to have several elements map to the same value</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../-left-outer-joined-map/index.html">LeftOuterJoinedMap</a></td>
+<td>
+<code><span class="keyword">class </span><span class="identifier">LeftOuterJoinedMap</span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">ReadOnlyBackedObservableMapBase</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">C</span><span class="symbol">,</span>&nbsp;<span class="identifier">SimpleObjectProperty</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p><a href="../-left-outer-joined-map/index.html">LeftOuterJoinedMap</a> implements a special case of a left outer join where were matching on primary keys of both
+tables.</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/is-empty.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.isEmpty - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">isEmpty</a><br/>
+<br/>
+<h1>isEmpty</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$isEmpty()"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">isEmpty</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/keys.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.keys - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">keys</a><br/>
+<br/>
+<h1>keys</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$keys"></a>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">keys</span><span class="symbol">: </span><span class="identifier">MutableSet</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/put-all.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.putAll - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">putAll</a><br/>
+<br/>
+<h1>putAll</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$putAll(kotlin.collections.Map((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">putAll</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$putAll(kotlin.collections.Map((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))/from">from</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/put.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.put - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">put</a><br/>
+<br/>
+<h1>put</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$put(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">put</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$put(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$put(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)/value">value</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">A</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/remove-listener.html

@@ -0,0 +1,17 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.removeListener - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">removeListener</a><br/>
+<br/>
+<h1>removeListener</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$removeListener(javafx.beans.InvalidationListener)"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">removeListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$removeListener(javafx.beans.InvalidationListener)/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">InvalidationListener</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$removeListener(javafx.collections.MapChangeListener((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">removeListener</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$removeListener(javafx.collections.MapChangeListener((com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K, com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.A)))/listener">listener</span><span class="symbol">:</span>&nbsp;<span class="identifier">MapChangeListener</span><span class="symbol">&lt;</span><span class="keyword">in</span>&nbsp;<span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">in</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/remove.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.remove - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">remove</a><br/>
+<br/>
+<h1>remove</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$remove(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K)"></a>
+<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">remove</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$remove(com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">A</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/size.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.size - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">size</a><br/>
+<br/>
+<h1>size</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$size"></a>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">size</span><span class="symbol">: </span><span class="identifier">Int</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-read-only-backed-observable-map-base/values.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReadOnlyBackedObservableMapBase.values - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReadOnlyBackedObservableMapBase</a>&nbsp;/&nbsp;<a href=".">values</a><br/>
+<br/>
+<h1>values</h1>
+<a name="com.r3corda.client.fxutils.ReadOnlyBackedObservableMapBase$values"></a>
+<code><span class="keyword">open</span> <span class="keyword">val </span><span class="identifier">values</span><span class="symbol">: </span><span class="identifier">MutableCollection</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-replayed-list/-init-.html

@@ -0,0 +1,16 @@
+<HTML>
+<HEAD>
+<title>ReplayedList.<init> - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReplayedList</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
+<br/>
+<h1>&lt;init&gt;</h1>
+<code><span class="identifier">ReplayedList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReplayedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.ReplayedList.A)))/sourceList">sourceList</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><br/>
+<p>This list type just replays changes propagated from the underlying source list. Used for testing changes and backing a
+non-backed observable</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-replayed-list/get-source-index.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReplayedList.getSourceIndex - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReplayedList</a>&nbsp;/&nbsp;<a href=".">getSourceIndex</a><br/>
+<br/>
+<h1>getSourceIndex</h1>
+<a name="com.r3corda.client.fxutils.ReplayedList$getSourceIndex(kotlin.Int)"></a>
+<code><span class="keyword">fun </span><span class="identifier">getSourceIndex</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReplayedList$getSourceIndex(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-replayed-list/get.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReplayedList.get - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReplayedList</a>&nbsp;/&nbsp;<a href=".">get</a><br/>
+<br/>
+<h1>get</h1>
+<a name="com.r3corda.client.fxutils.ReplayedList$get(kotlin.Int)"></a>
+<code><span class="keyword">fun </span><span class="identifier">get</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReplayedList$get(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">A</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-replayed-list/index.html

@@ -0,0 +1,189 @@
+<HTML>
+<HEAD>
+<title>ReplayedList - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">ReplayedList</a><br/>
+<br/>
+<h1>ReplayedList</h1>
+<code><span class="keyword">class </span><span class="identifier">ReplayedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<p>This list type just replays changes propagated from the underlying source list. Used for testing changes and backing a
+non-backed observable</p>
+<br/>
+<br/>
+<h3>Constructors</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="-init-.html">&lt;init&gt;</a></td>
+<td>
+<code><span class="identifier">ReplayedList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReplayedList$<init>(javafx.collections.ObservableList((com.r3corda.client.fxutils.ReplayedList.A)))/sourceList">sourceList</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><p>This list type just replays changes propagated from the underlying source list. Used for testing changes and backing a
+non-backed observable</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="replayed-list.html">replayedList</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">replayedList</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html"><span class="identifier">ArrayList</span></a><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="size.html">size</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">size</span><span class="symbol">: </span><span class="identifier">Int</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="get.html">get</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">get</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReplayedList$get(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">A</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="get-source-index.html">getSourceIndex</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">getSourceIndex</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReplayedList$getSourceIndex(kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="source-changed.html">sourceChanged</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">sourceChanged</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReplayedList$sourceChanged(javafx.collections.ListChangeListener.Change((com.r3corda.client.fxutils.ReplayedList.A)))/c">c</span><span class="symbol">:</span>&nbsp;<span class="identifier">Change</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Extension Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by.html">associateBy</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p>data class Person(val height: Long)
+val people: ObservableList = (..)
+val nameToHeight: ObservableMap&lt;String, Long&gt; = people.associateBy(Person::name) { name, person -&gt; person.height }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val nameToPerson: ObservableMap&lt;String, Person&gt; = people.associateBy(Person::name)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/associate-by-aggregation.html">associateByAggregation</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToNames: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height) { name, person -&gt; person.name }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToPeople: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/filter.html">filter</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
+val filterCriterion: ObservableValue = (..)
+val people: ObservableList = (..)
+fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .. }</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/filter-not-null.html">filterNotNull</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filterNotNull</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Dog(val owner: Person?)
+val dogs: ObservableList = (..)
+val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/first.html">first</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">first</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/fold-observable.html">foldObservable</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldObservable</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val concatenatedNames = people.foldObservable("", { names, person -&gt; names + person.name })
+val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/get-value-at.html">getValueAt</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getValueAt</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getValueAt(javafx.collections.ObservableList((com.r3corda.client.fxutils.getValueAt.A)), kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-list/index-of-or-throw.html">indexOfOrThrow</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">List</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">indexOfOrThrow</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$indexOfOrThrow(kotlin.collections.List((com.r3corda.core.indexOfOrThrow.T)), com.r3corda.core.indexOfOrThrow.T)/item">item</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Int</span></code><p>Returns the index of the given item or throws <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/IllegalArgumentException.html">IllegalArgumentException</a> if not found.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/is-ordered-and-unique.html">isOrderedAndUnique</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">, </span><span class="identifier">I</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Comparable</span><span class="symbol">&lt;</span><span class="identifier">I</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">isOrderedAndUnique</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$isOrderedAndUnique(kotlin.collections.Iterable((com.r3corda.core.isOrderedAndUnique.T)), kotlin.Function1((com.r3corda.core.isOrderedAndUnique.T, com.r3corda.core.isOrderedAndUnique.I)))/extractId">extractId</span><span class="symbol">:</span>&nbsp;<span class="identifier">T</span><span class="symbol">.</span><span class="symbol">(</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">I</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Boolean</span></code><p>Determine if an iterable data types contents are ordered and unique, based on their <a href="#">Comparable</a>.compareTo
+function.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/last.html">last</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">last</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/left-outer-join.html">leftOuterJoin</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><p>data class Person(val name: String, val managerName: String)
+val people: ObservableList = (..)
+val managerEmployeeMapping: ObservableList&lt;Pair&lt;Person, ObservableList&gt;&gt; =
+people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -&gt; Pair(manager, employees) }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>data class Person(name: String, favouriteSpecies: Species)
+data class Animal(name: String, species: Species)
+val people: ObservableList = (..)
+val animals: ObservableList = (..)
+val peopleToFavouriteAnimals: ObservableMap&lt;Species, Pair&lt;ObservableList, ObservableList&gt;&gt; =
+people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../javafx.collections.-observable-list/map.html">map</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/cached">cached</span><span class="symbol">:</span>&nbsp;<span class="identifier">Boolean</span>&nbsp;<span class="symbol">=</span>&nbsp;true<span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
+val dogOwners: ObservableList = dogs.map { it.owner }</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core/kotlin.collections.-iterable/none-or-single.html">noneOrSingle</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">noneOrSingle</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core$noneOrSingle(kotlin.collections.Iterable((com.r3corda.core.noneOrSingle.T)), kotlin.Function1((com.r3corda.core.noneOrSingle.T, kotlin.Boolean)))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">T</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">T</span><span class="symbol">?</span></code><p>Returns the single element matching the given <a href="../../com.r3corda.core/kotlin.collections.-iterable/none-or-single.html#com.r3corda.core$noneOrSingle(kotlin.collections.Iterable((com.r3corda.core.noneOrSingle.T)), kotlin.Function1((com.r3corda.core.noneOrSingle.T, kotlin.Boolean)))/predicate">predicate</a>, or <code>null</code> if element was not found,
+or throws if more than one element was found.</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">Iterable</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">noneOrSingle</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">T</span><span class="symbol">?</span></code><p>Returns single element, or <code>null</code> if element was not found, or throws if more than one element was found.</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-replayed-list/replayed-list.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReplayedList.replayedList - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReplayedList</a>&nbsp;/&nbsp;<a href=".">replayedList</a><br/>
+<br/>
+<h1>replayedList</h1>
+<a name="com.r3corda.client.fxutils.ReplayedList$replayedList"></a>
+<code><span class="keyword">val </span><span class="identifier">replayedList</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html"><span class="identifier">ArrayList</span></a><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-replayed-list/size.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReplayedList.size - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReplayedList</a>&nbsp;/&nbsp;<a href=".">size</a><br/>
+<br/>
+<h1>size</h1>
+<a name="com.r3corda.client.fxutils.ReplayedList$size"></a>
+<code><span class="keyword">val </span><span class="identifier">size</span><span class="symbol">: </span><span class="identifier">Int</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/-replayed-list/source-changed.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>ReplayedList.sourceChanged - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">ReplayedList</a>&nbsp;/&nbsp;<a href=".">sourceChanged</a><br/>
+<br/>
+<h1>sourceChanged</h1>
+<a name="com.r3corda.client.fxutils.ReplayedList$sourceChanged(javafx.collections.ListChangeListener.Change((com.r3corda.client.fxutils.ReplayedList.A)))"></a>
+<code><span class="keyword">protected</span> <span class="keyword">fun </span><span class="identifier">sourceChanged</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils.ReplayedList$sourceChanged(javafx.collections.ListChangeListener.Change((com.r3corda.client.fxutils.ReplayedList.A)))/c">c</span><span class="symbol">:</span>&nbsp;<span class="identifier">Change</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/fold-to-observable-list.html

@@ -9,6 +9,15 @@
 <h1>foldToObservableList</h1>
 <a name="com.r3corda.client.fxutils$foldToObservableList(((com.r3corda.client.fxutils.foldToObservableList.A)), com.r3corda.client.fxutils.foldToObservableList.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableList.A, com.r3corda.client.fxutils.foldToObservableList.C, javafx.collections.ObservableList((com.r3corda.client.fxutils.foldToObservableList.B)), )))"></a>
 <code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldToObservableList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableList(((com.r3corda.client.fxutils.foldToObservableList.A)), com.r3corda.client.fxutils.foldToObservableList.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableList.A, com.r3corda.client.fxutils.foldToObservableList.C, javafx.collections.ObservableList((com.r3corda.client.fxutils.foldToObservableList.B)), )))/initialAccumulator">initialAccumulator</span><span class="symbol">:</span>&nbsp;<span class="identifier">C</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableList(((com.r3corda.client.fxutils.foldToObservableList.A)), com.r3corda.client.fxutils.foldToObservableList.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableList.A, com.r3corda.client.fxutils.foldToObservableList.C, javafx.collections.ObservableList((com.r3corda.client.fxutils.foldToObservableList.B)), )))/folderFun">folderFun</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">C</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
+<p>foldToObservableList takes an <a href="#">rx.Observable</a> stream and creates an <a href="#">ObservableList</a> out of it, while maintaining
+an accumulator.</p>
+<h3>Parameters</h3>
+<a name="initialAccumulator"></a>
+<code>initialAccumulator</code> - The initial value of the accumulator.<br/>
+<br/>
+<a name="folderFun"></a>
+<code>folderFun</code> - 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.<br/>
 <br/>
 <br/>
 </BODY>

docs/build/html/api/com.r3corda.client.fxutils/fold-to-observable-map.html

@@ -0,0 +1,24 @@
+<HTML>
+<HEAD>
+<title>foldToObservableMap - </title>
+<link rel="stylesheet" href="../style.css">
+</HEAD>
+<BODY>
+<a href="index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">foldToObservableMap</a><br/>
+<br/>
+<h1>foldToObservableMap</h1>
+<a name="com.r3corda.client.fxutils$foldToObservableMap(((com.r3corda.client.fxutils.foldToObservableMap.A)), com.r3corda.client.fxutils.foldToObservableMap.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableMap.A, com.r3corda.client.fxutils.foldToObservableMap.C, javafx.collections.ObservableMap((com.r3corda.client.fxutils.foldToObservableMap.K, com.r3corda.client.fxutils.foldToObservableMap.B)), )))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">, </span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldToObservableMap</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableMap(((com.r3corda.client.fxutils.foldToObservableMap.A)), com.r3corda.client.fxutils.foldToObservableMap.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableMap.A, com.r3corda.client.fxutils.foldToObservableMap.C, javafx.collections.ObservableMap((com.r3corda.client.fxutils.foldToObservableMap.K, com.r3corda.client.fxutils.foldToObservableMap.B)), )))/initialAccumulator">initialAccumulator</span><span class="symbol">:</span>&nbsp;<span class="identifier">C</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableMap(((com.r3corda.client.fxutils.foldToObservableMap.A)), com.r3corda.client.fxutils.foldToObservableMap.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableMap.A, com.r3corda.client.fxutils.foldToObservableMap.C, javafx.collections.ObservableMap((com.r3corda.client.fxutils.foldToObservableMap.K, com.r3corda.client.fxutils.foldToObservableMap.B)), )))/folderFun">folderFun</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">C</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
+<p>foldToObservableMap takes an <a href="#">rx.Observable</a> stream and creates an <a href="#">ObservableMap</a> out of it, while maintaining
+an accumulator.</p>
+<h3>Parameters</h3>
+<a name="initialAccumulator"></a>
+<code>initialAccumulator</code> - The initial value of the accumulator.<br/>
+<br/>
+<a name="folderFun"></a>
+<code>folderFun</code> - 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.<br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/fold-to-observable-value.html

@@ -9,7 +9,14 @@
 <h1>foldToObservableValue</h1>
 <a name="com.r3corda.client.fxutils$foldToObservableValue(((com.r3corda.client.fxutils.foldToObservableValue.A)), com.r3corda.client.fxutils.foldToObservableValue.B, kotlin.Function2((com.r3corda.client.fxutils.foldToObservableValue.A, com.r3corda.client.fxutils.foldToObservableValue.B, )))"></a>
 <code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldToObservableValue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableValue(((com.r3corda.client.fxutils.foldToObservableValue.A)), com.r3corda.client.fxutils.foldToObservableValue.B, kotlin.Function2((com.r3corda.client.fxutils.foldToObservableValue.A, com.r3corda.client.fxutils.foldToObservableValue.B, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableValue(((com.r3corda.client.fxutils.foldToObservableValue.A)), com.r3corda.client.fxutils.foldToObservableValue.B, kotlin.Function2((com.r3corda.client.fxutils.foldToObservableValue.A, com.r3corda.client.fxutils.foldToObservableValue.B, )))/folderFun">folderFun</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
-<p>Simple utilities for converting an <a href="#">rx.Observable</a> into a javafx <a href="#">ObservableValue</a>/<a href="#">ObservableList</a></p>
+<p>foldToObservableValue takes an <a href="#">rx.Observable</a> stream and creates an <a href="#">ObservableValue</a> out of it.</p>
+<h3>Parameters</h3>
+<a name="initial"></a>
+<code>initial</code> - The initial value of the returned observable.<br/>
+<br/>
+<a name="folderFun"></a>
+<code>folderFun</code> - The transformation function to be called on the observable value when a new element is emitted on
+the stream.<br/>
 <br/>
 <br/>
 </BODY>

docs/build/html/api/com.r3corda.client.fxutils/index.html

@@ -14,7 +14,7 @@
 <td>
 <a href="-aggregated-list/index.html">AggregatedList</a></td>
 <td>
-<code><span class="keyword">class </span><span class="identifier">AggregatedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">E</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">E</span><span class="symbol">&gt;</span></code><p>Given an <a href="#">ObservableList</a>&lt;<a href="#">E</a>&gt; and a grouping key <a href="#">K</a>, <a href="-aggregated-list/index.html">AggregatedList</a> groups the elements by the key into a fresh
+<code><span class="keyword">class </span><span class="identifier">AggregatedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">E</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">E</span><span class="symbol">&gt;</span></code><p>Given an <a href="#">ObservableList</a>&lt;<a href="#">E</a>&gt; and a grouping key <a href="#">K</a>, <a href="-aggregated-list/index.html">AggregatedList</a> groups the elements by the key into a fresh
 <a href="#">ObservableList</a>&lt;<a href="#">E</a>&gt; for each group and exposes the groups as an observable list of <a href="#">A</a>s by calling <a href="-aggregated-list/assemble.html">assemble</a> on each.</p>
 </td>
 </tr>
@@ -27,6 +27,14 @@
 </tr>
 <tr>
 <td>
+<a href="-associated-list/index.html">AssociatedList</a></td>
+<td>
+<code><span class="keyword">class </span><span class="identifier">AssociatedList</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="-read-only-backed-observable-map-base/index.html"><span class="identifier">ReadOnlyBackedObservableMapBase</span></a><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">Unit</span><span class="symbol">&gt;</span></code><p><a href="-associated-list/index.html">AssociatedList</a> creates an <a href="#">ObservableMap</a> from an <a href="#">ObservableList</a> by associating each list element with a unique key.
+It is <emph>not</emph> allowed to have several elements map to the same value</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="-chosen-list/index.html">ChosenList</a></td>
 <td>
 <code><span class="keyword">class </span><span class="identifier">ChosenList</span><span class="symbol">&lt;</span><span class="identifier">E</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">ObservableListBase</span><span class="symbol">&lt;</span><span class="identifier">E</span><span class="symbol">&gt;</span></code><p><a href="-chosen-list/index.html">ChosenList</a> manages an <a href="#">ObservableList</a> that may be changed by the wrapping <a href="#">ObservableValue</a>. Whenever the underlying
@@ -35,12 +43,61 @@
 </tr>
 <tr>
 <td>
+<a href="-concatenated-list/index.html">ConcatenatedList</a></td>
+<td>
+<code><span class="keyword">class </span><span class="identifier">ConcatenatedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p><a href="-concatenated-list/index.html">ConcatenatedList</a> takes a list of lists and concatenates them. Any change to the underlying lists or the outer list
+is propagated as expected.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="-flattened-list/index.html">FlattenedList</a></td>
 <td>
 <code><span class="keyword">class </span><span class="identifier">FlattenedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p><a href="-flattened-list/index.html">FlattenedList</a> flattens the passed in list of <a href="#">ObservableValue</a>s so that changes in individual updates to the values
 are reflected in the exposed list as expected.</p>
 </td>
 </tr>
+<tr>
+<td>
+<a href="-left-outer-joined-map/index.html">LeftOuterJoinedMap</a></td>
+<td>
+<code><span class="keyword">class </span><span class="identifier">LeftOuterJoinedMap</span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="-read-only-backed-observable-map-base/index.html"><span class="identifier">ReadOnlyBackedObservableMapBase</span></a><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">C</span><span class="symbol">,</span>&nbsp;<span class="identifier">SimpleObjectProperty</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p><a href="-left-outer-joined-map/index.html">LeftOuterJoinedMap</a> implements a special case of a left outer join where were matching on primary keys of both
+tables.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="-map-values-list/index.html">MapValuesList</a></td>
+<td>
+<code><span class="keyword">class </span><span class="identifier">MapValuesList</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><p><a href="-map-values-list/index.html">MapValuesList</a> takes an <a href="#">ObservableMap</a> and returns its values as an <a href="#">ObservableList</a>.
+The order of returned elements is deterministic but unspecified.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="-mapped-list/index.html">MappedList</a></td>
+<td>
+<code><span class="keyword">class </span><span class="identifier">MappedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>This is a variant of <a href="#">EasyBind.map</a> 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 <a href="#">EasyBind.map</a> to trade off memory vs CPU, or if (god forbid) the mapped function is side-effecting.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="-read-only-backed-observable-map-base/index.html">ReadOnlyBackedObservableMapBase</a></td>
+<td>
+<code><span class="keyword">open</span> <span class="keyword">class </span><span class="identifier">ReadOnlyBackedObservableMapBase</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p><a href="-read-only-backed-observable-map-base/index.html">ReadOnlyBackedObservableMapBase</a> is a base class implementing all abstract functions required for an <a href="#">ObservableMap</a>
+using a backing HashMap that subclasses should modify.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="-replayed-list/index.html">ReplayedList</a></td>
+<td>
+<code><span class="keyword">class </span><span class="identifier">ReplayedList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">TransformationList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>This list type just replays changes propagated from the underlying source list. Used for testing changes and backing a
+non-backed observable</p>
+</td>
+</tr>
 </tbody>
 </table>
 <h3>Extensions for External Classes</h3>
@@ -60,6 +117,12 @@ are reflected in the exposed list as expected.</p>
 </tr>
 <tr>
 <td>
+<a href="javafx.collections.-observable-map/index.html">javafx.collections.ObservableMap</a></td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
 <a href="kotlin.-function1/index.html">kotlin.Function1</a></td>
 <td>
 </td>
@@ -82,6 +145,12 @@ are reflected in the exposed list as expected.</p>
 <td>
 </td>
 </tr>
+<tr>
+<td>
+<a href="kotlin.collections.-collection/index.html">kotlin.collections.Collection</a></td>
+<td>
+</td>
+</tr>
 </tbody>
 </table>
 <h3>Functions</h3>
@@ -91,13 +160,23 @@ are reflected in the exposed list as expected.</p>
 <td>
 <a href="fold-to-observable-list.html">foldToObservableList</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldToObservableList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableList(((com.r3corda.client.fxutils.foldToObservableList.A)), com.r3corda.client.fxutils.foldToObservableList.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableList.A, com.r3corda.client.fxutils.foldToObservableList.C, javafx.collections.ObservableList((com.r3corda.client.fxutils.foldToObservableList.B)), )))/initialAccumulator">initialAccumulator</span><span class="symbol">:</span>&nbsp;<span class="identifier">C</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableList(((com.r3corda.client.fxutils.foldToObservableList.A)), com.r3corda.client.fxutils.foldToObservableList.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableList.A, com.r3corda.client.fxutils.foldToObservableList.C, javafx.collections.ObservableList((com.r3corda.client.fxutils.foldToObservableList.B)), )))/folderFun">folderFun</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">C</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code></td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldToObservableList</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableList(((com.r3corda.client.fxutils.foldToObservableList.A)), com.r3corda.client.fxutils.foldToObservableList.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableList.A, com.r3corda.client.fxutils.foldToObservableList.C, javafx.collections.ObservableList((com.r3corda.client.fxutils.foldToObservableList.B)), )))/initialAccumulator">initialAccumulator</span><span class="symbol">:</span>&nbsp;<span class="identifier">C</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableList(((com.r3corda.client.fxutils.foldToObservableList.A)), com.r3corda.client.fxutils.foldToObservableList.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableList.A, com.r3corda.client.fxutils.foldToObservableList.C, javafx.collections.ObservableList((com.r3corda.client.fxutils.foldToObservableList.B)), )))/folderFun">folderFun</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">C</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p><a href="fold-to-observable-list.html">foldToObservableList</a> takes an <a href="#">rx.Observable</a> stream and creates an <a href="#">ObservableList</a> out of it, while maintaining
+an accumulator.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="fold-to-observable-map.html">foldToObservableMap</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">, </span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldToObservableMap</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableMap(((com.r3corda.client.fxutils.foldToObservableMap.A)), com.r3corda.client.fxutils.foldToObservableMap.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableMap.A, com.r3corda.client.fxutils.foldToObservableMap.C, javafx.collections.ObservableMap((com.r3corda.client.fxutils.foldToObservableMap.K, com.r3corda.client.fxutils.foldToObservableMap.B)), )))/initialAccumulator">initialAccumulator</span><span class="symbol">:</span>&nbsp;<span class="identifier">C</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableMap(((com.r3corda.client.fxutils.foldToObservableMap.A)), com.r3corda.client.fxutils.foldToObservableMap.C, kotlin.Function3((com.r3corda.client.fxutils.foldToObservableMap.A, com.r3corda.client.fxutils.foldToObservableMap.C, javafx.collections.ObservableMap((com.r3corda.client.fxutils.foldToObservableMap.K, com.r3corda.client.fxutils.foldToObservableMap.B)), )))/folderFun">folderFun</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">C</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p><a href="fold-to-observable-map.html">foldToObservableMap</a> takes an <a href="#">rx.Observable</a> stream and creates an <a href="#">ObservableMap</a> out of it, while maintaining
+an accumulator.</p>
+</td>
 </tr>
 <tr>
 <td>
 <a href="fold-to-observable-value.html">foldToObservableValue</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldToObservableValue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableValue(((com.r3corda.client.fxutils.foldToObservableValue.A)), com.r3corda.client.fxutils.foldToObservableValue.B, kotlin.Function2((com.r3corda.client.fxutils.foldToObservableValue.A, com.r3corda.client.fxutils.foldToObservableValue.B, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableValue(((com.r3corda.client.fxutils.foldToObservableValue.A)), com.r3corda.client.fxutils.foldToObservableValue.B, kotlin.Function2((com.r3corda.client.fxutils.foldToObservableValue.A, com.r3corda.client.fxutils.foldToObservableValue.B, )))/folderFun">folderFun</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>Simple utilities for converting an <a href="#">rx.Observable</a> into a javafx <a href="#">ObservableValue</a>/<a href="#">ObservableList</a></p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldToObservableValue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableValue(((com.r3corda.client.fxutils.foldToObservableValue.A)), com.r3corda.client.fxutils.foldToObservableValue.B, kotlin.Function2((com.r3corda.client.fxutils.foldToObservableValue.A, com.r3corda.client.fxutils.foldToObservableValue.B, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldToObservableValue(((com.r3corda.client.fxutils.foldToObservableValue.A)), com.r3corda.client.fxutils.foldToObservableValue.B, kotlin.Function2((com.r3corda.client.fxutils.foldToObservableValue.A, com.r3corda.client.fxutils.foldToObservableValue.B, )))/folderFun">folderFun</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p><a href="fold-to-observable-value.html">foldToObservableValue</a> takes an <a href="#">rx.Observable</a> stream and creates an <a href="#">ObservableValue</a> out of it.</p>
 </td>
 </tr>
 <tr>
@@ -109,6 +188,20 @@ val bobHeight: ObservableValue = (..)
 fun sumHeight(a: Long, b: Long): Long { .. }</p>
 </td>
 </tr>
+<tr>
+<td>
+<a href="record-as-association.html">recordAsAssociation</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">K</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">recordAsAssociation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$recordAsAssociation(((com.r3corda.client.fxutils.recordAsAssociation.A)), kotlin.Function1((com.r3corda.client.fxutils.recordAsAssociation.A, com.r3corda.client.fxutils.recordAsAssociation.K)), kotlin.Function3((com.r3corda.client.fxutils.recordAsAssociation.K, com.r3corda.client.fxutils.recordAsAssociation.A, , )))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$recordAsAssociation(((com.r3corda.client.fxutils.recordAsAssociation.A)), kotlin.Function1((com.r3corda.client.fxutils.recordAsAssociation.A, com.r3corda.client.fxutils.recordAsAssociation.K)), kotlin.Function3((com.r3corda.client.fxutils.recordAsAssociation.K, com.r3corda.client.fxutils.recordAsAssociation.A, , )))/merge">merge</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">A</span>&nbsp;<span class="symbol">=</span>&nbsp;{ _key, _oldValue, newValue -&gt; newValue }<span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>This variant simply associates each event with its key.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="record-in-sequence.html">recordInSequence</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">recordInSequence</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p><a href="record-in-sequence.html">recordInSequence</a> records incoming events on the <a href="#">rx.Observable</a> in sequence.</p>
+</td>
+</tr>
 </tbody>
 </table>
 </BODY>

docs/build/html/api/com.r3corda.client.fxutils/javafx.beans.value.-observable-value/bind-out.html

@@ -0,0 +1,17 @@
+<HTML>
+<HEAD>
+<title>bindOut - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.beans.value.ObservableValue</a>&nbsp;/&nbsp;<a href=".">bindOut</a><br/>
+<br/>
+<h1>bindOut</h1>
+<a name="com.r3corda.client.fxutils$bindOut(javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bindOut.A)), kotlin.Function1((com.r3corda.client.fxutils.bindOut.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bindOut.B)))))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">bindOut</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$bindOut(javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bindOut.A)), kotlin.Function1((com.r3corda.client.fxutils.bindOut.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bindOut.B)))))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
+<p>A variant of <a href="bind.html">bind</a> that has out variance on the output type. This is sometimes useful when kotlin is too eager to
+propagate variance constraints and type inference fails.</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.beans.value.-observable-value/bind.html

@@ -8,7 +8,7 @@
 <br/>
 <h1>bind</h1>
 <a name="com.r3corda.client.fxutils$bind(javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bind.A)), kotlin.Function1((com.r3corda.client.fxutils.bind.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bind.B)))))"></a>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">bind</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$bind(javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bind.A)), kotlin.Function1((com.r3corda.client.fxutils.bind.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bind.B)))))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">bind</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$bind(javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bind.A)), kotlin.Function1((com.r3corda.client.fxutils.bind.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bind.B)))))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
 <p>data class Person(val height: ObservableValue)
 val person: ObservableValue = (..)
 val personHeight: ObservableValue = person.bind { it.height }</p>

docs/build/html/api/com.r3corda.client.fxutils/javafx.beans.value.-observable-value/index.html

@@ -13,13 +13,21 @@
 <td>
 <a href="bind.html">bind</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">bind</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$bind(javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bind.A)), kotlin.Function1((com.r3corda.client.fxutils.bind.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bind.B)))))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p>data class Person(val height: ObservableValue)
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">bind</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$bind(javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bind.A)), kotlin.Function1((com.r3corda.client.fxutils.bind.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bind.B)))))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>data class Person(val height: ObservableValue)
 val person: ObservableValue = (..)
 val personHeight: ObservableValue = person.bind { it.height }</p>
 </td>
 </tr>
 <tr>
 <td>
+<a href="bind-out.html">bindOut</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">bindOut</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$bindOut(javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bindOut.A)), kotlin.Function1((com.r3corda.client.fxutils.bindOut.A, javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.bindOut.B)))))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p>A variant of <a href="bind.html">bind</a> that has out variance on the output type. This is sometimes useful when kotlin is too eager to
+propagate variance constraints and type inference fails.</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="map.html">map</a></td>
 <td>
 <code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.map.A)), kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val person: ObservableValue = (..)

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/associate-by-aggregation.html

@@ -0,0 +1,23 @@
+<HTML>
+<HEAD>
+<title>associateByAggregation - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">associateByAggregation</a><br/>
+<br/>
+<h1>associateByAggregation</h1>
+<a name="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
+<p>val people: ObservableList = (..)
+val heightToNames: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height) { name, person -&gt; person.name }</p>
+<br/>
+<br/>
+<a name="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
+<p>val people: ObservableList = (..)
+val heightToPeople: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height)</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/associate-by.html

@@ -0,0 +1,24 @@
+<HTML>
+<HEAD>
+<title>associateBy - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">associateBy</a><br/>
+<br/>
+<h1>associateBy</h1>
+<a name="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
+<p>data class Person(val height: Long)
+val people: ObservableList = (..)
+val nameToHeight: ObservableMap&lt;String, Long&gt; = people.associateBy(Person::name) { name, person -&gt; person.height }</p>
+<br/>
+<br/>
+<a name="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<p>val people: ObservableList = (..)
+val nameToPerson: ObservableMap&lt;String, Person&gt; = people.associateBy(Person::name)</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/concatenate.html

@@ -0,0 +1,17 @@
+<HTML>
+<HEAD>
+<title>concatenate - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">concatenate</a><br/>
+<br/>
+<h1>concatenate</h1>
+<a name="com.r3corda.client.fxutils$concatenate(javafx.collections.ObservableList((javafx.collections.ObservableList((com.r3corda.client.fxutils.concatenate.A)))))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">concatenate</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<p>val groups: ObservableList&lt;ObservableList&gt; = (..)
+val allPeople: ObservableList = groups.concatenate()</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/filter-not-null.html

@@ -0,0 +1,18 @@
+<HTML>
+<HEAD>
+<title>filterNotNull - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">filterNotNull</a><br/>
+<br/>
+<h1>filterNotNull</h1>
+<a name="com.r3corda.client.fxutils$filterNotNull(javafx.collections.ObservableList((com.r3corda.client.fxutils.filterNotNull.A)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filterNotNull</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<p>data class Dog(val owner: Person?)
+val dogs: ObservableList = (..)
+val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/filter.html

@@ -8,7 +8,7 @@
 <br/>
 <h1>filter</h1>
 <a name="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))"></a>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
 <p>enum class FilterCriterion { HEIGHT, NAME }
 val filterCriterion: ObservableValue = (..)
 val people: ObservableList = (..)

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/first.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>first - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">first</a><br/>
+<br/>
+<h1>first</h1>
+<a name="com.r3corda.client.fxutils$first(javafx.collections.ObservableList((com.r3corda.client.fxutils.first.A)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">first</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/flatten.html

@@ -8,7 +8,7 @@
 <br/>
 <h1>flatten</h1>
 <a name="com.r3corda.client.fxutils$flatten(javafx.collections.ObservableList((javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.flatten.A)))))"></a>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">flatten</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">flatten</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
 <p>data class Person(val height: ObservableValue)
 val people: ObservableList = (..)
 val heights: ObservableList = people.map(Person::height).flatten()</p>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/fold-observable.html

@@ -0,0 +1,18 @@
+<HTML>
+<HEAD>
+<title>foldObservable - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">foldObservable</a><br/>
+<br/>
+<h1>foldObservable</h1>
+<a name="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldObservable</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
+<p>val people: ObservableList = (..)
+val concatenatedNames = people.foldObservable("", { names, person -&gt; names + person.name })
+val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/fold.html

@@ -1,18 +0,0 @@
-<HTML>
-<HEAD>
-<title>fold - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">fold</a><br/>
-<br/>
-<h1>fold</h1>
-<a name="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))"></a>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">fold</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
-<p>val people: ObservableList = (..)
-val concatenatedNames = people.fold("", { names, person -&gt; names + person.name })
-val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/get-value-at.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>getValueAt - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">getValueAt</a><br/>
+<br/>
+<h1>getValueAt</h1>
+<a name="com.r3corda.client.fxutils$getValueAt(javafx.collections.ObservableList((com.r3corda.client.fxutils.getValueAt.A)), kotlin.Int)"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getValueAt</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getValueAt(javafx.collections.ObservableList((com.r3corda.client.fxutils.getValueAt.A)), kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/index.html

@@ -11,9 +11,38 @@
 <tbody>
 <tr>
 <td>
+<a href="associate-by.html">associateBy</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)), kotlin.Function2((com.r3corda.client.fxutils.associateBy.K, com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">B</span><span class="symbol">&gt;</span></code><p>data class Person(val height: Long)
+val people: ObservableList = (..)
+val nameToHeight: ObservableMap&lt;String, Long&gt; = people.associateBy(Person::name) { name, person -&gt; person.height }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateBy</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateBy(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateBy.A)), kotlin.Function1((com.r3corda.client.fxutils.associateBy.A, com.r3corda.client.fxutils.associateBy.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val nameToPerson: ObservableMap&lt;String, Person&gt; = people.associateBy(Person::name)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="associate-by-aggregation.html">associateByAggregation</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)), kotlin.Function2((com.r3corda.client.fxutils.associateByAggregation.K, com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.B)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToNames: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height) { name, person -&gt; person.name }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">associateByAggregation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$associateByAggregation(javafx.collections.ObservableList((com.r3corda.client.fxutils.associateByAggregation.A)), kotlin.Function1((com.r3corda.client.fxutils.associateByAggregation.A, com.r3corda.client.fxutils.associateByAggregation.K)))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val heightToPeople: ObservableMap&lt;Long, ObservableList&gt; = people.associateByAggregation(Person::height)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="concatenate.html">concatenate</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">concatenate</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>val groups: ObservableList&lt;ObservableList&gt; = (..)
+val allPeople: ObservableList = groups.concatenate()</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="filter.html">filter</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$filter(javafx.collections.ObservableList((com.r3corda.client.fxutils.filter.A)), javafx.beans.value.ObservableValue((kotlin.Function1((com.r3corda.client.fxutils.filter.A, kotlin.Boolean)))))/predicate">predicate</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">Boolean</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>enum class FilterCriterion { HEIGHT, NAME }
 val filterCriterion: ObservableValue = (..)
 val people: ObservableList = (..)
 fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .. }</p>
@@ -21,27 +50,70 @@ fun filterFunction(filterCriterion: FilterCriterion): (Person) -&gt; Boolean { .
 </tr>
 <tr>
 <td>
+<a href="filter-not-null.html">filterNotNull</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">filterNotNull</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Dog(val owner: Person?)
+val dogs: ObservableList = (..)
+val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="first.html">first</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">first</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
 <a href="flatten.html">flatten</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">flatten</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Person(val height: ObservableValue)
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">flatten</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Person(val height: ObservableValue)
 val people: ObservableList = (..)
 val heights: ObservableList = people.map(Person::height).flatten()</p>
 </td>
 </tr>
 <tr>
 <td>
-<a href="fold.html">fold</a></td>
+<a href="fold-observable.html">foldObservable</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">fold</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$fold(javafx.collections.ObservableList((com.r3corda.client.fxutils.fold.A)), com.r3corda.client.fxutils.fold.B, kotlin.Function2((com.r3corda.client.fxutils.fold.B, com.r3corda.client.fxutils.fold.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
-val concatenatedNames = people.fold("", { names, person -&gt; names + person.name })
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">foldObservable</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/initial">initial</span><span class="symbol">:</span>&nbsp;<span class="identifier">B</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$foldObservable(javafx.collections.ObservableList((com.r3corda.client.fxutils.foldObservable.A)), com.r3corda.client.fxutils.foldObservable.B, kotlin.Function2((com.r3corda.client.fxutils.foldObservable.B, com.r3corda.client.fxutils.foldObservable.A, )))/folderFunction">folderFunction</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val people: ObservableList = (..)
+val concatenatedNames = people.foldObservable("", { names, person -&gt; names + person.name })
 val concatenatedNames2 = people.map(Person::name).fold("", String::plus)</p>
 </td>
 </tr>
 <tr>
 <td>
+<a href="get-value-at.html">getValueAt</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getValueAt</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getValueAt(javafx.collections.ObservableList((com.r3corda.client.fxutils.getValueAt.A)), kotlin.Int)/index">index</span><span class="symbol">:</span>&nbsp;<span class="identifier">Int</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="last.html">last</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">last</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="left-outer-join.html">leftOuterJoin</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><p>data class Person(val name: String, val managerName: String)
+val people: ObservableList = (..)
+val managerEmployeeMapping: ObservableList&lt;Pair&lt;Person, ObservableList&gt;&gt; =
+people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -&gt; Pair(manager, employees) }</p>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>data class Person(name: String, favouriteSpecies: Species)
+data class Animal(name: String, species: Species)
+val people: ObservableList = (..)
+val animals: ObservableList = (..)
+val peopleToFavouriteAnimals: ObservableMap&lt;Species, Pair&lt;ObservableList, ObservableList&gt;&gt; =
+people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)</p>
+</td>
+</tr>
+<tr>
+<td>
 <a href="map.html">map</a></td>
 <td>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/cached">cached</span><span class="symbol">:</span>&nbsp;<span class="identifier">Boolean</span>&nbsp;<span class="symbol">=</span>&nbsp;true<span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><p>val dogs: ObservableList = (..)
 val dogOwners: ObservableList = dogs.map { it.owner }</p>
 </td>
 </tr>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/last.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>last - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">last</a><br/>
+<br/>
+<h1>last</h1>
+<a name="com.r3corda.client.fxutils$last(javafx.collections.ObservableList((com.r3corda.client.fxutils.last.A)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">last</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">?</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/left-outer-join.html

@@ -0,0 +1,34 @@
+<HTML>
+<HEAD>
+<title>leftOuterJoin - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">leftOuterJoin</a><br/>
+<br/>
+<h1>leftOuterJoin</h1>
+<a name="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">C</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function2((com.r3corda.client.fxutils.leftOuterJoin.A, javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), com.r3corda.client.fxutils.leftOuterJoin.C)))/assemble">assemble</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">C</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">C</span><span class="symbol">&gt;</span></code><br/>
+<p>data class Person(val name: String, val managerName: String)
+val people: ObservableList = (..)
+val managerEmployeeMapping: ObservableList&lt;Pair&lt;Person, ObservableList&gt;&gt; =
+people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -&gt; Pair(manager, employees) }</p>
+<br/>
+<br/>
+<a name="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">B</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">, </span><span class="identifier">K</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Any</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">leftOuterJoin</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightTable">rightTable</span><span class="symbol">:</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/leftToJoinKey">leftToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$leftOuterJoin(javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.A)), javafx.collections.ObservableList((com.r3corda.client.fxutils.leftOuterJoin.B)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.A, com.r3corda.client.fxutils.leftOuterJoin.K)), kotlin.Function1((com.r3corda.client.fxutils.leftOuterJoin.B, com.r3corda.client.fxutils.leftOuterJoin.K)))/rightToJoinKey">rightToJoinKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">B</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">,</span>&nbsp;<span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
+<p>data class Person(name: String, favouriteSpecies: Species)
+data class Animal(name: String, species: Species)
+val people: ObservableList = (..)
+val animals: ObservableList = (..)
+val peopleToFavouriteAnimals: ObservableMap&lt;Species, Pair&lt;ObservableList, ObservableList&gt;&gt; =
+people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)</p>
+<p>This is the most general left join, given a joining key it returns for each key a pair of relevant elements from the
+left and right tables. It is "left outer" in the sense that all members of the left table are guaranteed to be in
+the result, but this may not be the case for the right table.</p>
+<br/>
+<br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-list/map.html

@@ -7,10 +7,14 @@
 <a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableList</a>&nbsp;/&nbsp;<a href=".">map</a><br/>
 <br/>
 <h1>map</h1>
-<a name="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))"></a>
-<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
+<a name="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">B</span><span class="symbol">&gt;</span> <span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">map</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/cached">cached</span><span class="symbol">:</span>&nbsp;<span class="identifier">Boolean</span>&nbsp;<span class="symbol">=</span>&nbsp;true<span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$map(javafx.collections.ObservableList((com.r3corda.client.fxutils.map.A)), kotlin.Boolean, kotlin.Function1((com.r3corda.client.fxutils.map.A, com.r3corda.client.fxutils.map.B)))/function">function</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">B</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">B</span><span class="symbol">&gt;</span></code><br/>
 <p>val dogs: ObservableList = (..)
 val dogOwners: ObservableList = dogs.map { it.owner }</p>
+<h3>Parameters</h3>
+<a name="cached"></a>
+<code>cached</code> - If true the results of the mapped function are cached in a backing list. If false each get() will
+re-run the function.<br/>
 <br/>
 <br/>
 </BODY>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-map/create-map-change.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>createMapChange - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableMap</a>&nbsp;/&nbsp;<a href=".">createMapChange</a><br/>
+<br/>
+<h1>createMapChange</h1>
+<a name="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">K</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">createMapChange</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/removedValue">removedValue</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/addedValue">addedValue</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Change</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-map/get-observable-entries.html

@@ -0,0 +1,17 @@
+<HTML>
+<HEAD>
+<title>getObservableEntries - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableMap</a>&nbsp;/&nbsp;<a href=".">getObservableEntries</a><br/>
+<br/>
+<h1>getObservableEntries</h1>
+<a name="com.r3corda.client.fxutils$getObservableEntries(javafx.collections.ObservableMap((com.r3corda.client.fxutils.getObservableEntries.K, com.r3corda.client.fxutils.getObservableEntries.V)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableEntries</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">Entry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
+<p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val people: ObservableList = nameToPerson.getObservableValues()</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-map/get-observable-value.html

@@ -0,0 +1,17 @@
+<HTML>
+<HEAD>
+<title>getObservableValue - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableMap</a>&nbsp;/&nbsp;<a href=".">getObservableValue</a><br/>
+<br/>
+<h1>getObservableValue</h1>
+<a name="com.r3corda.client.fxutils$getObservableValue(javafx.collections.ObservableMap((com.r3corda.client.fxutils.getObservableValue.K, com.r3corda.client.fxutils.getObservableValue.V)), com.r3corda.client.fxutils.getObservableValue.K)"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableValue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getObservableValue(javafx.collections.ObservableMap((com.r3corda.client.fxutils.getObservableValue.K, com.r3corda.client.fxutils.getObservableValue.V)), com.r3corda.client.fxutils.getObservableValue.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">V</span><span class="symbol">?</span><span class="symbol">&gt;</span></code><br/>
+<p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val john: ObservableValue&lt;Person?&gt; = nameToPerson.getObservableValue("John")</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-map/get-observable-values.html

@@ -0,0 +1,17 @@
+<HTML>
+<HEAD>
+<title>getObservableValues - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">javafx.collections.ObservableMap</a>&nbsp;/&nbsp;<a href=".">getObservableValues</a><br/>
+<br/>
+<h1>getObservableValues</h1>
+<a name="com.r3corda.client.fxutils$getObservableValues(javafx.collections.ObservableMap((com.r3corda.client.fxutils.getObservableValues.K, com.r3corda.client.fxutils.getObservableValues.V)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableValues</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">V</span><span class="symbol">&gt;</span></code><br/>
+<p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val people: ObservableList = nameToPerson.getObservableValues()</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/javafx.collections.-observable-map/index.html

@@ -0,0 +1,45 @@
+<HTML>
+<HEAD>
+<title>com.r3corda.client.fxutils.javafx.collections.ObservableMap - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">javafx.collections.ObservableMap</a><br/>
+<br/>
+<h3>Extensions for javafx.collections.ObservableMap</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="create-map-change.html">createMapChange</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">K</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">createMapChange</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/removedValue">removedValue</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$createMapChange(javafx.collections.ObservableMap((com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A)), com.r3corda.client.fxutils.createMapChange.K, com.r3corda.client.fxutils.createMapChange.A, com.r3corda.client.fxutils.createMapChange.A)/addedValue">addedValue</span><span class="symbol">:</span>&nbsp;<span class="identifier">A</span><span class="symbol">?</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Change</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code></td>
+</tr>
+<tr>
+<td>
+<a href="get-observable-entries.html">getObservableEntries</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableEntries</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">Entry</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val people: ObservableList = nameToPerson.getObservableValues()</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="get-observable-value.html">getObservableValue</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableValue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$getObservableValue(javafx.collections.ObservableMap((com.r3corda.client.fxutils.getObservableValue.K, com.r3corda.client.fxutils.getObservableValue.V)), com.r3corda.client.fxutils.getObservableValue.K)/key">key</span><span class="symbol">:</span>&nbsp;<span class="identifier">K</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="identifier">V</span><span class="symbol">?</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val john: ObservableValue&lt;Person?&gt; = nameToPerson.getObservableValue("John")</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="get-observable-values.html">getObservableValues</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">, </span><span class="identifier">V</span><span class="symbol">&gt;</span> <span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">V</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">getObservableValues</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">V</span><span class="symbol">&gt;</span></code><p>val nameToPerson: ObservableMap&lt;String, Person&gt; = (..)
+val people: ObservableList = nameToPerson.getObservableValues()</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/kotlin.collections.-collection/index.html

@@ -0,0 +1,24 @@
+<HTML>
+<HEAD>
+<title>com.r3corda.client.fxutils.kotlin.collections.Collection - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">kotlin.collections.Collection</a><br/>
+<br/>
+<h3>Extensions for kotlin.collections.Collection</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="sequence.html">sequence</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">Collection</span><span class="symbol">&lt;</span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">sequence</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><p>data class Person(val height: ObservableValue)
+val people: List = listOf(alice, bob)
+val heights: ObservableList = people.map(Person::height).sequence()</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/kotlin.collections.-collection/sequence.html

@@ -0,0 +1,18 @@
+<HTML>
+<HEAD>
+<title>sequence - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href="index.html">kotlin.collections.Collection</a>&nbsp;/&nbsp;<a href=".">sequence</a><br/>
+<br/>
+<h1>sequence</h1>
+<a name="com.r3corda.client.fxutils$sequence(kotlin.collections.Collection((javafx.beans.value.ObservableValue((com.r3corda.client.fxutils.sequence.A)))))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">Collection</span><span class="symbol">&lt;</span><span class="identifier">ObservableValue</span><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">sequence</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<p>data class Person(val height: ObservableValue)
+val people: List = listOf(alice, bob)
+val heights: ObservableList = people.map(Person::height).sequence()</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/record-as-association.html

@@ -0,0 +1,22 @@
+<HTML>
+<HEAD>
+<title>recordAsAssociation - </title>
+<link rel="stylesheet" href="../style.css">
+</HEAD>
+<BODY>
+<a href="index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">recordAsAssociation</a><br/>
+<br/>
+<h1>recordAsAssociation</h1>
+<a name="com.r3corda.client.fxutils$recordAsAssociation(((com.r3corda.client.fxutils.recordAsAssociation.A)), kotlin.Function1((com.r3corda.client.fxutils.recordAsAssociation.A, com.r3corda.client.fxutils.recordAsAssociation.K)), kotlin.Function3((com.r3corda.client.fxutils.recordAsAssociation.K, com.r3corda.client.fxutils.recordAsAssociation.A, , )))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">, </span><span class="identifier">K</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">recordAsAssociation</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.client.fxutils$recordAsAssociation(((com.r3corda.client.fxutils.recordAsAssociation.A)), kotlin.Function1((com.r3corda.client.fxutils.recordAsAssociation.A, com.r3corda.client.fxutils.recordAsAssociation.K)), kotlin.Function3((com.r3corda.client.fxutils.recordAsAssociation.K, com.r3corda.client.fxutils.recordAsAssociation.A, , )))/toKey">toKey</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">K</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.client.fxutils$recordAsAssociation(((com.r3corda.client.fxutils.recordAsAssociation.A)), kotlin.Function1((com.r3corda.client.fxutils.recordAsAssociation.A, com.r3corda.client.fxutils.recordAsAssociation.K)), kotlin.Function3((com.r3corda.client.fxutils.recordAsAssociation.K, com.r3corda.client.fxutils.recordAsAssociation.A, , )))/merge">merge</span><span class="symbol">:</span>&nbsp;<span class="symbol">(</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">,</span>&nbsp;<span class="identifier">A</span><span class="symbol">)</span>&nbsp;<span class="symbol">-&gt;</span>&nbsp;<span class="identifier">A</span>&nbsp;<span class="symbol">=</span>&nbsp;{ _key, _oldValue, newValue -&gt; newValue }<span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableMap</span><span class="symbol">&lt;</span><span class="identifier">K</span><span class="symbol">,</span>&nbsp;<span class="keyword">out</span>&nbsp;<span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<p>This variant simply associates each event with its key.</p>
+<h3>Parameters</h3>
+<a name="toKey"></a>
+<code>toKey</code> - Function retrieving the key to associate with.<br/>
+<br/>
+<a name="merge"></a>
+<code>merge</code> - The function to be called if there is an existing element at the key.<br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.fxutils/record-in-sequence.html

@@ -0,0 +1,16 @@
+<HTML>
+<HEAD>
+<title>recordInSequence - </title>
+<link rel="stylesheet" href="../style.css">
+</HEAD>
+<BODY>
+<a href="index.html">com.r3corda.client.fxutils</a>&nbsp;/&nbsp;<a href=".">recordInSequence</a><br/>
+<br/>
+<h1>recordInSequence</h1>
+<a name="com.r3corda.client.fxutils$recordInSequence(((com.r3corda.client.fxutils.recordInSequence.A)))"></a>
+<code><span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span> <span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">recordInSequence</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">ObservableList</span><span class="symbol">&lt;</span><span class="identifier">A</span><span class="symbol">&gt;</span></code><br/>
+<p>recordInSequence records incoming events on the <a href="#">rx.Observable</a> in sequence.</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.client.mock/-event-generator/index.html

@@ -108,12 +108,6 @@ state/ref pairs, but it doesnt necessarily generate "correct" events</p>
 </tr>
 <tr>
 <td>
-<a href="output-state-generator.html">outputStateGenerator</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">outputStateGenerator</span><span class="symbol">: </span><a href="../-generator/index.html"><span class="identifier">Generator</span></a><span class="symbol">&lt;</span><a href="../../com.r3corda.node.services.monitor/-service-to-client-event/-output-state/index.html"><span class="identifier">OutputState</span></a><span class="symbol">&gt;</span></code></td>
-</tr>
-<tr>
-<td>
 <a href="parties.html">parties</a></td>
 <td>
 <code><span class="keyword">val </span><span class="identifier">parties</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">&gt;</span></code></td>
@@ -136,12 +130,6 @@ state/ref pairs, but it doesnt necessarily generate "correct" events</p>
 <td>
 <code><span class="keyword">val </span><span class="identifier">publicKeyGenerator</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
 </tr>
-<tr>
-<td>
-<a href="service-to-client-event-generator.html">serviceToClientEventGenerator</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">serviceToClientEventGenerator</span><span class="symbol">: </span><a href="../-generator/index.html"><span class="identifier">Generator</span></a><span class="symbol">&lt;</span><a href="../../com.r3corda.node.services.monitor/-service-to-client-event/index.html"><span class="identifier">ServiceToClientEvent</span></a><span class="symbol">&gt;</span></code></td>
-</tr>
 </tbody>
 </table>
 </BODY>