Enum aws_smithy_http_server::plugin::Either

pub enum Either<L, R> {
    Left {
        value: L,
    },
    Right {
        value: R,
    },
}

Combine two different Future/[Service]/[Layer]/Plugin types into a single type.

Notes on Future

The Future::Output must be identical.

Notes on [Service]

The [Service::Response] and [Service::Error] must be identical.

Variants

Left

Fields

value: L

One type of backing [Service].

Right

Fields

value: R

The other type of backing [Service].

Trait Implementations

impl<L: Clone, R: Clone> Clone for Either<L, R>

fn clone(&self) -> Either<L, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Debug, R: Debug> Debug for Either<L, R>

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

Formats the value using the given formatter.

impl<L, R> Future for Either<L, R>where L: Future, R: Future<Output = L::Output>,

type Output = <L as Future>::Output

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, L, R> Layer<S> for Either<L, R>where L: Layer<S>, R: Layer<S>,

type Service = Either<<L as Layer<S>>::Service, <R 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<P, Op, S, L, Le, Ri> Plugin<P, Op, S, L> for Either<Le, Ri>where Le: Plugin<P, Op, S, L>, Ri: Plugin<P, Op, S, L>,

type Service = Either<<Le as Plugin<P, Op, S, L>>::Service, <Ri as Plugin<P, Op, S, L>>::Service>

The type of the new Service.

type Layer = Either<<Le as Plugin<P, Op, S, L>>::Layer, <Ri as Plugin<P, Op, S, L>>::Layer>

The type of the new Layer.

fn map(&self, input: Operation<S, L>) -> Operation<Self::Service, Self::Layer>

Maps an Operation to another.

impl<L, R, Request> Service<Request> for Either<L, R>where L: Service<Request>, R: Service<Request, Response = L::Response, Error = L::Error>,

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

Responses given by the service.

type Error = <L as Service<Request>>::Error

Errors produced by the service.

type Future = Either<<L as Service<Request>>::Future, <R 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, L, R> Unpin for Either<L, R>where __Origin<'__pin, L, R>: Unpin,