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