sark-h2 0.23.0

Fiber-free HTTP/2 protocol primitives and manifold server 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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use o3::buffer::hold;
use sark_core::life::{self, exchange, owners};
use sark_http::owner::{self, cause};

use crate::stream;

pub(in crate::server) struct Proof {
    pub(super) stream: stream::Key,
    pub(super) charge: hold::Charge,
}

#[derive(Clone, Copy)]
pub(in crate::server) enum Progress {
    Blocked,
    Committed,
}

pub(in crate::server) trait Sink<R> {
    fn progress(&self) -> Progress;

    fn accept(&mut self, receipt: R);

    fn reject(&mut self, receipt: R);
}

pub(in crate::server) struct Track<F> {
    progress: Progress,
    accepted: F,
}

impl<F> Track<F> {
    pub(super) const fn new(accepted: F) -> Self {
        Self {
            progress: Progress::Blocked,
            accepted,
        }
    }
}

impl Sink<()> for Track<()> {
    fn progress(&self) -> Progress {
        self.progress
    }

    fn accept(&mut self, (): ()) {
        self.progress = Progress::Committed;
    }

    fn reject(&mut self, (): ()) {
        self.progress = Progress::Committed;
    }
}

impl<C: Copy, M: life::Mode<C, stream::Key>> Sink<Option<Proof>> for Track<(C, &mut M)> {
    fn progress(&self) -> Progress {
        self.progress
    }

    fn accept(&mut self, receipt: Option<Proof>) {
        self.progress = Progress::Committed;
        if let Some(receipt) = receipt {
            owners::Projection::new(&mut *self.accepted.1).apply(owner::Effect::new(
                exchange::Id::new(self.accepted.0, receipt.stream),
                receipt.charge,
                owner::Change::Handoff,
            ));
        }
    }

    fn reject(&mut self, receipt: Option<Proof>) {
        use cause::Staging;

        self.progress = Progress::Committed;
        if let Some(receipt) = receipt {
            owners::Projection::new(&mut *self.accepted.1).apply(owner::Effect::new(
                exchange::Id::new(self.accepted.0, receipt.stream),
                receipt.charge,
                owner::Change::StagingReleased(Staging::Closed),
            ));
        }
    }
}

const _: () = assert!(std::mem::size_of::<Track<()>>() == 1);