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> Rpc<I, R>

where R: 'static + Send,

pub fn detached(input: I) -> Rpc<I, R>

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>(self, f: F)

where F: AsyncFnOnce(I) -> 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, E>(self, f: F) -> Result<(), E>

where F: AsyncFnOnce(I) -> 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> Rpc<I, Result<R, RemoteError>>

where R: 'static + Send,

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

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

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, E>(self, f: F)

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

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

pub fn fail<E>(self, error: E)

where E: Into<Box<dyn Error + Sync + Send>>,

Fails the RPC with the specified error.

Trait Implementations

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

where I: Debug,

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

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.