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
85
86
87
88
89
90
91
92

use core::num::NonZero;

use o3::{base::num::bounded, depot, depot::index::Stored};
use sark_core::{manifold, manifold::stream::Boundary};

use crate::stream::{Id, Key, Nonzero};

/// `raw` must retain a previously emitted stream Key identity.
const unsafe fn restore(raw: u64) -> Key {
    Key {
        id: Nonzero(Id::from_wire((raw >> 32) as u32)),
        // SAFETY: The retained Key's physical slot excludes the sentinel.
        slot: unsafe { bounded::raw::Proof::assume(raw as u32) }.retain(),
    }
}

#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub(crate) struct Marked(NonZero<u64>);

impl Marked {
    const END: u64 = 1 << 63;

    pub(crate) fn new(key: Key, boundary: Boundary) -> Self {
        let marker = match boundary {
            Boundary::More => 0,
            Boundary::End => Self::END,
        };
        Self(manifold::raw::Key::identity(key) | marker)
    }

    pub(crate) const fn key(self) -> Key {
        // SAFETY: Marked retains the original Key below its separate boundary bit.
        unsafe { restore(self.0.get() & !Self::END) }
    }

    pub(crate) const fn boundary(self) -> Boundary {
        match self.0.get() & Self::END {
            0 => Boundary::More,
            _ => Boundary::End,
        }
    }
}

const _: () = assert!(core::mem::size_of::<Marked>() == core::mem::size_of::<Key>());
const _: () = assert!(core::mem::size_of::<Option<Marked>>() == core::mem::size_of::<Marked>());

unsafe impl depot::raw::Key for Key {
    type Raw = u64;
    type Live = Self;

    const VACANT: Self::Raw = 0;

    fn index(self) -> usize {
        self.slot.into_usize()
    }

    fn into_raw(self) -> Self::Raw {
        manifold::raw::Key::identity(self).get()
    }

    fn from_raw(raw: Stored<Self>) -> Self {
        // SAFETY: Stored<Self> retains this exact stream domain and logical identity.
        unsafe { <Self as depot::raw::Key>::rebuild(raw) }
    }

    unsafe fn rebuild<K: depot::raw::Key<Raw = u64>>(raw: Stored<K>) -> Self {
        // SAFETY: Stored and rebuild's caller preserve the emitted stream Key domain.
        unsafe { restore(raw.into_raw()) }
    }

    fn decode(raw: Self::Raw) -> Option<Self> {
        let id = Id::new((raw >> 32) as u32)?.nonzero()?;
        let slot = bounded::U32::new(raw as u32)?;
        Some(Self { id, slot })
    }

    fn into_live(self) -> Self::Live {
        self
    }

    fn from_live(live: Self::Live) -> Self {
        live
    }
}

// SAFETY: Key retains its nonzero wire stream id and bounded physical slot.
unsafe impl manifold::raw::Key for Key {
    fn identity(self) -> NonZero<u64> {
        unsafe { NonZero::<u64>::new_unchecked(self.identity()) }
    }
}