sark-http 0.28.7

HTTP wire types, semantics, codecs, and ownership invariants 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

use crate::{
    field::metadata::map::record,
    payload::compress::dynamic::{hash, index, mode, table::View},
};

#[derive(Clone, Copy)]
pub struct Search<'a> {
    view: View<'a, mode::Direct>,
}

impl<'a> Search<'a> {
    pub(super) const fn new(view: View<'a, mode::Direct>) -> Self {
        Self { view }
    }

    pub fn get(self, name: &[u8], value: &[u8]) -> record::Match<usize> {
        let state = self.view.state();
        self.both(
            state.hash.probe(record::Entry::new(name, value)),
            state.entries.len(),
            Some,
        )
    }

    pub(super) fn both<I: Copy>(
        self,
        probe: hash::Probe<'_>,
        retained: usize,
        mut map: impl FnMut(usize) -> Option<I>,
    ) -> record::Match<I> {
        if let Some(exact) = self.find_exact(probe, retained, &mut map) {
            return record::Match {
                exact: Some(exact),
                name: Some(exact),
            };
        }
        let name = self.find_needle(probe.needle(), retained, &mut map);
        record::Match { exact: None, name }
    }

    pub(super) fn exact<I: Copy>(
        self,
        probe: hash::Probe<'_>,
        retained: usize,
        mut map: impl FnMut(usize) -> Option<I>,
    ) -> Option<I> {
        self.find_exact(probe, retained, &mut map)
    }

    pub(super) fn needle<I: Copy>(
        self,
        needle: hash::Needle<'_>,
        retained: usize,
        mut map: impl FnMut(usize) -> Option<I>,
    ) -> Option<I> {
        self.find_needle(needle, retained, &mut map)
    }

    fn find_exact<I: Copy>(
        self,
        probe: hash::Probe<'_>,
        retained: usize,
        map: &mut impl FnMut(usize) -> Option<I>,
    ) -> Option<I> {
        let field = probe.field();
        let digest = probe.digest();
        index::Search::new(self.view.lookup(index::Key::Exact)).find(
            digest.exact(),
            |(relative, entry)| {
                if relative < retained
                    && entry.name.is_equal(field.name)
                    && entry.value.is_equal(field.value)
                {
                    map(relative).map(|mapped| (relative, mapped))
                } else {
                    None
                }
            },
        )
    }

    fn find_needle<I: Copy>(
        self,
        needle: hash::Needle<'_>,
        retained: usize,
        map: &mut impl FnMut(usize) -> Option<I>,
    ) -> Option<I> {
        index::Search::new(self.view.lookup(index::Key::Name)).find(
            needle.hash(),
            |(relative, entry)| {
                if relative < retained && entry.name.is_equal(needle.name()) {
                    map(relative).map(|mapped| (relative, mapped))
                } else {
                    None
                }
            },
        )
    }
}