sark 0.11.0

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
73
74
75
76
77
78
79
80

use std::cell::OnceCell;

use sark_core::http::FixedResponse;

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

pub struct Cache<'a> {
    entry: Option<&'a OnceCell<Entry>>,
}

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

impl<'a> Cache<'a> {
    pub const fn new(entry: &'a OnceCell<Entry>) -> Self {
        Self { entry: Some(entry) }
    }

    pub const fn empty() -> Self {
        Self { entry: None }
    }

    pub fn write(&self, write: &mut [u8], date: &[u8; 29]) -> Option<Cached> {
        match self.entry.and_then(OnceCell::get) {
            Some(Entry::Fixed {
                template,
                date_offset,
            }) => FixedResponse::write_preserialized(write, template, *date_offset, date)
                .map(|written| Cached::Fixed { written }),
            Some(Entry::Static {
                head_template,
                date_offset,
                body,
            }) => FixedResponse::write_preserialized(write, head_template, *date_offset, date)
                .map(|hdr_written| Cached::Static { hdr_written, body }),
            None => None,
        }
    }

    pub fn insert_fixed(&self, template: Vec<u8>, date_offset: Option<usize>) {
        if let Some(entry) = self.entry {
            let _ = entry.set(Entry::Fixed {
                template,
                date_offset,
            });
        }
    }

    pub fn insert_static(
        &self,
        head_template: Vec<u8>,
        date_offset: Option<usize>,
        body: &'static [u8],
    ) {
        if let Some(entry) = self.entry {
            let _ = entry.set(Entry::Static {
                head_template,
                date_offset,
                body,
            });
        }
    }
}