kbvm 0.1.5

An implementation of the XKB specification
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

#[rustfmt::skip]
#[allow(clippy::upper_case_acronyms)]
mod generated;

pub(crate) use generated::Meaning;
use {
    crate::{
        phf_map::PhfMap,
        xkb::{
            interner::{Interned, Interner},
            meaning::generated::LONGEST,
        },
    },
    arrayvec::ArrayVec,
    bstr::ByteSlice,
    hashbrown::{HashMap, hash_map::Entry},
};

#[derive(Default)]
pub(crate) struct MeaningCache {
    sensitive: HashMap<Interned, Meaning>,
    insensitive: HashMap<Interned, Meaning>,
}

impl MeaningCache {
    pub(crate) fn get_case_sensitive(&mut self, interner: &Interner, name: Interned) -> Meaning {
        match self.sensitive.entry(name) {
            Entry::Occupied(e) => *e.get(),
            Entry::Vacant(e) => {
                let val = interner.get(name);
                let meaning = generated::STRING_TO_MEANING[val.as_bytes()];
                let res = match meaning.name().as_bytes() == val.as_bytes() {
                    true => meaning,
                    _ => Meaning::__Unknown,
                };
                e.insert(res);
                res
            }
        }
    }

    pub(crate) fn get_case_insensitive(&mut self, interner: &Interner, name: Interned) -> Meaning {
        match self.insensitive.entry(name) {
            Entry::Occupied(e) => *e.get(),
            Entry::Vacant(e) => {
                let val = interner.get(name);
                let res = if val.len() > LONGEST {
                    Meaning::__Unknown
                } else {
                    let mut buffer = ArrayVec::<u8, LONGEST>::new();
                    for &c in val.as_bytes() {
                        buffer.push(c.to_ascii_lowercase());
                    }
                    let meaning = generated::LOWERCASE_TO_MEANING[buffer.as_bytes()];
                    match meaning.lowercase().as_bytes() == buffer.as_bytes() {
                        true => meaning,
                        _ => Meaning::__Unknown,
                    }
                };
                e.insert(res);
                res
            }
        }
    }
}