read_fonts/generated/
generated_hhea.rs1#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8impl<'a> MinByteRange<'a> for Hhea<'a> {
9 fn min_byte_range(&self) -> Range<usize> {
10 0..self.number_of_h_metrics_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 TopLevelTable for Hhea<'_> {
19 const TAG: Tag = Tag::new(b"hhea");
21}
22
23impl ReadArgs for Hhea<'_> {
24 type Args = ();
25}
26
27impl<'a> FontRead<'a> for Hhea<'a> {
28 fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
29 #[allow(clippy::absurd_extreme_comparisons)]
30 if data.len() < Self::MIN_SIZE {
31 return Err(ReadError::OutOfBounds);
32 }
33 let Some(data) = TableDataRef::new(data.as_bytes()) else {
34 return Err(ReadError::OutOfBounds);
35 };
36 Ok(Self { data })
37 }
38}
39
40#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
42#[repr(C, packed)]
43#[doc(hidden)]
44pub struct HheaFixedHeader {
45 pub version: BigEndian<MajorMinor>,
46 pub ascender: BigEndian<FWord>,
47 pub descender: BigEndian<FWord>,
48 pub line_gap: BigEndian<FWord>,
49 pub advance_width_max: BigEndian<UfWord>,
50 pub min_left_side_bearing: BigEndian<FWord>,
51 pub min_right_side_bearing: BigEndian<FWord>,
52 pub x_max_extent: BigEndian<FWord>,
53 pub caret_slope_rise: BigEndian<i16>,
54 pub caret_slope_run: BigEndian<i16>,
55 pub caret_offset: BigEndian<i16>,
56 pub reserved1: BigEndian<i16>,
57 pub reserved2: BigEndian<i16>,
58 pub reserved3: BigEndian<i16>,
59 pub reserved4: BigEndian<i16>,
60 pub metric_data_format: BigEndian<i16>,
61 pub number_of_h_metrics: BigEndian<u16>,
62}
63
64#[allow(clippy::absurd_extreme_comparisons)]
65const _: () = assert!(std::mem::size_of::<HheaFixedHeader>() <= Hhea::MIN_SIZE);
66
67#[derive(Clone)]
69pub struct Hhea<'a> {
70 data: TableDataRef<'a, HheaFixedHeader>,
71}
72
73#[allow(clippy::needless_lifetimes)]
74impl<'a> Hhea<'a> {
75 pub const MIN_SIZE: usize = (MajorMinor::RAW_BYTE_LEN
76 + FWord::RAW_BYTE_LEN
77 + FWord::RAW_BYTE_LEN
78 + FWord::RAW_BYTE_LEN
79 + UfWord::RAW_BYTE_LEN
80 + FWord::RAW_BYTE_LEN
81 + FWord::RAW_BYTE_LEN
82 + FWord::RAW_BYTE_LEN
83 + i16::RAW_BYTE_LEN
84 + i16::RAW_BYTE_LEN
85 + i16::RAW_BYTE_LEN
86 + i16::RAW_BYTE_LEN
87 + i16::RAW_BYTE_LEN
88 + i16::RAW_BYTE_LEN
89 + i16::RAW_BYTE_LEN
90 + i16::RAW_BYTE_LEN
91 + u16::RAW_BYTE_LEN);
92 basic_table_impls!(impl_the_methods);
93
94 pub fn version(&self) -> MajorMinor {
96 self.data.header().version.get()
97 }
98
99 pub fn ascender(&self) -> FWord {
101 self.data.header().ascender.get()
102 }
103
104 pub fn descender(&self) -> FWord {
106 self.data.header().descender.get()
107 }
108
109 pub fn line_gap(&self) -> FWord {
112 self.data.header().line_gap.get()
113 }
114
115 pub fn advance_width_max(&self) -> UfWord {
117 self.data.header().advance_width_max.get()
118 }
119
120 pub fn min_left_side_bearing(&self) -> FWord {
123 self.data.header().min_left_side_bearing.get()
124 }
125
126 pub fn min_right_side_bearing(&self) -> FWord {
129 self.data.header().min_right_side_bearing.get()
130 }
131
132 pub fn x_max_extent(&self) -> FWord {
134 self.data.header().x_max_extent.get()
135 }
136
137 pub fn caret_slope_rise(&self) -> i16 {
140 self.data.header().caret_slope_rise.get()
141 }
142
143 pub fn caret_slope_run(&self) -> i16 {
145 self.data.header().caret_slope_run.get()
146 }
147
148 pub fn caret_offset(&self) -> i16 {
152 self.data.header().caret_offset.get()
153 }
154
155 pub fn metric_data_format(&self) -> i16 {
157 self.data.header().metric_data_format.get()
158 }
159
160 pub fn number_of_h_metrics(&self) -> u16 {
162 self.data.header().number_of_h_metrics.get()
163 }
164
165 pub fn version_byte_range(&self) -> Range<usize> {
166 let start = 0;
167 let end = start + MajorMinor::RAW_BYTE_LEN;
168 start..end
169 }
170
171 pub fn ascender_byte_range(&self) -> Range<usize> {
172 let start = self.version_byte_range().end;
173 let end = start + FWord::RAW_BYTE_LEN;
174 start..end
175 }
176
177 pub fn descender_byte_range(&self) -> Range<usize> {
178 let start = self.ascender_byte_range().end;
179 let end = start + FWord::RAW_BYTE_LEN;
180 start..end
181 }
182
183 pub fn line_gap_byte_range(&self) -> Range<usize> {
184 let start = self.descender_byte_range().end;
185 let end = start + FWord::RAW_BYTE_LEN;
186 start..end
187 }
188
189 pub fn advance_width_max_byte_range(&self) -> Range<usize> {
190 let start = self.line_gap_byte_range().end;
191 let end = start + UfWord::RAW_BYTE_LEN;
192 start..end
193 }
194
195 pub fn min_left_side_bearing_byte_range(&self) -> Range<usize> {
196 let start = self.advance_width_max_byte_range().end;
197 let end = start + FWord::RAW_BYTE_LEN;
198 start..end
199 }
200
201 pub fn min_right_side_bearing_byte_range(&self) -> Range<usize> {
202 let start = self.min_left_side_bearing_byte_range().end;
203 let end = start + FWord::RAW_BYTE_LEN;
204 start..end
205 }
206
207 pub fn x_max_extent_byte_range(&self) -> Range<usize> {
208 let start = self.min_right_side_bearing_byte_range().end;
209 let end = start + FWord::RAW_BYTE_LEN;
210 start..end
211 }
212
213 pub fn caret_slope_rise_byte_range(&self) -> Range<usize> {
214 let start = self.x_max_extent_byte_range().end;
215 let end = start + i16::RAW_BYTE_LEN;
216 start..end
217 }
218
219 pub fn caret_slope_run_byte_range(&self) -> Range<usize> {
220 let start = self.caret_slope_rise_byte_range().end;
221 let end = start + i16::RAW_BYTE_LEN;
222 start..end
223 }
224
225 pub fn caret_offset_byte_range(&self) -> Range<usize> {
226 let start = self.caret_slope_run_byte_range().end;
227 let end = start + i16::RAW_BYTE_LEN;
228 start..end
229 }
230
231 pub fn reserved1_byte_range(&self) -> Range<usize> {
232 let start = self.caret_offset_byte_range().end;
233 let end = start + i16::RAW_BYTE_LEN;
234 start..end
235 }
236
237 pub fn reserved2_byte_range(&self) -> Range<usize> {
238 let start = self.reserved1_byte_range().end;
239 let end = start + i16::RAW_BYTE_LEN;
240 start..end
241 }
242
243 pub fn reserved3_byte_range(&self) -> Range<usize> {
244 let start = self.reserved2_byte_range().end;
245 let end = start + i16::RAW_BYTE_LEN;
246 start..end
247 }
248
249 pub fn reserved4_byte_range(&self) -> Range<usize> {
250 let start = self.reserved3_byte_range().end;
251 let end = start + i16::RAW_BYTE_LEN;
252 start..end
253 }
254
255 pub fn metric_data_format_byte_range(&self) -> Range<usize> {
256 let start = self.reserved4_byte_range().end;
257 let end = start + i16::RAW_BYTE_LEN;
258 start..end
259 }
260
261 pub fn number_of_h_metrics_byte_range(&self) -> Range<usize> {
262 let start = self.metric_data_format_byte_range().end;
263 let end = start + u16::RAW_BYTE_LEN;
264 start..end
265 }
266}
267
268const _: () = assert!(FontData::default_data_long_enough(Hhea::MIN_SIZE));
269
270impl Default for Hhea<'_> {
271 fn default() -> Self {
272 Self {
273 data: TableDataRef::new(FontData::default_table_data().as_bytes())
274 .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
275 }
276 }
277}
278
279impl<'a> MinByteRange<'a> for HheaExtended<'a> {
280 fn min_byte_range(&self) -> Range<usize> {
281 0..self.number_of_h_metrics_byte_range().end
282 }
283 fn min_table_bytes(&self) -> &'a [u8] {
284 let range = self.min_byte_range();
285 self.offset_data().as_bytes().get(range).unwrap_or_default()
286 }
287}
288
289impl TopLevelTable for HheaExtended<'_> {
290 const TAG: Tag = Tag::new(b"HHEA");
292}
293
294impl ReadArgs for HheaExtended<'_> {
295 type Args = ();
296}
297
298impl<'a> FontRead<'a> for HheaExtended<'a> {
299 fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
300 #[allow(clippy::absurd_extreme_comparisons)]
301 if data.len() < Self::MIN_SIZE {
302 return Err(ReadError::OutOfBounds);
303 }
304 let Some(data) = TableDataRef::new(data.as_bytes()) else {
305 return Err(ReadError::OutOfBounds);
306 };
307 Ok(Self { data })
308 }
309}
310
311#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
313#[repr(C, packed)]
314#[doc(hidden)]
315pub struct HheaExtendedFixedHeader {
316 pub version: BigEndian<MajorMinor>,
317 pub ascender: BigEndian<FWord>,
318 pub descender: BigEndian<FWord>,
319 pub line_gap: BigEndian<FWord>,
320 pub advance_width_max: BigEndian<UfWord>,
321 pub min_left_side_bearing: BigEndian<FWord>,
322 pub min_right_side_bearing: BigEndian<FWord>,
323 pub x_max_extent: BigEndian<FWord>,
324 pub caret_slope_rise: BigEndian<i16>,
325 pub caret_slope_run: BigEndian<i16>,
326 pub caret_offset: BigEndian<i16>,
327 pub reserved1: BigEndian<i16>,
328 pub reserved2: BigEndian<i16>,
329 pub reserved3: BigEndian<i16>,
330 pub reserved4: BigEndian<i16>,
331 pub metric_data_format: BigEndian<i16>,
332 pub number_of_h_metrics: BigEndian<u32>,
333}
334
335#[allow(clippy::absurd_extreme_comparisons)]
336const _: () = assert!(std::mem::size_of::<HheaExtendedFixedHeader>() <= HheaExtended::MIN_SIZE);
337
338#[derive(Clone)]
340pub struct HheaExtended<'a> {
341 data: TableDataRef<'a, HheaExtendedFixedHeader>,
342}
343
344#[allow(clippy::needless_lifetimes)]
345impl<'a> HheaExtended<'a> {
346 pub const MIN_SIZE: usize = (MajorMinor::RAW_BYTE_LEN
347 + FWord::RAW_BYTE_LEN
348 + FWord::RAW_BYTE_LEN
349 + FWord::RAW_BYTE_LEN
350 + UfWord::RAW_BYTE_LEN
351 + FWord::RAW_BYTE_LEN
352 + FWord::RAW_BYTE_LEN
353 + FWord::RAW_BYTE_LEN
354 + i16::RAW_BYTE_LEN
355 + i16::RAW_BYTE_LEN
356 + i16::RAW_BYTE_LEN
357 + i16::RAW_BYTE_LEN
358 + i16::RAW_BYTE_LEN
359 + i16::RAW_BYTE_LEN
360 + i16::RAW_BYTE_LEN
361 + i16::RAW_BYTE_LEN
362 + u32::RAW_BYTE_LEN);
363 basic_table_impls!(impl_the_methods);
364
365 pub fn version(&self) -> MajorMinor {
366 self.data.header().version.get()
367 }
368
369 pub fn ascender(&self) -> FWord {
370 self.data.header().ascender.get()
371 }
372
373 pub fn descender(&self) -> FWord {
374 self.data.header().descender.get()
375 }
376
377 pub fn line_gap(&self) -> FWord {
378 self.data.header().line_gap.get()
379 }
380
381 pub fn advance_width_max(&self) -> UfWord {
382 self.data.header().advance_width_max.get()
383 }
384
385 pub fn min_left_side_bearing(&self) -> FWord {
386 self.data.header().min_left_side_bearing.get()
387 }
388
389 pub fn min_right_side_bearing(&self) -> FWord {
390 self.data.header().min_right_side_bearing.get()
391 }
392
393 pub fn x_max_extent(&self) -> FWord {
394 self.data.header().x_max_extent.get()
395 }
396
397 pub fn caret_slope_rise(&self) -> i16 {
398 self.data.header().caret_slope_rise.get()
399 }
400
401 pub fn caret_slope_run(&self) -> i16 {
402 self.data.header().caret_slope_run.get()
403 }
404
405 pub fn caret_offset(&self) -> i16 {
406 self.data.header().caret_offset.get()
407 }
408
409 pub fn metric_data_format(&self) -> i16 {
410 self.data.header().metric_data_format.get()
411 }
412
413 pub fn number_of_h_metrics(&self) -> u32 {
415 self.data.header().number_of_h_metrics.get()
416 }
417
418 pub fn version_byte_range(&self) -> Range<usize> {
419 let start = 0;
420 let end = start + MajorMinor::RAW_BYTE_LEN;
421 start..end
422 }
423
424 pub fn ascender_byte_range(&self) -> Range<usize> {
425 let start = self.version_byte_range().end;
426 let end = start + FWord::RAW_BYTE_LEN;
427 start..end
428 }
429
430 pub fn descender_byte_range(&self) -> Range<usize> {
431 let start = self.ascender_byte_range().end;
432 let end = start + FWord::RAW_BYTE_LEN;
433 start..end
434 }
435
436 pub fn line_gap_byte_range(&self) -> Range<usize> {
437 let start = self.descender_byte_range().end;
438 let end = start + FWord::RAW_BYTE_LEN;
439 start..end
440 }
441
442 pub fn advance_width_max_byte_range(&self) -> Range<usize> {
443 let start = self.line_gap_byte_range().end;
444 let end = start + UfWord::RAW_BYTE_LEN;
445 start..end
446 }
447
448 pub fn min_left_side_bearing_byte_range(&self) -> Range<usize> {
449 let start = self.advance_width_max_byte_range().end;
450 let end = start + FWord::RAW_BYTE_LEN;
451 start..end
452 }
453
454 pub fn min_right_side_bearing_byte_range(&self) -> Range<usize> {
455 let start = self.min_left_side_bearing_byte_range().end;
456 let end = start + FWord::RAW_BYTE_LEN;
457 start..end
458 }
459
460 pub fn x_max_extent_byte_range(&self) -> Range<usize> {
461 let start = self.min_right_side_bearing_byte_range().end;
462 let end = start + FWord::RAW_BYTE_LEN;
463 start..end
464 }
465
466 pub fn caret_slope_rise_byte_range(&self) -> Range<usize> {
467 let start = self.x_max_extent_byte_range().end;
468 let end = start + i16::RAW_BYTE_LEN;
469 start..end
470 }
471
472 pub fn caret_slope_run_byte_range(&self) -> Range<usize> {
473 let start = self.caret_slope_rise_byte_range().end;
474 let end = start + i16::RAW_BYTE_LEN;
475 start..end
476 }
477
478 pub fn caret_offset_byte_range(&self) -> Range<usize> {
479 let start = self.caret_slope_run_byte_range().end;
480 let end = start + i16::RAW_BYTE_LEN;
481 start..end
482 }
483
484 pub fn reserved1_byte_range(&self) -> Range<usize> {
485 let start = self.caret_offset_byte_range().end;
486 let end = start + i16::RAW_BYTE_LEN;
487 start..end
488 }
489
490 pub fn reserved2_byte_range(&self) -> Range<usize> {
491 let start = self.reserved1_byte_range().end;
492 let end = start + i16::RAW_BYTE_LEN;
493 start..end
494 }
495
496 pub fn reserved3_byte_range(&self) -> Range<usize> {
497 let start = self.reserved2_byte_range().end;
498 let end = start + i16::RAW_BYTE_LEN;
499 start..end
500 }
501
502 pub fn reserved4_byte_range(&self) -> Range<usize> {
503 let start = self.reserved3_byte_range().end;
504 let end = start + i16::RAW_BYTE_LEN;
505 start..end
506 }
507
508 pub fn metric_data_format_byte_range(&self) -> Range<usize> {
509 let start = self.reserved4_byte_range().end;
510 let end = start + i16::RAW_BYTE_LEN;
511 start..end
512 }
513
514 pub fn number_of_h_metrics_byte_range(&self) -> Range<usize> {
515 let start = self.metric_data_format_byte_range().end;
516 let end = start + u32::RAW_BYTE_LEN;
517 start..end
518 }
519}
520
521const _: () = assert!(FontData::default_data_long_enough(HheaExtended::MIN_SIZE));
522
523impl Default for HheaExtended<'_> {
524 fn default() -> Self {
525 Self {
526 data: TableDataRef::new(FontData::default_table_data().as_bytes())
527 .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
528 }
529 }
530}