actix-extras/src/body.rs

use std::marker::PhantomData;
use std::{fmt, mem};

use bytes::{Bytes, BytesMut};
use futures::{Async, Poll, Stream};

use crate::error::{Error, PayloadError};

/// Type represent streaming payload
pub type PayloadStream = Box<dyn Stream<Item = Bytes, Error = PayloadError>>;

#[derive(Debug, PartialEq, Copy, Clone)]
/// Different type of body
pub enum BodyLength {
    None,
    Empty,
    Sized(usize),
    Sized64(u64),
    Chunked,
    Stream,
}

impl BodyLength {
    pub fn is_eof(&self) -> bool {
        match self {
            BodyLength::None
            | BodyLength::Empty
            | BodyLength::Sized(0)
            | BodyLength::Sized64(0) => true,
            _ => false,
        }
    }
}

/// Type that provides this trait can be streamed to a peer.
pub trait MessageBody {
    fn length(&self) -> BodyLength;

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error>;
}

impl MessageBody for () {
    fn length(&self) -> BodyLength {
        BodyLength::Empty
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        Ok(Async::Ready(None))
    }
}

pub enum ResponseBody<B> {
    Body(B),
    Other(Body),
}

impl ResponseBody<Body> {
    pub fn into_body<B>(self) -> ResponseBody<B> {
        match self {
            ResponseBody::Body(b) => ResponseBody::Other(b),
            ResponseBody::Other(b) => ResponseBody::Other(b),
        }
    }
}

impl<B: MessageBody> ResponseBody<B> {
    pub fn as_ref(&self) -> Option<&B> {
        if let ResponseBody::Body(ref b) = self {
            Some(b)
        } else {
            None
        }
    }
}

impl<B: MessageBody> MessageBody for ResponseBody<B> {
    fn length(&self) -> BodyLength {
        match self {
            ResponseBody::Body(ref body) => body.length(),
            ResponseBody::Other(ref body) => body.length(),
        }
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        match self {
            ResponseBody::Body(ref mut body) => body.poll_next(),
            ResponseBody::Other(ref mut body) => body.poll_next(),
        }
    }
}

/// Represents various types of http message body.
pub enum Body {
    /// Empty response. `Content-Length` header is not set.
    None,
    /// Zero sized response body. `Content-Length` header is set to `0`.
    Empty,
    /// Specific response body.
    Bytes(Bytes),
    /// Generic message body.
    Message(Box<dyn MessageBody>),
}

impl Body {
    /// Create body from slice (copy)
    pub fn from_slice(s: &[u8]) -> Body {
        Body::Bytes(Bytes::from(s))
    }

    /// Create body from generic message body.
    pub fn from_message<B: MessageBody + 'static>(body: B) -> Body {
        Body::Message(Box::new(body))
    }
}

impl MessageBody for Body {
    fn length(&self) -> BodyLength {
        match self {
            Body::None => BodyLength::None,
            Body::Empty => BodyLength::Empty,
            Body::Bytes(ref bin) => BodyLength::Sized(bin.len()),
            Body::Message(ref body) => body.length(),
        }
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        match self {
            Body::None => Ok(Async::Ready(None)),
            Body::Empty => Ok(Async::Ready(None)),
            Body::Bytes(ref mut bin) => {
                let len = bin.len();
                if len == 0 {
                    Ok(Async::Ready(None))
                } else {
                    Ok(Async::Ready(Some(bin.split_to(len))))
                }
            }
            Body::Message(ref mut body) => body.poll_next(),
        }
    }
}

impl PartialEq for Body {
    fn eq(&self, other: &Body) -> bool {
        match *self {
            Body::None => match *other {
                Body::None => true,
                _ => false,
            },
            Body::Empty => match *other {
                Body::Empty => true,
                _ => false,
            },
            Body::Bytes(ref b) => match *other {
                Body::Bytes(ref b2) => b == b2,
                _ => false,
            },
            Body::Message(_) => false,
        }
    }
}

impl fmt::Debug for Body {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Body::None => write!(f, "Body::None"),
            Body::Empty => write!(f, "Body::Zero"),
            Body::Bytes(ref b) => write!(f, "Body::Bytes({:?})", b),
            Body::Message(_) => write!(f, "Body::Message(_)"),
        }
    }
}

impl From<&'static str> for Body {
    fn from(s: &'static str) -> Body {
        Body::Bytes(Bytes::from_static(s.as_ref()))
    }
}

impl From<&'static [u8]> for Body {
    fn from(s: &'static [u8]) -> Body {
        Body::Bytes(Bytes::from_static(s))
    }
}

impl From<Vec<u8>> for Body {
    fn from(vec: Vec<u8>) -> Body {
        Body::Bytes(Bytes::from(vec))
    }
}

impl From<String> for Body {
    fn from(s: String) -> Body {
        s.into_bytes().into()
    }
}

impl<'a> From<&'a String> for Body {
    fn from(s: &'a String) -> Body {
        Body::Bytes(Bytes::from(AsRef::<[u8]>::as_ref(&s)))
    }
}

impl From<Bytes> for Body {
    fn from(s: Bytes) -> Body {
        Body::Bytes(s)
    }
}

impl From<BytesMut> for Body {
    fn from(s: BytesMut) -> Body {
        Body::Bytes(s.freeze())
    }
}

impl MessageBody for Bytes {
    fn length(&self) -> BodyLength {
        BodyLength::Sized(self.len())
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
            Ok(Async::Ready(None))
        } else {
            Ok(Async::Ready(Some(mem::replace(self, Bytes::new()))))
        }
    }
}

impl MessageBody for BytesMut {
    fn length(&self) -> BodyLength {
        BodyLength::Sized(self.len())
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
            Ok(Async::Ready(None))
        } else {
            Ok(Async::Ready(Some(
                mem::replace(self, BytesMut::new()).freeze(),
            )))
        }
    }
}

impl MessageBody for &'static str {
    fn length(&self) -> BodyLength {
        BodyLength::Sized(self.len())
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
            Ok(Async::Ready(None))
        } else {
            Ok(Async::Ready(Some(Bytes::from_static(
                mem::replace(self, "").as_ref(),
            ))))
        }
    }
}

impl MessageBody for &'static [u8] {
    fn length(&self) -> BodyLength {
        BodyLength::Sized(self.len())
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
            Ok(Async::Ready(None))
        } else {
            Ok(Async::Ready(Some(Bytes::from_static(mem::replace(
                self, b"",
            )))))
        }
    }
}

impl MessageBody for Vec<u8> {
    fn length(&self) -> BodyLength {
        BodyLength::Sized(self.len())
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
            Ok(Async::Ready(None))
        } else {
            Ok(Async::Ready(Some(Bytes::from(mem::replace(
                self,
                Vec::new(),
            )))))
        }
    }
}

impl MessageBody for String {
    fn length(&self) -> BodyLength {
        BodyLength::Sized(self.len())
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
            Ok(Async::Ready(None))
        } else {
            Ok(Async::Ready(Some(Bytes::from(
                mem::replace(self, String::new()).into_bytes(),
            ))))
        }
    }
}

/// Type represent streaming body.
/// Response does not contain `content-length` header and appropriate transfer encoding is used.
pub struct BodyStream<S, E> {
    stream: S,
    _t: PhantomData<E>,
}

impl<S, E> BodyStream<S, E>
where
    S: Stream<Item = Bytes, Error = E>,
    E: Into<Error>,
{
    pub fn new(stream: S) -> Self {
        BodyStream {
            stream,
            _t: PhantomData,
        }
    }
}

impl<S, E> MessageBody for BodyStream<S, E>
where
    S: Stream<Item = Bytes, Error = E>,
    E: Into<Error>,
{
    fn length(&self) -> BodyLength {
        BodyLength::Chunked
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        self.stream.poll().map_err(|e| e.into())
    }
}

/// Type represent streaming body. This body implementation should be used
/// if total size of stream is known. Data get sent as is without using transfer encoding.
pub struct SizedStream<S> {
    size: usize,
    stream: S,
}

impl<S> SizedStream<S>
where
    S: Stream<Item = Bytes, Error = Error>,
{
    pub fn new(size: usize, stream: S) -> Self {
        SizedStream { size, stream }
    }
}

impl<S> MessageBody for SizedStream<S>
where
    S: Stream<Item = Bytes, Error = Error>,
{
    fn length(&self) -> BodyLength {
        BodyLength::Sized(self.size)
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        self.stream.poll()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    impl Body {
        pub(crate) fn get_ref(&self) -> &[u8] {
            match *self {
                Body::Bytes(ref bin) => &bin,
                _ => panic!(),
            }
        }
    }

    impl ResponseBody<Body> {
        pub(crate) fn get_ref(&self) -> &[u8] {
            match *self {
                ResponseBody::Body(ref b) => b.get_ref(),
                ResponseBody::Other(ref b) => b.get_ref(),
            }
        }
    }

    #[test]
    fn test_static_str() {
        assert_eq!(Body::from("").length(), BodyLength::Sized(0));
        assert_eq!(Body::from("test").length(), BodyLength::Sized(4));
        assert_eq!(Body::from("test").get_ref(), b"test");
    }

    #[test]
    fn test_static_bytes() {
        assert_eq!(Body::from(b"test".as_ref()).length(), BodyLength::Sized(4));
        assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");
        assert_eq!(
            Body::from_slice(b"test".as_ref()).length(),
            BodyLength::Sized(4)
        );
        assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
    }

    #[test]
    fn test_vec() {
        assert_eq!(Body::from(Vec::from("test")).length(), BodyLength::Sized(4));
        assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");
    }

    #[test]
    fn test_bytes() {
        assert_eq!(
            Body::from(Bytes::from("test")).length(),
            BodyLength::Sized(4)
        );
        assert_eq!(Body::from(Bytes::from("test")).get_ref(), b"test");
    }

    #[test]
    fn test_string() {
        let b = "test".to_owned();
        assert_eq!(Body::from(b.clone()).length(), BodyLength::Sized(4));
        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
        assert_eq!(Body::from(&b).length(), BodyLength::Sized(4));
        assert_eq!(Body::from(&b).get_ref(), b"test");
    }

    #[test]
    fn test_bytes_mut() {
        let b = BytesMut::from("test");
        assert_eq!(Body::from(b.clone()).length(), BodyLength::Sized(4));
        assert_eq!(Body::from(b).get_ref(), b"test");
    }
}
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`use std::marker::PhantomData;`
			`use std::{fmt, mem};`
refactory response body 2017-10-24 08:25:32 +02:00
add simple http client 2018-11-14 07:53:30 +01:00			`use bytes::{Bytes, BytesMut};`
			`use futures::{Async, Poll, Stream};`

convert to 2018 edition 2018-12-06 23:32:52 +01:00			`use crate::error::{Error, PayloadError};`
add extractor for Binary type; move all extractors to separate module 2018-04-02 23:55:42 +02:00
refactor client response payload handling 2018-11-14 18:38:16 +01:00			`/// Type represent streaming payload`
			`pub type PayloadStream = Box<dyn Stream<Item = Bytes, Error = PayloadError>>;`
refactory response body 2017-10-24 08:25:32 +02:00
refactor encoder/decoder impl 2018-11-19 02:52:56 +01:00			`#[derive(Debug, PartialEq, Copy, Clone)]`
use BodyLength for request and response body 2018-11-17 06:30:37 +01:00			`/// Different type of body`
			`pub enum BodyLength {`
add simple http client 2018-11-14 07:53:30 +01:00			`None,`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`Empty,`
add simple http client 2018-11-14 07:53:30 +01:00			`Sized(usize),`
use BodyLength for request and response body 2018-11-17 06:30:37 +01:00			`Sized64(u64),`
refactor response body management 2018-11-18 05:21:28 +01:00			`Chunked,`
			`Stream,`
add simple http client 2018-11-14 07:53:30 +01:00			`}`

add h2 server support 2019-02-06 20:44:15 +01:00			`impl BodyLength {`
			`pub fn is_eof(&self) -> bool {`
			`match self {`
			`BodyLength::None`
			`\| BodyLength::Empty`
			`\| BodyLength::Sized(0)`
			`\| BodyLength::Sized64(0) => true,`
			`_ => false,`
			`}`
			`}`
			`}`

add simple http client 2018-11-14 07:53:30 +01:00			`/// Type that provides this trait can be streamed to a peer.`
			`pub trait MessageBody {`
use BodyLength for request and response body 2018-11-17 06:30:37 +01:00			`fn length(&self) -> BodyLength;`
add simple http client 2018-11-14 07:53:30 +01:00
			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error>;`
			`}`

			`impl MessageBody for () {`
use BodyLength for request and response body 2018-11-17 06:30:37 +01:00			`fn length(&self) -> BodyLength {`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`BodyLength::Empty`
add simple http client 2018-11-14 07:53:30 +01:00			`}`

			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
			`Ok(Async::Ready(None))`
			`}`
			`}`

handle response errors 2018-11-21 16:49:24 +01:00			`pub enum ResponseBody<B> {`
			`Body(B),`
			`Other(Body),`
			`}`

add h2 server support 2019-02-06 20:44:15 +01:00			`impl ResponseBody<Body> {`
			`pub fn into_body<B>(self) -> ResponseBody<B> {`
			`match self {`
			`ResponseBody::Body(b) => ResponseBody::Other(b),`
			`ResponseBody::Other(b) => ResponseBody::Other(b),`
			`}`
			`}`
			`}`

handle response errors 2018-11-21 16:49:24 +01:00			`impl<B: MessageBody> ResponseBody<B> {`
			`pub fn as_ref(&self) -> Option<&B> {`
			`if let ResponseBody::Body(ref b) = self {`
			`Some(b)`
			`} else {`
			`None`
			`}`
			`}`
			`}`

			`impl<B: MessageBody> MessageBody for ResponseBody<B> {`
			`fn length(&self) -> BodyLength {`
			`match self {`
			`ResponseBody::Body(ref body) => body.length(),`
			`ResponseBody::Other(ref body) => body.length(),`
			`}`
			`}`

			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
			`match self {`
			`ResponseBody::Body(ref mut body) => body.poll_next(),`
			`ResponseBody::Other(ref mut body) => body.poll_next(),`
			`}`
			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`/// Represents various types of http message body.`
			`pub enum Body {`
			/// Empty response. `Content-Length` header is not set.
			`None,`
			/// Zero sized response body. `Content-Length` header is set to `0`.
			`Empty,`
			`/// Specific response body.`
refactory response body 2017-10-24 08:25:32 +02:00			`Bytes(Bytes),`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`/// Generic message body.`
			`Message(Box<dyn MessageBody>),`
refactory response body 2017-10-24 08:25:32 +02:00			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl Body {`
			`/// Create body from slice (copy)`
			`pub fn from_slice(s: &[u8]) -> Body {`
			`Body::Bytes(Bytes::from(s))`
refactory response body 2017-10-24 08:25:32 +02:00			`}`
use more binary 2018-01-14 23:40:39 +01:00
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`/// Create body from generic message body.`
			`pub fn from_message<B: MessageBody + 'static>(body: B) -> Body {`
			`Body::Message(Box::new(body))`
use more binary 2018-01-14 23:40:39 +01:00			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl MessageBody for Body {`
			`fn length(&self) -> BodyLength {`
			`match self {`
			`Body::None => BodyLength::None,`
			`Body::Empty => BodyLength::Empty,`
			`Body::Bytes(ref bin) => BodyLength::Sized(bin.len()),`
			`Body::Message(ref body) => body.length(),`
use more binary 2018-01-14 23:40:39 +01:00			`}`
			`}`
refactory response body 2017-10-24 08:25:32 +02:00
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
cleanup Binary type; more cors tests 2018-01-11 00:28:33 +01:00			`match self {`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`Body::None => Ok(Async::Ready(None)),`
			`Body::Empty => Ok(Async::Ready(None)),`
			`Body::Bytes(ref mut bin) => {`
refactor encoder/decoder impl 2018-11-19 02:52:56 +01:00			`let len = bin.len();`
			`if len == 0 {`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`Ok(Async::Ready(None))`
			`} else {`
refactor encoder/decoder impl 2018-11-19 02:52:56 +01:00			`Ok(Async::Ready(Some(bin.split_to(len))))`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`}`
			`}`
			`Body::Message(ref mut body) => body.poll_next(),`
cleanup Binary type; more cors tests 2018-01-11 00:28:33 +01:00			`}`
			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl PartialEq for Body {`
			`fn eq(&self, other: &Body) -> bool {`
			`match *self {`
			`Body::None => match *other {`
			`Body::None => true,`
			`_ => false,`
			`},`
			`Body::Empty => match *other {`
			`Body::Empty => true,`
			`_ => false,`
			`},`
			`Body::Bytes(ref b) => match *other {`
			`Body::Bytes(ref b2) => b == b2,`
			`_ => false,`
			`},`
			`Body::Message(_) => false,`
			`}`
refactory response body 2017-10-24 08:25:32 +02:00			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl fmt::Debug for Body {`
			`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
			`match *self {`
			`Body::None => write!(f, "Body::None"),`
			`Body::Empty => write!(f, "Body::Zero"),`
			`Body::Bytes(ref b) => write!(f, "Body::Bytes({:?})", b),`
			`Body::Message(_) => write!(f, "Body::Message(_)"),`
			`}`
convert from ref string into body 2017-10-30 06:50:21 +01:00			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl From<&'static str> for Body {`
			`fn from(s: &'static str) -> Body {`
			`Body::Bytes(Bytes::from_static(s.as_ref()))`
reuse BinaryBody for Frame::Payload 2017-10-24 08:39:01 +02:00			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl From<&'static [u8]> for Body {`
			`fn from(s: &'static [u8]) -> Body {`
cleaup warnings 2019-01-29 19:14:00 +01:00			`Body::Bytes(Bytes::from_static(s))`
reuse BinaryBody for Frame::Payload 2017-10-24 08:39:01 +02:00			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl From<Vec<u8>> for Body {`
			`fn from(vec: Vec<u8>) -> Body {`
			`Body::Bytes(Bytes::from(vec))`
added shared string body 2017-10-24 08:49:27 +02:00			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl From<String> for Body {`
			`fn from(s: String) -> Body {`
			`s.into_bytes().into()`
added shared string body 2017-10-24 08:49:27 +02:00			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl<'a> From<&'a String> for Body {`
			`fn from(s: &'a String) -> Body {`
			`Body::Bytes(Bytes::from(AsRef::<[u8]>::as_ref(&s)))`
Allow to use Arc<Vec<u8>> as response/request body 2018-03-04 19:33:18 +01:00			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl From<Bytes> for Body {`
			`fn from(s: Bytes) -> Body {`
			`Body::Bytes(s)`
Allow to use Arc<Vec<u8>> as response/request body 2018-03-04 19:33:18 +01:00			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl From<BytesMut> for Body {`
			`fn from(s: BytesMut) -> Body {`
			`Body::Bytes(s.freeze())`
refactory response body 2017-10-24 08:25:32 +02:00			`}`
			`}`
body tests 2017-10-24 09:09:52 +02:00
add simple http client 2018-11-14 07:53:30 +01:00			`impl MessageBody for Bytes {`
use BodyLength for request and response body 2018-11-17 06:30:37 +01:00			`fn length(&self) -> BodyLength {`
			`BodyLength::Sized(self.len())`
add simple http client 2018-11-14 07:53:30 +01:00			`}`

			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
			`if self.is_empty() {`
			`Ok(Async::Ready(None))`
			`} else {`
			`Ok(Async::Ready(Some(mem::replace(self, Bytes::new()))))`
			`}`
			`}`
			`}`

refactor response body management 2018-11-18 05:21:28 +01:00			`impl MessageBody for BytesMut {`
			`fn length(&self) -> BodyLength {`
			`BodyLength::Sized(self.len())`
			`}`

			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
			`if self.is_empty() {`
			`Ok(Async::Ready(None))`
			`} else {`
			`Ok(Async::Ready(Some(`
			`mem::replace(self, BytesMut::new()).freeze(),`
			`)))`
			`}`
			`}`
			`}`

add simple http client 2018-11-14 07:53:30 +01:00			`impl MessageBody for &'static str {`
use BodyLength for request and response body 2018-11-17 06:30:37 +01:00			`fn length(&self) -> BodyLength {`
			`BodyLength::Sized(self.len())`
add simple http client 2018-11-14 07:53:30 +01:00			`}`

			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
			`if self.is_empty() {`
			`Ok(Async::Ready(None))`
			`} else {`
			`Ok(Async::Ready(Some(Bytes::from_static(`
			`mem::replace(self, "").as_ref(),`
			`))))`
			`}`
			`}`
			`}`

			`impl MessageBody for &'static [u8] {`
use BodyLength for request and response body 2018-11-17 06:30:37 +01:00			`fn length(&self) -> BodyLength {`
			`BodyLength::Sized(self.len())`
add simple http client 2018-11-14 07:53:30 +01:00			`}`

			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
			`if self.is_empty() {`
			`Ok(Async::Ready(None))`
			`} else {`
			`Ok(Async::Ready(Some(Bytes::from_static(mem::replace(`
			`self, b"",`
			`)))))`
			`}`
			`}`
			`}`

			`impl MessageBody for Vec<u8> {`
use BodyLength for request and response body 2018-11-17 06:30:37 +01:00			`fn length(&self) -> BodyLength {`
			`BodyLength::Sized(self.len())`
add simple http client 2018-11-14 07:53:30 +01:00			`}`

			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
			`if self.is_empty() {`
			`Ok(Async::Ready(None))`
			`} else {`
			`Ok(Async::Ready(Some(Bytes::from(mem::replace(`
			`self,`
			`Vec::new(),`
			`)))))`
			`}`
			`}`
			`}`

			`impl MessageBody for String {`
use BodyLength for request and response body 2018-11-17 06:30:37 +01:00			`fn length(&self) -> BodyLength {`
			`BodyLength::Sized(self.len())`
add simple http client 2018-11-14 07:53:30 +01:00			`}`

			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
			`if self.is_empty() {`
			`Ok(Async::Ready(None))`
			`} else {`
			`Ok(Async::Ready(Some(Bytes::from(`
			`mem::replace(self, String::new()).into_bytes(),`
			`))))`
			`}`
			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`/// Type represent streaming body.`
			/// Response does not contain `content-length` header and appropriate transfer encoding is used.
			`pub struct BodyStream<S, E> {`
add simple http client 2018-11-14 07:53:30 +01:00			`stream: S,`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`_t: PhantomData<E>,`
add simple http client 2018-11-14 07:53:30 +01:00			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl<S, E> BodyStream<S, E>`
add simple http client 2018-11-14 07:53:30 +01:00			`where`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`S: Stream<Item = Bytes, Error = E>,`
			`E: Into<Error>,`
add simple http client 2018-11-14 07:53:30 +01:00			`{`
			`pub fn new(stream: S) -> Self {`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`BodyStream {`
			`stream,`
			`_t: PhantomData,`
			`}`
add simple http client 2018-11-14 07:53:30 +01:00			`}`
			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl<S, E> MessageBody for BodyStream<S, E>`
add simple http client 2018-11-14 07:53:30 +01:00			`where`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`S: Stream<Item = Bytes, Error = E>,`
			`E: Into<Error>,`
add simple http client 2018-11-14 07:53:30 +01:00			`{`
use BodyLength for request and response body 2018-11-17 06:30:37 +01:00			`fn length(&self) -> BodyLength {`
refactor response body management 2018-11-18 05:21:28 +01:00			`BodyLength::Chunked`
add simple http client 2018-11-14 07:53:30 +01:00			`}`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
			`self.stream.poll().map_err(\|e\| e.into())`
			`}`
			`}`

			`/// Type represent streaming body. This body implementation should be used`
			`/// if total size of stream is known. Data get sent as is without using transfer encoding.`
			`pub struct SizedStream<S> {`
			`size: usize,`
			`stream: S,`
			`}`

			`impl<S> SizedStream<S>`
			`where`
			`S: Stream<Item = Bytes, Error = Error>,`
			`{`
			`pub fn new(size: usize, stream: S) -> Self {`
			`SizedStream { size, stream }`
			`}`
			`}`

			`impl<S> MessageBody for SizedStream<S>`
			`where`
			`S: Stream<Item = Bytes, Error = Error>,`
			`{`
			`fn length(&self) -> BodyLength {`
			`BodyLength::Sized(self.size)`
			`}`

add simple http client 2018-11-14 07:53:30 +01:00			`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {`
			`self.stream.poll()`
			`}`
			`}`

body tests 2017-10-24 09:09:52 +02:00			`#[cfg(test)]`
			`mod tests {`
			`use super::*;`

re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`impl Body {`
			`pub(crate) fn get_ref(&self) -> &[u8] {`
			`match *self {`
			`Body::Bytes(ref bin) => &bin,`
			`_ => panic!(),`
			`}`
			`}`
more Body tests 2017-11-20 05:32:37 +01:00			`}`

handle response errors 2018-11-21 16:49:24 +01:00			`impl ResponseBody<Body> {`
			`pub(crate) fn get_ref(&self) -> &[u8] {`
			`match *self {`
			`ResponseBody::Body(ref b) => b.get_ref(),`
			`ResponseBody::Other(ref b) => b.get_ref(),`
			`}`
			`}`
			`}`

body tests 2017-10-24 09:09:52 +02:00			`#[test]`
			`fn test_static_str() {`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`assert_eq!(Body::from("").length(), BodyLength::Sized(0));`
			`assert_eq!(Body::from("test").length(), BodyLength::Sized(4));`
			`assert_eq!(Body::from("test").get_ref(), b"test");`
body tests 2017-10-24 09:09:52 +02:00			`}`

			`#[test]`
			`fn test_static_bytes() {`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`assert_eq!(Body::from(b"test".as_ref()).length(), BodyLength::Sized(4));`
			`assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");`
			`assert_eq!(`
			`Body::from_slice(b"test".as_ref()).length(),`
			`BodyLength::Sized(4)`
			`);`
			`assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");`
body tests 2017-10-24 09:09:52 +02:00			`}`

			`#[test]`
			`fn test_vec() {`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`assert_eq!(Body::from(Vec::from("test")).length(), BodyLength::Sized(4));`
			`assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");`
body tests 2017-10-24 09:09:52 +02:00			`}`

			`#[test]`
			`fn test_bytes() {`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`assert_eq!(`
			`Body::from(Bytes::from("test")).length(),`
			`BodyLength::Sized(4)`
			`);`
			`assert_eq!(Body::from(Bytes::from("test")).get_ref(), b"test");`
body tests 2017-10-24 09:09:52 +02:00			`}`
more Body tests 2017-11-20 05:32:37 +01:00
			`#[test]`
			`fn test_string() {`
			`let b = "test".to_owned();`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`assert_eq!(Body::from(b.clone()).length(), BodyLength::Sized(4));`
			`assert_eq!(Body::from(b.clone()).get_ref(), b"test");`
			`assert_eq!(Body::from(&b).length(), BodyLength::Sized(4));`
			`assert_eq!(Body::from(&b).get_ref(), b"test");`
Allow to use Arc<Vec<u8>> as response/request body 2018-03-04 19:33:18 +01:00			`}`

more Body tests 2017-11-20 05:32:37 +01:00			`#[test]`
			`fn test_bytes_mut() {`
add rustfmt config 2018-04-14 01:02:01 +02:00			`let b = BytesMut::from("test");`
re-introduce Body type, use Body as default body type for Response 2018-11-18 22:48:42 +01:00			`assert_eq!(Body::from(b.clone()).length(), BodyLength::Sized(4));`
			`assert_eq!(Body::from(b).get_ref(), b"test");`
cleanup Binary type; more cors tests 2018-01-11 00:28:33 +01:00			`}`
body tests 2017-10-24 09:09:52 +02:00			`}`