corda / net.corda.core.messaging

Package net.corda.core.messaging

Data types used by the Corda messaging layer to manage state of messaging and sessions between nodes.

Types

AllPossibleRecipients

interface AllPossibleRecipients : MessageRecipients

A special base class for the set of all possible recipients, without having to identify who they all are.

CordaRPCOps

interface CordaRPCOps : RPCOps

RPC operations that the node exposes to clients.

DataFeed

data class DataFeed<out A, B>

The Data feed contains a snapshot of the requested data and an Observable of future updates.

FlowHandle

interface FlowHandle<A> : AutoCloseable

FlowHandle is a serialisable handle for the started flow, parameterised by the type of the flow's return value.

FlowHandleImpl

data class FlowHandleImpl<A> : FlowHandle<A>

FlowProgressHandle

interface FlowProgressHandle<A> : FlowHandle<A>

FlowProgressHandle is a serialisable handle for the started flow, parameterised by the type of the flow's return value.

FlowProgressHandleImpl

data class FlowProgressHandleImpl<A> : FlowProgressHandle<A>

MessageRecipientGroup

interface MessageRecipientGroup : MessageRecipients

A base class for a set of recipients specifically identified by the sender.

MessageRecipients

interface MessageRecipients

The interface for a group of message recipients (which may contain only one recipient)

RPCOps

interface RPCOps

Base interface that all RPC servers must implement. Note: in Corda there's only one RPC interface. This base interface is here in case we split the RPC system out into a separate library one day.

SingleMessageRecipient

interface SingleMessageRecipient : MessageRecipients

A base class for the case of point-to-point messages

StateMachineInfo

data class StateMachineInfo

StateMachineTransactionMapping

data class StateMachineTransactionMapping

StateMachineUpdate

sealed class StateMachineUpdate

Annotations

RPCReturnsObservables

annotation class RPCReturnsObservables

If an RPC is tagged with this annotation it may return one or more observables anywhere in its response graph. Calling such a method comes with consequences: it's slower, and consumes server side resources as observations will buffer up on the server until they're consumed by the client.

Functions

startFlow

fun <T, R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: () -> R): FlowHandle<T>
fun <T, A, R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A) -> R, arg0: A): FlowHandle<T>
fun <T, A, B, C, R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A, B, C) -> R, arg0: A, arg1: B, arg2: C): FlowHandle<T>
fun <T, A, B, C, D, R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A, B, C, D) -> R, arg0: A, arg1: B, arg2: C, arg3: D): FlowHandle<T>
fun <T, A, B, C, D, E, R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A, B, C, D, E) -> R, arg0: A, arg1: B, arg2: C, arg3: D, arg4: E): FlowHandle<T>
fun <T, A, B, C, D, E, F, R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A, B, C, D, E, F) -> R, arg0: A, arg1: B, arg2: C, arg3: D, arg4: E, arg5: F): FlowHandle<T>fun <T, A, B, R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A, B) -> R, arg0: A, arg1: B): FlowHandle<T>

Extension function for type safe invocation of flows from Kotlin, for example:

startTrackedFlow

fun <T, R : FlowLogic<T>> CordaRPCOps.startTrackedFlow(flowConstructor: () -> R): FlowProgressHandle<T>

Extension function for type safe invocation of flows from Kotlin, with progress tracking enabled.

fun <T, A, R : FlowLogic<T>> CordaRPCOps.startTrackedFlow(flowConstructor: (A) -> R, arg0: A): FlowProgressHandle<T>
fun <T, A, B, R : FlowLogic<T>> CordaRPCOps.startTrackedFlow(flowConstructor: (A, B) -> R, arg0: A, arg1: B): FlowProgressHandle<T>
fun <T, A, B, C, R : FlowLogic<T>> CordaRPCOps.startTrackedFlow(flowConstructor: (A, B, C) -> R, arg0: A, arg1: B, arg2: C): FlowProgressHandle<T>
fun <T, A, B, C, D, R : FlowLogic<T>> CordaRPCOps.startTrackedFlow(flowConstructor: (A, B, C, D) -> R, arg0: A, arg1: B, arg2: C, arg3: D): FlowProgressHandle<T>
fun <T, A, B, C, D, E, R : FlowLogic<T>> CordaRPCOps.startTrackedFlow(flowConstructor: (A, B, C, D, E) -> R, arg0: A, arg1: B, arg2: C, arg3: D, arg4: E): FlowProgressHandle<T>
fun <T, A, B, C, D, E, F, R : FlowLogic<T>> CordaRPCOps.startTrackedFlow(flowConstructor: (A, B, C, D, E, F) -> R, arg0: A, arg1: B, arg2: C, arg3: D, arg4: E, arg5: F): FlowProgressHandle<T>

vaultQueryBy

fun <T : ContractState> CordaRPCOps.vaultQueryBy(criteria: QueryCriteria = QueryCriteria.VaultQueryCriteria(), paging: PageSpecification = PageSpecification(), sorting: Sort = Sort(emptySet())): Page<T>

vaultTrackBy

fun <T : ContractState> CordaRPCOps.vaultTrackBy(criteria: QueryCriteria = QueryCriteria.VaultQueryCriteria(), paging: PageSpecification = PageSpecification(), sorting: Sort = Sort(emptySet())): DataFeed<Page<T>, Update<T>>