sark 0.8.7

Simple Asynchronous Rust webKit - Server
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

use std::cell::OnceCell;

use sark_core::http::FixedResponseInner;

pub enum Content {
    Fixed {
        template: Vec<u8>,
        date_offset: Option<usize>,
    },
    Static {
        head_template: Vec<u8>,
        date_offset: Option<usize>,
        body: &'static [u8],
    },
}

pub struct Slot<'a> {
    slot: &'a OnceCell<Content>,
}

pub enum Hit {
    Fixed {
        written: usize,
    },
    Static {
        hdr_written: usize,
        body: &'static [u8],
    },
}

impl<'a> Slot<'a> {
    pub const fn new(slot: &'a OnceCell<Content>) -> Self {
        Self { slot }
    }

    pub fn try_hit(&self, write: &mut [u8], date: &[u8; 29]) -> Option<Hit> {
        match self.slot.get() {
            Some(Content::Fixed {
                template,
                date_offset,
            }) => FixedResponseInner::write_preserialized(write, template, *date_offset, date)
                .map(|written| Hit::Fixed { written }),
            Some(Content::Static {
                head_template,
                date_offset,
                body,
            }) => FixedResponseInner::write_preserialized(write, head_template, *date_offset, date)
                .map(|hdr_written| Hit::Static { hdr_written, body }),
            None => None,
        }
    }

    pub fn store_fixed(&self, template: Vec<u8>, date_offset: Option<usize>) {
        let _ = self.slot.set(Content::Fixed {
            template,
            date_offset,
        });
    }

    pub fn store_static(
        &self,
        head_template: Vec<u8>,
        date_offset: Option<usize>,
        body: &'static [u8],
    ) {
        let _ = self.slot.set(Content::Static {
            head_template,
            date_offset,
            body,
        });
    }
}