Enum actix_web::Either

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

Combines two different responder types into a single type

use actix_web::{Either, Error, HttpResponse};

type RegisterResult = Either<HttpResponse, Result<HttpResponse, Error>>;

fn index() -> RegisterResult {
    if is_a_variant() {
        // <- choose left variant
        Either::A(HttpResponse::BadRequest().body("Bad data"))
    } else {
        Either::B(
            // <- Right variant
            Ok(HttpResponse::Ok()
                .content_type("text/html")
                .body("Hello!"))
        )
    }
}

Variants

A(A)

First branch of the type

B(B)

Second branch of the type

Trait Implementations

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

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

Formats the value using the given formatter.

impl<A, B> FromRequest for Either<A, B> where
    A: FromRequest + 'static,
    B: FromRequest + 'static, 

Provides a mechanism for trying two extractors, a primary and a fallback. Useful for "polymorphic payloads" where, for example, a form might be JSON or URL encoded.

It is important to note that this extractor, by necessity, buffers the entire request payload as part of its implementation. Though, it does respect a PayloadConfig's maximum size limit.

type Error = EitherExtractError<A::Error, B::Error>

The associated error which can be returned.

type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>

Future that resolves to a Self

type Config = ()

Configuration for this extractor

pub fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future

Convert request to a Self

pub fn extract(req: &HttpRequest) -> Self::Future

Convert request to a Self

pub fn configure<F>(f: F) -> Self::Config where
    F: FnOnce(Self::Config) -> Self::Config, 

Create and configure config instance.

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

pub fn eq(&self, other: &Either<A, B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Either<A, B>) -> bool

This method tests for !=.

impl<A, B> Responder for Either<A, B> where
    A: Responder,
    B: Responder, 

type Error = Error

The associated error which can be returned.

type Future = EitherResponder<A, B>

The future response value.

pub fn respond_to(self, req: &HttpRequest) -> Self::Future

Convert itself to AsyncResult or Error.

pub fn with_status(self, status: StatusCode) -> CustomResponder<Self> where
    Self: Sized, 

Override a status code for a Responder.

pub fn with_header<K, V>(self, key: K, value: V) -> CustomResponder<Self> where
    Self: Sized,
    HeaderName: TryFrom<K>,
    <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
    V: IntoHeaderValue, 

Add header to the Responder's response.

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