sark-http 0.29.1

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

use std::convert::Infallible;

use o3::buffer::hold::{self, evidence};

use crate::owner::handoff::{Ready, stage};

enum Wait<'d, D> {
    Ready(Ready<'d>),
    Body(D),
}

/// Borrow-free response state waiting for an original request owner.
#[must_use = "finish the response owner handoff"]
#[doc(hidden)]
pub struct Pending<'d, M: evidence::Mode = evidence::Off, D = Infallible> {
    wait: Wait<'d, D>,
    proof: M::Projection,
}

impl<'d, M: evidence::Mode, D> Pending<'d, M, D> {
    pub(super) const fn ready(body: Ready<'d>, proof: M::Projection) -> Self {
        Self {
            wait: Wait::Ready(body),
            proof,
        }
    }

    pub(super) const fn body(body: D, proof: M::Projection) -> Self {
        Self {
            wait: Wait::Body(body),
            proof,
        }
    }
}

impl<'d, D: stage::Deferred<'d>> Pending<'d, evidence::Off, D> {
    pub fn finish(self, body: D::Owner) -> Ready<'d> {
        resolve(self.wait, body)
    }
}

impl<'d, D: stage::Deferred<'d>> Pending<'d, evidence::On, D> {
    pub fn finish(self, body: D::Owner) -> (Ready<'d>, hold::Charge) {
        let Self { wait, proof } = self;
        let ready = resolve(wait, body);
        (ready, proof)
    }
}

fn resolve<'d, D: stage::Deferred<'d>>(wait: Wait<'d, D>, body: D::Owner) -> Ready<'d> {
    match wait {
        Wait::Ready(body) => body,
        Wait::Body(selected) => Ready::Linked(selected.resolve(body)),
    }
}

const _: () = {
    assert!(std::mem::size_of::<Pending<'static>>() <= 7 * std::mem::size_of::<usize>());
};