Enum aws_smithy_http_server::plugin::Either

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

Combine two different Futures/Services/ Layers/Plugins 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

One type of backing [Service].

Fields

value: L

Right

The other type of backing [Service].

Fields

value: R

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<Ser, Op, T, Le, Ri> Plugin<Ser, Op, T> for Either<Le, Ri>

where Le: Plugin<Ser, Op, T>, Ri: Plugin<Ser, Op, T>,

type Output = Either<<Le as Plugin<Ser, Op, T>>::Output, <Ri as Plugin<Ser, Op, T>>::Output>

The type of the new Service.

fn apply(&self, input: T) -> Self::Output

Maps a Service 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 PinnedFieldsOf<__Origin<'__pin, L, R>>: Unpin,