http-body-alt 0.1.0

http-body alternative
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use core::{
    pin::Pin,
    task::{Context, Poll, ready},
};

use pin_project_lite::pin_project;

use super::{body::Body, frame::Frame};

pub trait BodyExt: Body {
    fn frame(&mut self) -> FrameFuture<'_, Self>
    where
        Self: Unpin,
    {
        FrameFuture { body: self }
    }

    fn data(&mut self) -> DataFuture<'_, Self>
    where
        Self: Unpin,
    {
        DataFuture { body: self }
    }

    fn chain<B>(self, other: B) -> ChainBody<Self, B>
    where
        B: Body<Data = Self::Data>,
        Self: Sized,
        Self::Error: From<B::Error>,
    {
        ChainBody {
            first: self,
            second: other,
        }
    }
}

pub struct FrameFuture<'a, B: ?Sized> {
    body: &'a mut B,
}

impl<B> Future for FrameFuture<'_, B>
where
    B: Body + Unpin,
{
    type Output = Option<Result<Frame<B::Data>, B::Error>>;

    #[inline]
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        Body::poll_frame(Pin::new(self.get_mut().body), cx)
    }
}

pub struct DataFuture<'a, B: ?Sized> {
    body: &'a mut B,
}

impl<B> Future for DataFuture<'_, B>
where
    B: Body + Unpin,
{
    type Output = Option<Result<B::Data, B::Error>>;

    #[inline]
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let opt = match ready!(Body::poll_frame(Pin::new(self.get_mut().body), cx)) {
            Some(Ok(Frame::Data(data))) => Some(Ok(data)),
            Some(Err(e)) => Some(Err(e)),
            Some(_) | None => None,
        };

        Poll::Ready(opt)
    }
}

pin_project! {
    pub struct ChainBody<A, B> {
        #[pin]
        first: A,
        #[pin]
        second: B
    }
}

impl<A, B> Body for ChainBody<A, B>
where
    A: Body,
    B: Body<Data = A::Data>,
    A::Error: From<B::Error>,
{
    type Data = A::Data;
    type Error = A::Error;

    fn poll_frame(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
        let this = self.project();

        match ready!(this.first.poll_frame(cx)) {
            Some(frame) => Poll::Ready(Some(frame)),
            None => this.second.poll_frame(cx).map_err(Into::into),
        }
    }

    #[inline]
    fn is_end_stream(&self) -> bool {
        self.first.is_end_stream() && self.second.is_end_stream()
    }

    fn size_hint(&self) -> crate::SizeHint {
        self.first.size_hint() + self.second.size_hint()
    }
}

impl<B> BodyExt for B where B: Body {}