Struct RpcClient

pub struct RpcClient<S, C = BoxedConnector<<S as Service>::Res, <S as Service>::Req>> { /* private fields */ }

A client for a specific service

This is a wrapper around a Connector that serves as the entry point for the client DSL.

Type parameters:

S is the service type that determines what interactions this client supports. C is the connector that determines the transport.

Implementations

impl<S, C> RpcClient<S, C>

where S: Service, C: Connector<S>,

pub fn new(source: C) -> RpcClient<S, C>

Create a new rpc client for a specific Service given a compatible Connector.

This is where a generic typed connection is converted into a client for a specific service.

You can get a client for a nested service by calling map.

impl<S, C> RpcClient<S, C>

where S: Service, C: Connector<S>,

pub fn into_inner(self) -> C

Get the underlying connection

pub fn map<SNext>( self, ) -> RpcClient<SNext, MappedConnector<<SNext as Service>::Res, <SNext as Service>::Req, C>>

where SNext: Service, <S as Service>::Req: From<<SNext as Service>::Req>, <SNext as Service>::Res: TryFrom<<S as Service>::Res>,

Map this channel’s service into an inner service.

This method is available if the required bounds are upheld: SNext::Req: Into<S::Req> + TryFrom<S::Req>, SNext::Res: Into<S::Res> + TryFrom<S::Res>,

Where SNext is the new service to map to and S is the current inner service.

This method can be chained infintely.

pub fn boxed(self) -> RpcClient<S>

where C: BoxableConnector<<S as Service>::Res, <S as Service>::Req>,

box

impl<S, C> RpcClient<S, C>

where S: Service, C: Connector<In = <S as Service>::Res, Out = <S as Service>::Req>,

pub async fn bidi<M>( &self, msg: M, ) -> Result<(UpdateSink<C, <M as BidiStreamingMsg<S>>::Update>, Pin<Box<dyn Stream<Item = Result<<M as BidiStreamingMsg<S>>::Response, ItemError<C>>> + Send + Sync>>), Error<C>>

where M: BidiStreamingMsg<S>,

Bidi call to the server, request opens a stream, response is a stream

impl<S, C> RpcClient<S, C>

where S: Service, C: Connector<S>,

pub async fn client_streaming<M>( &self, msg: M, ) -> Result<(UpdateSink<C, <M as ClientStreamingMsg<S>>::Update>, Pin<Box<dyn Future<Output = Result<<M as ClientStreamingMsg<S>>::Response, ItemError<C>>> + Send>>), Error<C>>

where M: ClientStreamingMsg<S>,

Call to the server that allows the client to stream, single response

impl<S, C> RpcClient<S, C>

where S: Service, C: Connector<S>,

pub async fn rpc<M>( &self, msg: M, ) -> Result<<M as RpcMsg<S>>::Response, Error<C>>

where M: RpcMsg<S>,

RPC call to the server, single request, single response

impl<S, C> RpcClient<S, C>

where C: Connector<S>, S: Service,

pub async fn server_streaming<M>( &self, msg: M, ) -> Result<Pin<Box<dyn Stream<Item = Result<<M as ServerStreamingMsg<S>>::Response, ItemError<C>>> + Send + Sync>>, Error<C>>

where M: ServerStreamingMsg<S>,

Bidi call to the server, request opens a stream, response is a stream

impl<S, C> RpcClient<S, C>

where C: Connector<S>, S: Service,

pub async fn try_server_streaming<M>( &self, msg: M, ) -> Result<Pin<Box<dyn Stream<Item = Result<<M as TryServerStreamingMsg<S>>::Item, ItemError<C, <M as TryServerStreamingMsg<S>>::ItemError>>> + Send + Sync>>, Error<C, <M as TryServerStreamingMsg<S>>::CreateError>>

where M: TryServerStreamingMsg<S>, Result<<M as TryServerStreamingMsg<S>>::Item, <M as TryServerStreamingMsg<S>>::ItemError>: Into<<S as Service>::Res> + TryFrom<<S as Service>::Res>, Result<StreamCreated, <M as TryServerStreamingMsg<S>>::CreateError>: Into<<S as Service>::Res> + TryFrom<<S as Service>::Res>,

Bidi call to the server, request opens a stream, response is a stream

Trait Implementations

impl<S, C> AsRef<C> for RpcClient<S, C>

where S: Service, C: Connector<S>,

fn as_ref(&self) -> &C

Converts this type into a shared reference of the (usually inferred) input type.

impl<S, C> Clone for RpcClient<S, C>

where C: Clone,

fn clone(&self) -> RpcClient<S, C>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, C> Debug for RpcClient<S, C>

where S: Debug, C: Debug,

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

Formats the value using the given formatter.