Enum actix_http::body::EitherBody

pub enum EitherBody<L, R = BoxBody> {
    Left {
        body: L,
    },
    Right {
        body: R,
    },
}

An “either” type specialized for body types.

It is common, in middleware especially, to conditionally return an inner service’s unknown/ generic body B type or return early with a new response. This type’s “right” variant defaults to BoxBody since error responses are the common case.

For example, middleware will often have type Response = ServiceResponse<EitherBody<B>>. This means that the inner service’s response body type maps to the Left variant and the middleware’s own error responses use the default Right variant of BoxBody. Of course, there’s no reason it couldn’t use EitherBody<B, String> instead if its alternative responses have a known type.

Variants

Left

Fields

body: L

A body of type L.

Right

Fields

body: R

A body of type R.

Implementations

impl<L> EitherBody<L, BoxBody>

pub fn new(body: L) -> Self

Creates new EitherBody left variant with a boxed right variant.

If the expected R type will be inferred and is not BoxBody then use the left constructor instead.

impl<L, R> EitherBody<L, R>

pub fn left(body: L) -> Self

Creates new EitherBody using left variant.

pub fn right(body: R) -> Self

Creates new EitherBody using right variant.

Trait Implementations

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

fn clone(&self) -> EitherBody<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 EitherBody<L, R>

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

Formats the value using the given formatter.

impl<L, R> MessageBody for EitherBody<L, R> where
    L: MessageBody + 'static,
    R: MessageBody + 'static, 

type Error = Error

The type of error that will be returned if streaming body fails.

fn size(&self) -> BodySize

Body size hint.

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<Result<Bytes, Self::Error>>>

Attempt to pull out the next chunk of body bytes.

fn try_into_bytes(self) -> Result<Bytes, Self>

Try to convert into the complete chunk of body bytes.

fn boxed(self) -> BoxBody

Wraps this body into a BoxBody.

impl<'__pin, L, R> Unpin for EitherBody<L, R> where
    __Origin<'__pin, L, R>: Unpin,