Struct CallFuture 

pub struct CallFuture<C, Args, Ok, Err>
where
    C: Caller,
    Args: Facet<'static>,
{ /* private fields */ }

A future representing an RPC call that can be configured with metadata.

This provides a builder pattern for RPC calls:

• client.method(args).await - Simple call with default (empty) metadata
• client.method(args).with_metadata(meta).await - Call with custom metadata

The future is lazy - the RPC call is not made until .await is called.

Example

// Simple call
let result = client.subscribe(route).await?;

// With metadata
let result = client.subscribe(route)
    .with_metadata(vec![("trace-id".into(), MetadataValue::String("abc".into()))])
    .await?;

Implementations

impl<C, Args, Ok, Err> CallFuture<C, Args, Ok, Err>

where C: Caller, Args: Facet<'static>,

pub fn new(caller: C, method_id: u64, args: Args) -> Self

Create a new CallFuture.

pub fn with_metadata(self, metadata: Metadata) -> Self

Set metadata for this call.

Metadata is a list of key-value pairs that will be sent with the request. The server can access this via Context::metadata().

Trait Implementations

impl<C, Args, Ok, Err> IntoFuture for CallFuture<C, Args, Ok, Err>

where C: Caller, Args: Facet<'static> + Send + 'static, Ok: Facet<'static> + Send + 'static, Err: Facet<'static> + Send + 'static,

Available on non-WebAssembly only.

type Output = Result<Ok, CallError<Err>>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <CallFuture<C, Args, Ok, Err> as IntoFuture>::Output> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.