read_fonts/generated/
generated_cff.rs

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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
// THIS FILE IS AUTOGENERATED.
// Any changes to this file will be overwritten.
// For more information about how codegen works, see font-codegen/README.md

#[allow(unused_imports)]
use crate::codegen_prelude::*;

/// [Compact Font Format](https://learn.microsoft.com/en-us/typography/opentype/spec/cff) table header
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct CffHeaderMarker {
    _padding_byte_len: usize,
    trailing_data_byte_len: usize,
}

impl CffHeaderMarker {
    pub fn major_byte_range(&self) -> Range<usize> {
        let start = 0;
        start..start + u8::RAW_BYTE_LEN
    }

    pub fn minor_byte_range(&self) -> Range<usize> {
        let start = self.major_byte_range().end;
        start..start + u8::RAW_BYTE_LEN
    }

    pub fn hdr_size_byte_range(&self) -> Range<usize> {
        let start = self.minor_byte_range().end;
        start..start + u8::RAW_BYTE_LEN
    }

    pub fn off_size_byte_range(&self) -> Range<usize> {
        let start = self.hdr_size_byte_range().end;
        start..start + u8::RAW_BYTE_LEN
    }

    pub fn _padding_byte_range(&self) -> Range<usize> {
        let start = self.off_size_byte_range().end;
        start..start + self._padding_byte_len
    }

    pub fn trailing_data_byte_range(&self) -> Range<usize> {
        let start = self._padding_byte_range().end;
        start..start + self.trailing_data_byte_len
    }
}

impl<'a> FontRead<'a> for CffHeader<'a> {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        let mut cursor = data.cursor();
        cursor.advance::<u8>();
        cursor.advance::<u8>();
        let hdr_size: u8 = cursor.read()?;
        cursor.advance::<u8>();
        let _padding_byte_len = (transforms::subtract(hdr_size, 4_usize))
            .checked_mul(u8::RAW_BYTE_LEN)
            .ok_or(ReadError::OutOfBounds)?;
        cursor.advance_by(_padding_byte_len);
        let trailing_data_byte_len = cursor.remaining_bytes() / u8::RAW_BYTE_LEN * u8::RAW_BYTE_LEN;
        cursor.advance_by(trailing_data_byte_len);
        cursor.finish(CffHeaderMarker {
            _padding_byte_len,
            trailing_data_byte_len,
        })
    }
}

/// [Compact Font Format](https://learn.microsoft.com/en-us/typography/opentype/spec/cff) table header
pub type CffHeader<'a> = TableRef<'a, CffHeaderMarker>;

#[allow(clippy::needless_lifetimes)]
impl<'a> CffHeader<'a> {
    /// Format major version (starting at 1).
    pub fn major(&self) -> u8 {
        let range = self.shape.major_byte_range();
        self.data.read_at(range.start).unwrap()
    }

    /// Format minor version (starting at 0).
    pub fn minor(&self) -> u8 {
        let range = self.shape.minor_byte_range();
        self.data.read_at(range.start).unwrap()
    }

    /// Header size (bytes).
    pub fn hdr_size(&self) -> u8 {
        let range = self.shape.hdr_size_byte_range();
        self.data.read_at(range.start).unwrap()
    }

    /// Absolute offset size.
    pub fn off_size(&self) -> u8 {
        let range = self.shape.off_size_byte_range();
        self.data.read_at(range.start).unwrap()
    }

    /// Padding bytes before the start of the Name INDEX.
    pub fn _padding(&self) -> &'a [u8] {
        let range = self.shape._padding_byte_range();
        self.data.read_array(range).unwrap()
    }

    /// Remaining table data.
    pub fn trailing_data(&self) -> &'a [u8] {
        let range = self.shape.trailing_data_byte_range();
        self.data.read_array(range).unwrap()
    }
}

#[cfg(feature = "experimental_traverse")]
impl<'a> SomeTable<'a> for CffHeader<'a> {
    fn type_name(&self) -> &str {
        "CffHeader"
    }
    fn get_field(&self, idx: usize) -> Option<Field<'a>> {
        match idx {
            0usize => Some(Field::new("major", self.major())),
            1usize => Some(Field::new("minor", self.minor())),
            2usize => Some(Field::new("hdr_size", self.hdr_size())),
            3usize => Some(Field::new("off_size", self.off_size())),
            4usize => Some(Field::new("_padding", self._padding())),
            5usize => Some(Field::new("trailing_data", self.trailing_data())),
            _ => None,
        }
    }
}

#[cfg(feature = "experimental_traverse")]
#[allow(clippy::needless_lifetimes)]
impl<'a> std::fmt::Debug for CffHeader<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        (self as &dyn SomeTable<'a>).fmt(f)
    }
}