introduce either body

actix-http/CHANGES.md

@@ -5,10 +5,18 @@
 * Add timeout for canceling HTTP/2 server side connection handshake. Default to 5 seconds. [#2483]
 * HTTP/2 handshake timeout can be configured with `ServiceConfig::client_timeout`. [#2483]
 * Rename `body::BoxBody::{from_body => new}`. [#????]
+* `body::EitherBody` enum. [#????]
+
+### Changed
+* Rename `body::BoxBody::{from_body => new}`. [#????]
+
+### Removed
+* Remove unnecessary `MessageBody` bound on types passed to `body::AnyBody::new`. [#????]
 
 [#2483]: https://github.com/actix/actix-web/pull/2483
 [#????]: https://github.com/actix/actix-web/pull/????
 
+
 ## 3.0.0-beta.14 - 2021-11-30
 ### Changed
 * Guarantee ordering of `header::GetAll` iterator to be same as insertion order. [#2467]

actix-http/src/body/either.rs

@@ -0,0 +1,83 @@
+use std::{
+    error::Error as StdError,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use pin_project_lite::pin_project;
+
+use super::{BodySize, BoxBody, MessageBody};
+use crate::Error;
+
+pin_project! {
+    #[project = EitherBodyProj]
+    #[derive(Debug, Clone)]
+    pub enum EitherBody<L, R = BoxBody> {
+        /// A body of type `L`.
+        Left { #[pin] body: L },
+
+        /// A body of type `R`.
+        Right { #[pin] body: R },
+    }
+}
+
+impl<L> EitherBody<L, BoxBody> {
+    /// Creates new `EitherBody` using left variant and boxed right variant.
+    pub fn new(body: L) -> Self {
+        Self::Left { body }
+    }
+}
+
+impl<L, R> EitherBody<L, R> {
+    /// Creates new `EitherBody` using left variant.
+    pub fn left(body: L) -> Self {
+        Self::Left { body }
+    }
+
+    /// Creates new `EitherBody` using right variant.
+    pub fn right(body: R) -> Self {
+        Self::Right { body }
+    }
+}
+
+impl<L, R> MessageBody for EitherBody<L, R>
+where
+    L: MessageBody + 'static,
+    L::Error: Into<Box<dyn StdError + 'static>>,
+    R: MessageBody + 'static,
+    R::Error: Into<Box<dyn StdError + 'static>>,
+{
+    type Error = Error;
+
+    fn size(&self) -> BodySize {
+        match self {
+            EitherBody::Left { body } => body.size(),
+            EitherBody::Right { body } => body.size(),
+        }
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        match self.project() {
+            EitherBodyProj::Left { body } => body
+                .poll_next(cx)
+                .map_err(|err| Error::new_body().with_cause(err)),
+            EitherBodyProj::Right { body } => body
+                .poll_next(cx)
+                .map_err(|err| Error::new_body().with_cause(err)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn either_body_works() {
+        EitherBody::left(());
+    }
+}

actix-http/src/body/message_body.rs

@@ -27,6 +27,21 @@ pub trait MessageBody {
     ) -> Poll<Option<Result<Bytes, Self::Error>>>;
 }
 
+impl MessageBody for Infallible {
+    type Error = Infallible;
+
+    fn size(&self) -> BodySize {
+        match *self {}
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        match *self {}
+    }
+}
+
 impl MessageBody for () {
     type Error = Infallible;
 

actix-http/src/body/mod.rs

@@ -11,14 +11,17 @@ use futures_core::ready;
 mod body;
 mod body_stream;
 mod boxed;
+mod either;
 mod message_body;
 mod size;
 mod sized_stream;
 
+pub use self::body::AnyBody;
 #[allow(deprecated)]
-pub use self::body::{AnyBody, Body, BoxBody};
+pub use self::body::Body;
 pub use self::body_stream::BodyStream;
 pub use self::boxed::BoxBody;
+pub use self::either::EitherBody;
 pub use self::message_body::MessageBody;
 pub(crate) use self::message_body::MessageBodyMapErr;
 pub use self::size::BodySize;