Enum ProviderCall

pub enum ProviderCall<Conn, Params, Resp, Output = Resp, Map = fn(_: Resp) -> Output>
where
    Conn: Transport + Clone,
    Params: RpcParam,
    Resp: RpcReturn,
    Map: Fn(Resp) -> Output,
{
    RpcCall(RpcCall<Conn, Params, Resp, Output, Map>),
    Waiter(Waiter<Resp, Output, Map>),
    BoxedFuture(Pin<Box<dyn Future<Output = TransportResult<Output>> + Send>>),
    Ready(Option<TransportResult<Output>>),
}

The primary future type for the Provider.

This future abstracts over several potential data sources. It allows providers to:

• produce data via an RpcCall
• produce data by waiting on a batched RPC Waiter
• proudce data via an arbitrary boxed future
• produce data in any synchronous way

Variants

RpcCall(RpcCall<Conn, Params, Resp, Output, Map>)

An underlying call to an RPC server.

Waiter(Waiter<Resp, Output, Map>)

A waiter for a batched call to a remote RPC server.

BoxedFuture(Pin<Box<dyn Future<Output = TransportResult<Output>> + Send>>)

A boxed future.

Ready(Option<TransportResult<Output>>)

The output, produces synchronously.

Implementations

impl<Conn, Params, Resp, Output, Map> ProviderCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam, Resp: RpcReturn, Map: Fn(Resp) -> Output,

pub const fn ready(output: TransportResult<Output>) -> Self

Instantiate a new ProviderCall from the output.

pub const fn is_rpc_call(&self) -> bool

True if this is an RPC call.

pub const fn as_rpc_call( &self, ) -> Option<&RpcCall<Conn, Params, Resp, Output, Map>>

Fallible cast to RpcCall

pub fn as_mut_rpc_call( &mut self, ) -> Option<&mut RpcCall<Conn, Params, Resp, Output, Map>>

Fallible cast to mutable RpcCall

pub const fn is_waiter(&self) -> bool

True if this is a waiter.

pub const fn as_waiter(&self) -> Option<&Waiter<Resp, Output, Map>>

Fallible cast to Waiter

pub fn as_mut_waiter(&mut self) -> Option<&mut Waiter<Resp, Output, Map>>

Fallible cast to mutable Waiter

pub const fn is_boxed_future(&self) -> bool

True if this is a boxed future.

pub const fn as_boxed_future( &self, ) -> Option<&Pin<Box<dyn Future<Output = TransportResult<Output>> + Send>>>

Fallible cast to a boxed future.

pub const fn is_ready(&self) -> bool

True if this is a ready value.

pub const fn as_ready(&self) -> Option<&TransportResult<Output>>

Fallible cast to a ready value.

Panics

Panics if the future is already complete

pub fn map_resp<NewOutput, NewMap>( self, map: NewMap, ) -> Result<ProviderCall<Conn, Params, Resp, NewOutput, NewMap>, Self>

where NewMap: Fn(Resp) -> NewOutput + Clone,

Set a function to map the response into a different type. This is useful for transforming the response into a more usable type, e.g. changing U64 to u64.

This function fails if the inner future is not an RpcCall or Waiter.

Note

Carefully review the rust documentation on fn pointers before passing them to this function. Unless the pointer is specifically coerced to a fn(_) -> _, the NewMap will be inferred as that function’s unique type. This can lead to confusing error messages.

impl<Conn, Params, Resp, Output, Map> ProviderCall<Conn, &Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam + ToOwned, Params::Owned: RpcParam, Resp: RpcReturn, Map: Fn(Resp) -> Output,

pub fn into_owned_params( self, ) -> ProviderCall<Conn, Params::Owned, Resp, Output, Map>

Convert this call into one with owned params, by cloning the params.

Panics

Panics if called after the request has been polled.

Trait Implementations

impl<Conn, Params, Resp> Debug for ProviderCall<Conn, Params, Resp>

where Conn: Transport + Clone, Params: RpcParam, Resp: RpcReturn,

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

Formats the value using the given formatter.

impl<Conn, Params, Resp, Output, Map> From<Pin<Box<dyn Future<Output = Result<Output, RpcError<TransportErrorKind>>> + Send>>> for ProviderCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam, Resp: RpcReturn, Map: Fn(Resp) -> Output,

fn from( fut: Pin<Box<dyn Future<Output = TransportResult<Output>> + Send>>, ) -> Self

Converts to this type from the input type.

impl<Conn, Params, Resp> From<Receiver<Result<Box<RawValue>, RpcError<TransportErrorKind>>>> for ProviderCall<Conn, Params, Resp>

where Conn: Transport + Clone, Params: RpcParam, Resp: RpcReturn,

fn from(rx: Receiver<TransportResult<Box<RawValue>>>) -> Self

Converts to this type from the input type.

impl<Conn, Params, Resp, Output, Map> From<RpcCall<Conn, Params, Resp, Output, Map>> for ProviderCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam, Resp: RpcReturn, Map: Fn(Resp) -> Output,

fn from(call: RpcCall<Conn, Params, Resp, Output, Map>) -> Self

Converts to this type from the input type.

impl<Conn, Params, Resp> From<Waiter<Resp>> for ProviderCall<Conn, Params, Resp, Resp, fn(_: Resp) -> Resp>

where Conn: Transport + Clone, Params: RpcParam, Resp: RpcReturn,

fn from(waiter: Waiter<Resp>) -> Self

Converts to this type from the input type.

impl<Conn, Params, Resp, Output, Map> Future for ProviderCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam, Resp: RpcReturn, Output: 'static, Map: Fn(Resp) -> Output,

type Output = Result<Output, RpcError<TransportErrorKind>>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'pin, Conn, Params, Resp, Output, Map> Unpin for ProviderCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam, Resp: RpcReturn, Map: Fn(Resp) -> Output, __ProviderCall<'pin, Conn, Params, Resp, Output, Map>: Unpin,