jay-compositor 1.15.0

The Jay compositor
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

use crate::utils::str_table::generated::Length;
use crate::utils::str_table::generated::Offset;
use crate::utils::str_table::generated::STR;
use std::fmt::Debug;
use std::fmt::Display;
use std::fmt::Formatter;
use std::num::NonZero;
use std::ops::Deref;

mod generated {
    include!(concat!(env!("OUT_DIR"), "/str_table.rs"));
}

#[repr(Rust, packed)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct StrAccess {
    off: NonZero<Offset>,
    len: Length,
}

static_assertions::const_assert_eq!(size_of::<StrAccess>(), size_of::<Option<StrAccess>>());

impl StrAccess {
    pub const fn new(off: Offset, len: Length) -> Self {
        assert!(off as usize <= STR.len());
        assert!(len as usize <= STR.len() - off as usize);
        assert!(STR.is_char_boundary(off as usize));
        assert!(STR.is_char_boundary(off as usize + len as usize));
        Self {
            off: NonZero::new(off).unwrap(),
            len,
        }
    }

    pub fn get(self) -> &'static str {
        unsafe {
            str::from_utf8_unchecked(std::slice::from_raw_parts(
                STR.as_ptr().add(self.off.get() as usize),
                self.len as usize,
            ))
        }
    }
}

impl Deref for StrAccess {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        self.get()
    }
}

impl Debug for StrAccess {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        Debug::fmt(self.get(), f)
    }
}

impl Display for StrAccess {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        Display::fmt(self.get(), f)
    }
}

pub trait OptionStrAccessExt {
    fn get(self) -> Option<&'static str>;
}

impl OptionStrAccessExt for Option<StrAccess> {
    fn get(self) -> Option<&'static str> {
        self.map(|v| v.get())
    }
}