Struct Rpc

pub struct Rpc<I, R>(/* private fields */);

An RPC message for a request with input of type I and output of type R. The receiver of the message should process the request and return results via the Sender<R>.

Implementations

impl<I, R: 'static + Send> Rpc<I, R>

pub fn detached(input: I) -> Self

Returns a new RPC message with input and no one listening for the result.

pub fn input(&self) -> &I

Returns the input to the RPC.

pub fn split(self) -> (I, Rpc<(), R>)

Splits the RPC into its input and an input-less RPC. This is useful when the input is needed in one place but the RPC will be completed in another.

pub fn handle_sync<F>(self, f: F)

where F: FnOnce(I) -> R,

Handles an RPC request by calling f and sending the result to the initiator.

pub async fn handle<F, Fut>(self, f: F)

where F: FnOnce(I) -> Fut, Fut: Future<Output = R>,

Handles an RPC request by calling f, awaiting its result, and sending the result to the initiator.

pub async fn handle_must_succeed<F, Fut, E>(self, f: F) -> Result<(), E>

where F: FnOnce(I) -> Fut, Fut: Future<Output = Result<R, E>>,

Handles an RPC request by calling f, awaiting its result, and sending Ok results back to the initiator.

If f fails, the error is propagated back to the caller, and the RPC channel is dropped (resulting in a RecvError::Closed on the initiator).

pub fn complete(self, result: R)

Completes the RPC with the specified result value.

impl<I, R: 'static + Send> Rpc<I, Result<R, RemoteError>>

pub fn handle_failable_sync<F, E>(self, f: F)

where F: FnOnce(I) -> Result<R, E>, E: Into<Box<dyn Error + Send + Sync>>,

Handles an RPC request by calling f and sending the result to the initiator, after converting any error to a RemoteError.

pub async fn handle_failable<F, Fut, E>(self, f: F)

where F: FnOnce(I) -> Fut, Fut: Future<Output = Result<R, E>>, E: Into<Box<dyn Error + Send + Sync>>,

Handles an RPC request by calling f, awaiting its result, and sending the result to the initiator, after converting any error to a RemoteError.

Trait Implementations

impl<I: Debug, R: Debug> Debug for Rpc<I, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I, R> DefaultEncoding for Rpc<I, R>

where I: 'static + MeshField + Send, R: 'static + MeshField + Send,

type Encoding = TableEncoder

The encoding to use for the serialization.

impl<'encoding, I, R> StructDecodeMetadata<'encoding, Resource> for Rpc<I, R>

where I: 'static + MeshField + Send, R: 'static + MeshField + Send,

const DECODERS: &'static [ErasedDecoderEntry] = _

The list of decoder vtables.

impl<I, R> StructEncodeMetadata<Resource> for Rpc<I, R>

where I: 'static + MeshField + Send, R: 'static + MeshField + Send,

const ENCODERS: &'static [ErasedEncoderEntry] = _

The list of encoder vtables.

impl<I, R> StructMetadata for Rpc<I, R>

where I: 'static + MeshField + Send, R: 'static + MeshField + Send,

const NUMBERS: &'static [u32] = _

The field numbers for each field.

const OFFSETS: &'static [usize] = _

The byte offset to each field within the struct.