sark-h2 0.26.3

Fiber-free HTTP/2 protocol primitives and manifold server 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
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

use o3::buffer::{resident, segments};
use sark_core::{body::admit, decode::state};

use crate::server::{payload::Buffer, state::exchange::Pending};

pub(crate) trait Input<'d>: state::Set {
    fn sync(body: Self::SyncOpen) -> Buffer<'d>;

    fn sync_done(body: Self::SyncFinished) -> Buffer<'d>;

    fn task(body: Self::TaskOpen) -> Buffer<'d>;

    fn task_done(body: Self::TaskFinished) -> Buffer<'d>;

    fn duplex(body: Self::DuplexOpen) -> Option<segments::Chain<resident::Shared<'d>>>;

    fn duplex_done(body: Self::DuplexFinished) -> Option<segments::Chain<resident::Shared<'d>>>;

    /// Releases a duplex body on a close path that never delivers it.
    ///
    /// The hooks return the chain a delivering path would consume, so the
    /// release lives once per hook instead of at every close arm.
    fn close_duplex(body: Self::DuplexOpen) {
        Self::duplex(body);
    }

    /// Releases a finished duplex body on a close path that never delivers it.
    fn end_duplex(body: Self::DuplexFinished) {
        Self::duplex_done(body);
    }

    fn other(body: Self::UnsupportedOpen) -> Buffer<'d>;

    fn other_done(body: Self::UnsupportedFinished) -> Buffer<'d>;
}

impl<'d> Input<'d> for state::Routed {
    fn sync(body: admit::Track<admit::Open>) -> Buffer<'d> {
        Buffer::start(admit::Start::Open(body))
    }

    fn sync_done(body: admit::Track<admit::Finished>) -> Buffer<'d> {
        Buffer::start(admit::Start::Finished(body))
    }

    fn task(body: admit::Track<admit::Open>) -> Buffer<'d> {
        Buffer::start(admit::Start::Open(body))
    }

    fn task_done(body: admit::Track<admit::Finished>) -> Buffer<'d> {
        Buffer::start(admit::Start::Finished(body))
    }

    fn duplex((): ()) -> Option<segments::Chain<resident::Shared<'d>>> {
        None
    }

    fn duplex_done((): ()) -> Option<segments::Chain<resident::Shared<'d>>> {
        None
    }

    fn other(body: admit::Track<admit::Open>) -> Buffer<'d> {
        Buffer::start(admit::Start::Open(body))
    }

    fn other_done(body: admit::Track<admit::Finished>) -> Buffer<'d> {
        Buffer::start(admit::Start::Finished(body))
    }
}

impl<'d> Input<'d> for Pending<'d> {
    fn sync(body: Buffer<'d>) -> Buffer<'d> {
        body
    }

    fn sync_done(body: Buffer<'d>) -> Buffer<'d> {
        body
    }

    fn task(body: Buffer<'d>) -> Buffer<'d> {
        body
    }

    fn task_done(body: Buffer<'d>) -> Buffer<'d> {
        body
    }

    fn duplex(
        body: Option<segments::Chain<resident::Shared<'d>>>,
    ) -> Option<segments::Chain<resident::Shared<'d>>> {
        body
    }

    fn duplex_done(
        body: Option<segments::Chain<resident::Shared<'d>>>,
    ) -> Option<segments::Chain<resident::Shared<'d>>> {
        body
    }

    fn other(body: Buffer<'d>) -> Buffer<'d> {
        body
    }

    fn other_done(body: Buffer<'d>) -> Buffer<'d> {
        body
    }
}