Struct quic_rpc::client::RpcClient

pub struct RpcClient<S, C, SInner = S> { /* private fields */ }

A client for a specific service

This is a wrapper around a ServiceConnection that serves as the entry point for the client DSL. S is the service type, C is the substream source.

Implementations

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

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

pub fn new(source: C) -> Self

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

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

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

where S: Service, C: ServiceConnection<S>, SInner: Service,

pub fn into_inner(self) -> C

Get the underlying connection

pub fn map<SNext>(self) -> RpcClient<S, C, SNext>

where SNext: Service, SNext::Req: Into<SInner::Req> + TryFrom<SInner::Req>, SNext::Res: Into<SInner::Res> + TryFrom<SInner::Res>,

Map this channel’s service into an inner service.

This method is available if the required bounds are upheld: SNext::Req: IntoSInner::Req + TryFromSInner::Req, SNext::Res: IntoSInner::Res + TryFromSInner::Res,

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

This method can be chained infintely.

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

where S: Service, C: ServiceConnection<S>, SInner: Service,

pub async fn bidi<M>( &self, msg: M, ) -> Result<(UpdateSink<S, C, M::Update, SInner>, BoxStreamSync<'static, Result<M::Response, ItemError<C>>>), Error<C>>

where M: BidiStreamingMsg<SInner>,

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

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

where S: Service, C: ServiceConnection<S>, SInner: Service,

pub async fn client_streaming<M>( &self, msg: M, ) -> Result<(UpdateSink<S, C, M::Update, SInner>, Boxed<Result<M::Response, ItemError<C>>>), Error<C>>

where M: ClientStreamingMsg<SInner>,

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

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

where S: Service, C: ServiceConnection<S>, SInner: Service,

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

where M: RpcMsg<SInner>,

RPC call to the server, single request, single response

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

where S: Service, C: ServiceConnection<S>, SInner: Service,

pub async fn server_streaming<M>( &self, msg: M, ) -> Result<BoxStreamSync<'static, Result<M::Response, ItemError<C>>>, Error<C>>

where M: ServerStreamingMsg<SInner>,

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

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

where S: Service, C: ServiceConnection<S>, SInner: Service,

pub async fn try_server_streaming<M>( &self, msg: M, ) -> Result<BoxStreamSync<'static, Result<M::Item, ItemError<C, M::ItemError>>>, Error<C, M::CreateError>>

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

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

Trait Implementations

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

where S: Service, C: ServiceConnection<S>, SInner: Service,

fn as_ref(&self) -> &C

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

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.