Enum tower::util::Either

pub enum Either<A, B> {
    A(A),
    B(B),
}

Combine two different service types into a single type.

Both services must be of the same request, response, and error types. Either is useful for handling conditional branching in service middleware to different inner service types.

Variants

A(A)

One type of backing Service.

B(B)

The other type of backing Service.

Trait Implementations

impl<A: Clone, B: Clone> Clone for Either<A, B>

fn clone(&self) -> Either<A, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug> Debug for Either<A, B>

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

Formats the value using the given formatter.

impl<A, B, T, AE, BE> Future for Either<A, B>where A: Future<Output = Result<T, AE>>, AE: Into<BoxError>, B: Future<Output = Result<T, BE>>, BE: Into<BoxError>,

type Output = Result<T, Box<dyn Error + Send + Sync + 'static, Global>>

The type of value produced on completion.

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

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

impl<S, A, B> Layer<S> for Either<A, B>where A: Layer<S>, B: Layer<S>,

type Service = Either<<A as Layer<S>>::Service, <B as Layer<S>>::Service>

The wrapped service

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.

impl<A, B, Request> Service<Request> for Either<A, B>where A: Service<Request>, A::Error: Into<BoxError>, B: Service<Request, Response = A::Response>, B::Error: Into<BoxError>,

type Response = <A as Service<Request>>::Response

Responses given by the service.

type Error = Box<dyn Error + Send + Sync + 'static, Global>

Errors produced by the service.

type Future = Either<<A as Service<Request>>::Future, <B as Service<Request>>::Future>

The future response value.

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

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

fn call(&mut self, request: Request) -> Self::Future

Process the request and return the response asynchronously.

impl<'pin, A, B> Unpin for Either<A, B>where __Either<'pin, A, B>: Unpin,