sark-http 0.21.0

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

//! Linear response ownership handoff.

use o3::buffer::hold;

use crate::{payload::owned, request::body};

/// One affine choice of how to project a request source.
pub trait Project<'d>: Sized {
    type Proof: stage::Proof;
    type Owner;

    fn contiguous<V, T>(
        self,
        value: V,
        project: impl for<'req> FnOnce(
            V,
            body::View<'req, 'd>,
            Slot<'req, 'd, (), input::Bound<'req, 'd, Self::Proof>>,
        ) -> T,
    ) -> Result<(T, Self::Owner), (Self, V, body::Error)>;

    fn segmented<V, T>(
        self,
        value: V,
        project: impl for<'req> FnOnce(
            V,
            body::Ref<'req, 'd>,
            Slot<'req, 'd, (), input::Bound<'req, 'd, Self::Proof>>,
        ) -> T,
    ) -> (T, Self::Owner);

    fn discarded<V, T>(
        self,
        value: V,
        project: impl for<'req> FnOnce(V, Slot<'req, 'd, (), input::Bound<'req, 'd, Self::Proof>>) -> T,
    ) -> (T, Self::Owner);
}

pub mod copy;
pub mod input;
mod origin;
mod pending;
mod plan;
mod ready;
mod slot;
pub mod stage;

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Error {
    Retain(owned::Error),
    Overflow(hold::Overflow),
}

#[doc(hidden)]
pub enum Head<O> {
    Kept,
    Passed(O),
}

pub(crate) use origin::Origin;
pub use pending::Pending;
pub use plan::Plan;
pub(crate) use plan::State;
pub use ready::Ready;
pub use slot::Slot;

const _: () = assert!(size_of::<Error>() <= 4 * size_of::<usize>());