Trait AsyncOperator 

pub trait AsyncOperator<I> {
    type Output;
    type Error;
    type Future<'a>: Future<Output = Result<Self::Output, Self::Error>>
       where Self: 'a;

    // Required methods
    fn poll_ready(
        &mut self,
        cx: &mut Context<'_>,
    ) -> Poll<Result<(), Self::Error>>;
    fn next(&mut self, input: I) -> Self::Future<'_>;
}

Async Operator. It can be seen as an alias of tower_service::Service.

Required Associated Types

type Output

Output type.

type Error

Error type.

type Future<'a>: Future<Output = Result<Self::Output, Self::Error>> where Self: 'a

The future output value.

Required Methods

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Check if the operator is ready to process the next input.

fn next(&mut self, input: I) -> Self::Future<'_>

Process the next input.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<I, E, F, P> AsyncOperator<I> for MapErr<F, P>

where P: AsyncOperator<I>, F: FnMut(P::Error) -> E,

type Output = <P as AsyncOperator<I>>::Output

type Error = E

type Future<'a> = MapErr<<P as AsyncOperator<I>>::Future<'a>, &'a mut F> where P: 'a, F: 'a

impl<I, E, P1, P2> AsyncOperator<I> for Then<I, P1, P2>

where P1: AsyncOperator<I, Error = E>, P2: AsyncOperator<P1::Output, Error = E>,

type Output = <P2 as AsyncOperator<<P1 as AsyncOperator<I>>::Output>>::Output

type Error = E

type Future<'a> = AndThenFuture<'a, <P1 as AsyncOperator<I>>::Future<'a>, P2> where I: 'a, P1: 'a, P2: 'a

impl<P, I, O> AsyncOperator<I> for Next<P>

where P: Operator<I, Output = O>,

type Output = O

type Error = Infallible

type Future<'a> = Ready<Result<<Next<P> as AsyncOperator<I>>::Output, <Next<P> as AsyncOperator<I>>::Error>> where P: 'a

impl<S, I, O> AsyncOperator<I> for ServiceOp<S>

where S: Service<I, Response = O>,

type Output = O

type Error = <S as Service<I>>::Error

type Future<'a> = <S as Service<I>>::Future where S: 'a