[−][src]Enum actix_utils::either::EitherService

pub enum EitherService<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. EitherService is useful for handling conditional branching in service middleware to different inner service types.

Variants

A(A)B(B)

Trait Implementations

impl<A: Clone, B: Clone> Clone for EitherService<A, B>[src]

fn clone_from(&mut self, source: &Self)
1.0.0
[src]

Performs copy-assignment from source. Read more

impl<A, B> Service for EitherService<A, B> where
    A: Service,
    B: Service<Request = A::Request, Response = A::Response, Error = A::Error>, [src]

type Request = A::Request

Requests handled by the service.

type Response = A::Response

Responses given by the service.

type Error = A::Error

Errors produced by the service.

type Future = Either<A::Future, B::Future>

The future response value.

Auto Trait Implementations

impl<A, B> Send for EitherService<A, B> where
    A: Send,
    B: Send, 

impl<A, B> Sync for EitherService<A, B> where
    A: Sync,
    B: Sync, 

Blanket Implementations

impl<T, U> Into for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

impl<T> From for T[src]

impl<T, U> TryFrom for T where
    U: Into<T>, [src]

type Error = !

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

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized, [src]

impl<T> BorrowMut for T where
    T: ?Sized, [src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

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

The type returned in the event of a conversion error.

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> IntoService for T where
    T: Service, [src]

impl<T> ServiceExt for T where
    T: Service + ?Sized, [src]

fn apply<T, T1, B, B1>(
    self,
    transform: T1,
    service: B1
) -> AndThenTransform<T, Self, B> where
    B: Service<Error = Self::Error>,
    B1: IntoService<B>,
    T: Transform<B, Request = Self::Response>,
    T1: IntoTransform<T, B>,
    <T as Transform<B>>::Error: From<Self::Error>, [src]

Apply tranformation to specified service and use it as a next service in chain. Read more

fn apply_fn<F, B, B1, Out>(
    self,
    service: B1,
    f: F
) -> AndThenApply<Self, B, F, Out> where
    B: Service<Error = Self::Error>,
    B1: IntoService<B>,
    F: FnMut(Self::Response, &mut B) -> Out,
    Out: IntoFuture,
    <Out as IntoFuture>::Error: Into<Self::Error>, [src]

Apply function to specified service and use it as a next service in chain. Read more

fn and_then<F, B>(self, service: F) -> AndThen<Self, B> where
    B: Service<Request = Self::Response, Error = Self::Error>,
    F: IntoService<B>, [src]

Call another service after call to this one has resolved successfully. Read more

fn from_err<E>(self) -> FromErr<Self, E> where
    E: From<Self::Error>, [src]

Map this service's error to any error implementing From for this servicesError`. Read more

fn then<B>(self, service: B) -> Then<Self, B> where
    B: Service<Request = Result<Self::Response, Self::Error>, Error = Self::Error>, [src]

Chain on a computation for when a call to the service finished, passing the result of the call to the next service B. Read more

fn map<F, R>(self, f: F) -> Map<Self, F, R> where
    F: FnMut(Self::Response) -> R, [src]

Map this service's output to a different type, returning a new service of the resulting type. Read more

fn map_err<F, E>(self, f: F) -> MapErr<Self, F, E> where
    F: Fn(Self::Error) -> E, [src]

Map this service's error to a different error, returning a new service. Read more