net.corda.core.messaging - corda

corda / net.corda.core.messaging

## Package net.corda.core.messaging

### Types

#### AllPossibleRecipients | A special base class for the set of all possible recipients, without having to identify who they all are. `interface AllPossibleRecipients : MessageRecipients`
#### ClientRpcSslOptions | As an RPC Client, use this class to point to the truststore that contains the RPC SSL certificate provided by the node admin `data class ClientRpcSslOptions`
#### CordaRPCOps | RPC operations that the node exposes to clients. `interface CordaRPCOps : RPCOps`
#### DataFeed | The Data feed contains a snapshot of the requested data and an Observable of future updates. `data class DataFeed<out A, B>`
#### FlowHandle | FlowHandle is a serialisable handle for the started flow, parameterised by the type of the flow's return value. `interface FlowHandle<A> : AutoCloseable`
#### FlowHandleImpl | `data class FlowHandleImpl<A> : FlowHandle<A>`
#### FlowHandleWithClientId | `interface FlowHandleWithClientId<A> : FlowHandle<A>`
#### FlowHandleWithClientIdImpl | `data class FlowHandleWithClientIdImpl<A> : FlowHandleWithClientId<A>`
#### FlowInfo | An alias for StateMachineInfo which uses more modern terminology. `typealias FlowInfo = StateMachineInfo`
#### FlowProgressHandle | FlowProgressHandle is a serialisable handle for the started flow, parameterised by the type of the flow's return value. `interface FlowProgressHandle<A> : FlowHandle<A>`
#### FlowProgressHandleImpl | `data class FlowProgressHandleImpl<A> : FlowProgressHandle<A>`
#### MessageRecipientGroup | A base class for a set of recipients specifically identified by the sender. `interface MessageRecipientGroup : MessageRecipients`
#### MessageRecipients | The interface for a group of message recipients (which may contain only one recipient) `interface MessageRecipients`
#### ParametersUpdateInfo | Data class containing information about the scheduled network parameters update. The info is emitted every time node receives network map with ParametersUpdate which wasn't seen before. For more information see: CordaRPCOps.networkParametersFeed and CordaRPCOps.acceptNewNetworkParameters. `data class ParametersUpdateInfo`
#### 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. `interface RPCOps`
#### SingleMessageRecipient | A base class for the case of point-to-point messages `interface SingleMessageRecipient : MessageRecipients`
#### StateMachineInfo | Represents information about a flow (the name "state machine" is legacy, Kotlin users can use the FlowInfo type alias). You can access progress tracking, information about why the flow was started and so on. `data class StateMachineInfo`
#### StateMachineTransactionMapping | `data class StateMachineTransactionMapping`
#### StateMachineUpdate | `sealed class StateMachineUpdate`

### Annotations

#### 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. `annotation class RPCReturnsObservables`

### Functions

#### pendingFlowsCount | Returns a DataFeed of the number of pending flows. The Observable for the updates will complete the moment all pending flows will have terminated. `fun CordaRPCOps.pendingFlowsCount(): DataFeed<Int, Pair<Int, Int>>`
#### 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>` Extension function for type safe invocation of flows from Kotlin, for example: `fun <T, A, B, R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A, B) -> R, arg0: A, arg1: B): FlowHandle<T>`
#### startFlowWithClientId | Extension function for type safe invocation of flows from Kotlin, with clientId. `fun <T, R : FlowLogic<T>> CordaRPCOps.startFlowWithClientId(clientId: String, flowConstructor: () -> R): FlowHandleWithClientId<T>``fun <T, A, R : FlowLogic<T>> CordaRPCOps.startFlowWithClientId(clientId: String, flowConstructor: (A) -> R, arg0: A): FlowHandleWithClientId<T>` `fun <T, A, B, R : FlowLogic<T>> CordaRPCOps.startFlowWithClientId(clientId: String, flowConstructor: (A, B) -> R, arg0: A, arg1: B): FlowHandleWithClientId<T>` `fun <T, A, B, C, R : FlowLogic<T>> CordaRPCOps.startFlowWithClientId(clientId: String, flowConstructor: (A, B, C) -> R, arg0: A, arg1: B, arg2: C): FlowHandleWithClientId<T>` `fun <T, A, B, C, D, R : FlowLogic<T>> CordaRPCOps.startFlowWithClientId(clientId: String, flowConstructor: (A, B, C, D) -> R, arg0: A, arg1: B, arg2: C, arg3: D): FlowHandleWithClientId<T>` `fun <T, A, B, C, D, E, R : FlowLogic<T>> CordaRPCOps.startFlowWithClientId(clientId: String, flowConstructor: (A, B, C, D, E) -> R, arg0: A, arg1: B, arg2: C, arg3: D, arg4: E): FlowHandleWithClientId<T>` `fun <T, A, B, C, D, E, F, R : FlowLogic<T>> CordaRPCOps.startFlowWithClientId(clientId: String, flowConstructor: (A, B, C, D, E, F) -> R, arg0: A, arg1: B, arg2: C, arg3: D, arg4: E, arg5: F): FlowHandleWithClientId<T>`
#### startTrackedFlow | Extension function for type safe invocation of flows from Kotlin, with progress tracking enabled. `fun <T, R : FlowLogic<T>> CordaRPCOps.startTrackedFlow(flowConstructor: () -> R): FlowProgressHandle<T>``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>>`