read_fonts/generated/
generated_cff2.rs1#[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#[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#[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 pub fn major_version(&self) -> u8 {
63 self.data.header().major_version
64 }
65
66 pub fn minor_version(&self) -> u8 {
68 self.data.header().minor_version
69 }
70
71 pub fn header_size(&self) -> u8 {
73 self.data.header().header_size
74 }
75
76 pub fn top_dict_length(&self) -> u16 {
78 self.data.header().top_dict_length.get()
79 }
80
81 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 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 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#[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#[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 pub fn count(&self) -> u32 {
218 self.data.header().count.get()
219 }
220
221 pub fn off_size(&self) -> u8 {
223 self.data.header().off_size
224 }
225
226 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 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}