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

use o3::buffer::resident::bound;

use crate::payload::{
    fixed,
    response::{dispatch, headers, status::Code},
};

/// Static response retaining every generated field in its original type.
#[derive(Copy)]
pub struct Direct<'body, H> {
    status: Code,
    fields: H,
    body: fixed::Body<'body>,
}

impl<H: Copy> Clone for Direct<'_, H> {
    fn clone(&self) -> Self {
        *self
    }
}

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

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

    pub fn body(&self) -> &fixed::Body<'body> {
        &self.body
    }
}

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

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

impl<'body, 'req, 'd, H: headers::Source> dispatch::Complete<'req, 'd> for Direct<'body, H>
where
    'body: 'd,
{
    const BODY: crate::payload::Kind = crate::payload::Kind::Static;

    type Bound = bound::AtMost<0>;

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