Skip to main content

read_fonts/generated/
generated_cff2.rs

1// THIS FILE IS AUTOGENERATED.
2// Any changes to this file will be overwritten.
3// For more information about how codegen works, see font-codegen/README.md
4
5#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8impl<'a> MinByteRange<'a> for Cff2Header<'a> {
9    fn min_byte_range(&self) -> Range<usize> {
10        0..self.trailing_data_byte_range().end
11    }
12    fn min_table_bytes(&self) -> &'a [u8] {
13        let range = self.min_byte_range();
14        self.offset_data().as_bytes().get(range).unwrap_or_default()
15    }
16}
17
18impl ReadArgs for Cff2Header<'_> {
19    type Args = ();
20}
21
22impl<'a> FontRead<'a> for Cff2Header<'a> {
23    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
24        #[allow(clippy::absurd_extreme_comparisons)]
25        if data.len() < Self::MIN_SIZE {
26            return Err(ReadError::OutOfBounds);
27        }
28        let Some(data) = TableDataRef::new(data.as_bytes()) else {
29            return Err(ReadError::OutOfBounds);
30        };
31        Ok(Self { data })
32    }
33}
34
35/// The fields at the start of the table, which are read directly.
36#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
37#[repr(C, packed)]
38#[doc(hidden)]
39pub struct Cff2HeaderFixedHeader {
40    pub major_version: u8,
41    pub minor_version: u8,
42    pub header_size: u8,
43    pub top_dict_length: BigEndian<u16>,
44}
45
46#[allow(clippy::absurd_extreme_comparisons)]
47const _: () = assert!(std::mem::size_of::<Cff2HeaderFixedHeader>() <= Cff2Header::MIN_SIZE);
48
49/// [Compact Font Format (CFF) version 2](https://learn.microsoft.com/en-us/typography/opentype/spec/cff2) table header
50#[derive(Clone)]
51pub struct Cff2Header<'a> {
52    data: TableDataRef<'a, Cff2HeaderFixedHeader>,
53}
54
55#[allow(clippy::needless_lifetimes)]
56impl<'a> Cff2Header<'a> {
57    pub const MIN_SIZE: usize =
58        (u8::RAW_BYTE_LEN + u8::RAW_BYTE_LEN + u8::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
59    basic_table_impls!(impl_the_methods);
60
61    /// Format major version (set to 2).
62    pub fn major_version(&self) -> u8 {
63        self.data.header().major_version
64    }
65
66    /// Format minor version (set to 0).
67    pub fn minor_version(&self) -> u8 {
68        self.data.header().minor_version
69    }
70
71    /// Header size (bytes).
72    pub fn header_size(&self) -> u8 {
73        self.data.header().header_size
74    }
75
76    /// Length of Top DICT structure in bytes.
77    pub fn top_dict_length(&self) -> u16 {
78        self.data.header().top_dict_length.get()
79    }
80
81    /// Padding bytes before the start of the Top DICT.
82    pub fn _padding(&self) -> &'a [u8] {
83        let range = self._padding_byte_range();
84        self.offset_data()
85            .read_array(range)
86            .ok()
87            .unwrap_or_default()
88    }
89
90    /// Data containing the Top DICT.
91    pub fn top_dict_data(&self) -> &'a [u8] {
92        let range = self.top_dict_data_byte_range();
93        self.offset_data()
94            .read_array(range)
95            .ok()
96            .unwrap_or_default()
97    }
98
99    /// Remaining table data.
100    pub fn trailing_data(&self) -> &'a [u8] {
101        let range = self.trailing_data_byte_range();
102        self.offset_data()
103            .read_array(range)
104            .ok()
105            .unwrap_or_default()
106    }
107
108    pub fn major_version_byte_range(&self) -> Range<usize> {
109        let start = 0;
110        let end = start + u8::RAW_BYTE_LEN;
111        start..end
112    }
113
114    pub fn minor_version_byte_range(&self) -> Range<usize> {
115        let start = self.major_version_byte_range().end;
116        let end = start + u8::RAW_BYTE_LEN;
117        start..end
118    }
119
120    pub fn header_size_byte_range(&self) -> Range<usize> {
121        let start = self.minor_version_byte_range().end;
122        let end = start + u8::RAW_BYTE_LEN;
123        start..end
124    }
125
126    pub fn top_dict_length_byte_range(&self) -> Range<usize> {
127        let start = self.header_size_byte_range().end;
128        let end = start + u16::RAW_BYTE_LEN;
129        start..end
130    }
131
132    pub fn _padding_byte_range(&self) -> Range<usize> {
133        let header_size = self.header_size();
134        let start = self.top_dict_length_byte_range().end;
135        let end =
136            start + (transforms::subtract(header_size, 5_usize)).saturating_mul(u8::RAW_BYTE_LEN);
137        start..end
138    }
139
140    pub fn top_dict_data_byte_range(&self) -> Range<usize> {
141        let top_dict_length = self.top_dict_length();
142        let start = self._padding_byte_range().end;
143        let end = start + (transforms::to_usize(top_dict_length)).saturating_mul(u8::RAW_BYTE_LEN);
144        start..end
145    }
146
147    pub fn trailing_data_byte_range(&self) -> Range<usize> {
148        let start = self.top_dict_data_byte_range().end;
149        let end = start
150            + self.offset_data().len().saturating_sub(start) / u8::RAW_BYTE_LEN * u8::RAW_BYTE_LEN;
151        start..end
152    }
153}
154
155const _: () = assert!(FontData::default_data_long_enough(Cff2Header::MIN_SIZE));
156
157impl Default for Cff2Header<'_> {
158    fn default() -> Self {
159        Self {
160            data: TableDataRef::new(FontData::default_table_data().as_bytes())
161                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
162        }
163    }
164}
165
166impl<'a> MinByteRange<'a> for Index<'a> {
167    fn min_byte_range(&self) -> Range<usize> {
168        0..self.data_byte_range().end
169    }
170    fn min_table_bytes(&self) -> &'a [u8] {
171        let range = self.min_byte_range();
172        self.offset_data().as_bytes().get(range).unwrap_or_default()
173    }
174}
175
176impl ReadArgs for Index<'_> {
177    type Args = ();
178}
179
180impl<'a> FontRead<'a> for Index<'a> {
181    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
182        #[allow(clippy::absurd_extreme_comparisons)]
183        if data.len() < Self::MIN_SIZE {
184            return Err(ReadError::OutOfBounds);
185        }
186        let Some(data) = TableDataRef::new(data.as_bytes()) else {
187            return Err(ReadError::OutOfBounds);
188        };
189        Ok(Self { data })
190    }
191}
192
193/// The fields at the start of the table, which are read directly.
194#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
195#[repr(C, packed)]
196#[doc(hidden)]
197pub struct IndexFixedHeader {
198    pub count: BigEndian<u32>,
199    pub off_size: u8,
200}
201
202#[allow(clippy::absurd_extreme_comparisons)]
203const _: () = assert!(std::mem::size_of::<IndexFixedHeader>() <= Index::MIN_SIZE);
204
205/// An array of variable-sized objects in a `CFF2` table.
206#[derive(Clone)]
207pub struct Index<'a> {
208    data: TableDataRef<'a, IndexFixedHeader>,
209}
210
211#[allow(clippy::needless_lifetimes)]
212impl<'a> Index<'a> {
213    pub const MIN_SIZE: usize = (u32::RAW_BYTE_LEN + u8::RAW_BYTE_LEN);
214    basic_table_impls!(impl_the_methods);
215
216    /// Number of objects stored in INDEX.
217    pub fn count(&self) -> u32 {
218        self.data.header().count.get()
219    }
220
221    /// Object array element size.
222    pub fn off_size(&self) -> u8 {
223        self.data.header().off_size
224    }
225
226    /// Bytes containing `count + 1` offsets each of `off_size`.
227    pub fn offsets(&self) -> &'a [u8] {
228        let range = self.offsets_byte_range();
229        self.offset_data()
230            .read_array(range)
231            .ok()
232            .unwrap_or_default()
233    }
234
235    /// Array containing the object data.
236    pub fn data(&self) -> &'a [u8] {
237        let range = self.data_byte_range();
238        self.offset_data()
239            .read_array(range)
240            .ok()
241            .unwrap_or_default()
242    }
243
244    pub fn count_byte_range(&self) -> Range<usize> {
245        let start = 0;
246        let end = start + u32::RAW_BYTE_LEN;
247        start..end
248    }
249
250    pub fn off_size_byte_range(&self) -> Range<usize> {
251        let start = self.count_byte_range().end;
252        let end = start + u8::RAW_BYTE_LEN;
253        start..end
254    }
255
256    pub fn offsets_byte_range(&self) -> Range<usize> {
257        let count = self.count();
258        let off_size = self.off_size();
259        let start = self.off_size_byte_range().end;
260        let end = start
261            + (transforms::add_multiply(count, 1_usize, off_size)).saturating_mul(u8::RAW_BYTE_LEN);
262        start..end
263    }
264
265    pub fn data_byte_range(&self) -> Range<usize> {
266        let start = self.offsets_byte_range().end;
267        let end = start
268            + self.offset_data().len().saturating_sub(start) / u8::RAW_BYTE_LEN * u8::RAW_BYTE_LEN;
269        start..end
270    }
271}
272
273const _: () = assert!(FontData::default_data_long_enough(Index::MIN_SIZE));
274
275impl Default for Index<'_> {
276    fn default() -> Self {
277        Self {
278            data: TableDataRef::new(FontData::default_table_data().as_bytes())
279                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
280        }
281    }
282}