Struct Exc 

pub struct Exc<C, Req> { /* private fields */ }

The core service wrapper of this crate, which implements ExcService<T> if the request type of the underlying service implements Adaptor<T>.

With the help of Exc, we can use a single type to represent all the services that an exchange can provide.

For example, let Exchange be an api endpoint implementation of a exchange, which implements Service<R>, where R is the request type of the api endpoint. Then Exc<Exchange, R> will implement Service<SubscribeTickers> and Service<PlaceOrder>, as long as R implements both Adaptor<SubscribeTickers> and Adaptor<PlaceOrder>.

Implementations

impl<C, Req> Exc<C, Req>

pub fn into_inner(self) -> C

Into the inner channel.

impl<C, Req> Exc<C, Req>

where Req: Request, C: ExcService<Req>,

pub fn new(service: C) -> Exc<C, Req>

Create from the given ExcService.

pub async fn request( &mut self, request: Req, ) -> Result<<Req as Request>::Response, ExchangeError>

Make a request using the underlying channel directly.

pub fn into_rate_limited( self, num: u64, per: Duration, ) -> Exc<RateLimit<IntoService<C, Req>>, Req>

Apply rate-limit layer to the channel.

pub fn into_retry( self, max_duration: Duration, ) -> Exc<Retry<Always, IntoService<C, Req>>, Req>

where Req: Clone, C: Clone,

Apply retry layer to the channel.

pub fn into_adapted<R>(self) -> Exc<Adapt<IntoService<C, Req>, Req, R>, R>

where R: Request, IntoService<C, Req>: AdaptService<Req, R>,

Adapt the request type of the underlying channel to the target type R.

pub fn into_layered<T, R>( self, layer: &T, ) -> Exc<<T as Layer<IntoService<C, Req>>>::Service, R>

where T: Layer<IntoService<C, Req>>, R: Request, <T as Layer<IntoService<C, Req>>>::Service: ExcService<R>,

Apply a layer to the underlying channel.

Trait Implementations

impl<C, Req> Clone for Exc<C, Req>

where C: Clone,

fn clone(&self) -> Exc<C, Req>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C, Req> Debug for Exc<C, Req>

where C: Debug, Req: Debug,

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

Formats the value using the given formatter.

impl<C, Req, R> Service<R> for Exc<C, Req>

where R: Request, <R as Request>::Response: Send + 'static, Req: Adaptor<R>, C: ExcService<Req>, <C as ExcService<Req>>::Future: Send + 'static,

type Response = <R as Request>::Response

Responses given by the service.

type Error = ExchangeError

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<Exc<C, Req> as Service<R>>::Response, <Exc<C, Req> as Service<R>>::Error>> + Send>>

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <Exc<C, Req> as Service<R>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: R) -> <Exc<C, Req> as Service<R>>::Future

Process the request and return the response asynchronously.