sark-core 0.26.0

Fiber-free request, route, dispatch, and lifecycle core 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
93
94
95
96
97
98
99
100
101
102

use core::mem;

use sark_http::field::{
    head,
    metadata::{map::record, section::storage},
};

use crate::{request::field, route::Schema};

#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Tag(u16);

impl Tag {
    pub const fn new(actual: u16) -> Self {
        Self(actual)
    }

    pub const fn actual(self) -> u16 {
        self.0
    }
}

pub trait Slot: Copy {
    fn into_tag(self) -> storage::Slot;

    fn from_tag(tag: storage::Slot) -> Result<Self, Tag>;
}

pub trait Policy<R: Schema>: Copy {
    fn prefix<P>(prefix: P) -> P::Output
    where
        P: field::Prefix<Self>;
}

pub trait Fields<R: Schema>: Slot {
    const ENCODING: bool = false;

    fn slice(name: &[u8]) -> Option<Self>;

    fn span(name: record::Span<'_>) -> Option<Self>;

    fn set<V: field::HeaderValue>(
        headers: &mut R::RawHeaders,
        slot: Self,
        value: &V,
    ) -> Result<(), R::Error>;

    fn set_encoding<V: field::HeaderValue>(
        headers: &mut R::RawHeaders,
        slot: Self,
        value: &V,
        _encoding: head::AcceptEncoding,
    ) -> Result<(), R::Error> {
        Self::set(headers, slot, value)
    }
}

#[derive(Clone, Copy)]
pub enum Discard {}

impl Slot for Discard {
    fn into_tag(self) -> storage::Slot {
        match self {}
    }

    fn from_tag(tag: storage::Slot) -> Result<Self, Tag> {
        Err(Tag::new(tag.get() as u16))
    }
}

impl<R: Schema<Header = Self>> Policy<R> for Discard {
    fn prefix<P>(prefix: P) -> P::Output
    where
        P: field::Prefix<Self>,
    {
        prefix.miss(0)
    }
}

impl<R: Schema<Header = Self>> Fields<R> for Discard {
    fn slice(_: &[u8]) -> Option<Self> {
        None
    }

    fn span(_: record::Span<'_>) -> Option<Self> {
        None
    }

    fn set<V: field::HeaderValue>(
        _: &mut R::RawHeaders,
        slot: Self,
        _: &V,
    ) -> Result<(), R::Error> {
        match slot {}
    }
}

const _: () = {
    assert!(mem::size_of::<Tag>() == mem::size_of::<u16>());
    assert!(mem::size_of::<Discard>() == 0);
};