Enum service_async::either::Either

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

Variants

Left(A)

Right(B)

Implementations

impl<A, B> Either<A, B>

pub fn as_pin_ref(self: Pin<&Self>) -> Either<Pin<&A>, Pin<&B>>

Convert Pin<&Either<A, B>> to Either<Pin<&A>, Pin<&B>>, pinned projections of the inner variants.

pub fn as_pin_mut(self: Pin<&mut Self>) -> Either<Pin<&mut A>, Pin<&mut B>>

Convert Pin<&mut Either<A, B>> to Either<Pin<&mut A>, Pin<&mut B>>, pinned projections of the inner variants.

impl<T> Either<T, T>

pub fn into_inner(self) -> T

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: Display, B: Display> Display for Either<A, B>

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

Formats the value using the given formatter.

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

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type based access to context intended for error reports.

impl<C, F, FLA, FLB> FactoryLayer<C, F> for Either<FLA, FLB>

where FLA: FactoryLayer<C, F>, FLB: FactoryLayer<C, F>,

type Factory = Either<<FLA as FactoryLayer<C, F>>::Factory, <FLB as FactoryLayer<C, F>>::Factory>

fn layer(&self, config: &C, inner: F) -> Self::Factory

impl<A, B> Future for Either<A, B>

where A: Future, B: Future<Output = A::Output>,

type Output = <A 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<A, B> MakeService for Either<A, B>

where A: MakeService, B: MakeService,

type Service = Either<<A as MakeService>::Service, <B as MakeService>::Service>

type Error = Either<<A as MakeService>::Error, <B as MakeService>::Error>

fn make_via_ref( &self, old: Option<&Self::Service> ) -> Result<Self::Service, Self::Error>

fn make(&self) -> Result<Self::Service, Self::Error>

impl<A, B, R> Service<R> for Either<A, B>

where A: Service<R>, B: Service<R, Response = A::Response, Error = A::Error>,

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

Responses given by the service.

type Error = <A as Service<R>>::Error

Errors produced by the service.

fn call( &self, req: R ) -> impl Future<Output = Result<Self::Response, Self::Error>>

Process the request and return the response asynchronously.