sark-http 0.29.2

HTTP wire types, semantics, codecs, and ownership invariants for Sark
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

use crate::payload::response::status::Code;
mod overflow;
mod plan;

use o3::buffer::resident::bound;
pub use overflow::Overflow;
pub use plan::Plan;

use crate::payload::response::{Encode, dispatch, headers};

pub trait Body: Encode {
    fn encoded_len(&self) -> usize;
}

/// An encoder whose size must be admitted before transport output is prepared.
pub trait TryBody: Encode {
    fn try_len(&self) -> Result<usize, Overflow>;
}

impl<B: Body> TryBody for B {
    fn try_len(&self) -> Result<usize, Overflow> {
        Ok(self.encoded_len())
    }
}

/// Exact response retaining every generated field in its original type.
pub struct Direct<H, B> {
    status: Code,
    fields: H,
    body: B,
}

impl<H, B> Direct<H, B> {
    pub fn new(status: Code, fields: H, body: B) -> Self {
        Self {
            status,
            fields,
            body,
        }
    }

    pub fn status(&self) -> Code {
        self.status
    }
}

impl<'req, 'd, H, B> dispatch::IntoOutput<'req, 'd> for Direct<H, B>
where
    H: headers::Source,
    B: TryBody,
{
    type Output = Self;

    fn into_output(self) -> Self::Output {
        self
    }
}

impl<'req, 'd, H, B> dispatch::Complete<'req, 'd> for Direct<H, B>
where
    H: headers::Source,
    B: TryBody,
{
    const BODY: crate::payload::Kind = crate::payload::Kind::Inline;
    type Bound = bound::Unbounded;

    fn complete<S>(self, sink: S) -> Result<S::Output, S::Error>
    where
        S: dispatch::Accept<'d>,
    {
        let Self {
            status,
            fields,
            body,
        } = self;
        dispatch::Accept::exact(sink, status, fields, body)
    }
}