read_fonts/generated/
generated_maxp.rs1#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8impl<'a> MinByteRange<'a> for Maxp<'a> {
9 fn min_byte_range(&self) -> Range<usize> {
10 0..self.num_glyphs_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 Maxp<'_> {
19 const TAG: Tag = Tag::new(b"maxp");
21}
22
23impl ReadArgs for Maxp<'_> {
24 type Args = ();
25}
26
27impl<'a> FontRead<'a> for Maxp<'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 MaxpFixedHeader {
45 pub version: BigEndian<Version16Dot16>,
46 pub num_glyphs: BigEndian<u16>,
47}
48
49#[allow(clippy::absurd_extreme_comparisons)]
50const _: () = assert!(std::mem::size_of::<MaxpFixedHeader>() <= Maxp::MIN_SIZE);
51
52#[derive(Clone)]
54pub struct Maxp<'a> {
55 data: TableDataRef<'a, MaxpFixedHeader>,
56}
57
58#[allow(clippy::needless_lifetimes)]
59impl<'a> Maxp<'a> {
60 pub const MIN_SIZE: usize = (Version16Dot16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
61 basic_table_impls!(impl_the_methods);
62
63 pub fn version(&self) -> Version16Dot16 {
65 self.data.header().version.get()
66 }
67
68 pub fn num_glyphs(&self) -> u16 {
70 self.data.header().num_glyphs.get()
71 }
72
73 pub fn max_points(&self) -> Option<u16> {
75 let range = self.max_points_byte_range();
76 (!range.is_empty())
77 .then(|| self.offset_data().read_at(range.start).ok())
78 .flatten()
79 }
80
81 pub fn max_contours(&self) -> Option<u16> {
83 let range = self.max_contours_byte_range();
84 (!range.is_empty())
85 .then(|| self.offset_data().read_at(range.start).ok())
86 .flatten()
87 }
88
89 pub fn max_composite_points(&self) -> Option<u16> {
91 let range = self.max_composite_points_byte_range();
92 (!range.is_empty())
93 .then(|| self.offset_data().read_at(range.start).ok())
94 .flatten()
95 }
96
97 pub fn max_composite_contours(&self) -> Option<u16> {
99 let range = self.max_composite_contours_byte_range();
100 (!range.is_empty())
101 .then(|| self.offset_data().read_at(range.start).ok())
102 .flatten()
103 }
104
105 pub fn max_zones(&self) -> Option<u16> {
108 let range = self.max_zones_byte_range();
109 (!range.is_empty())
110 .then(|| self.offset_data().read_at(range.start).ok())
111 .flatten()
112 }
113
114 pub fn max_twilight_points(&self) -> Option<u16> {
116 let range = self.max_twilight_points_byte_range();
117 (!range.is_empty())
118 .then(|| self.offset_data().read_at(range.start).ok())
119 .flatten()
120 }
121
122 pub fn max_storage(&self) -> Option<u16> {
124 let range = self.max_storage_byte_range();
125 (!range.is_empty())
126 .then(|| self.offset_data().read_at(range.start).ok())
127 .flatten()
128 }
129
130 pub fn max_function_defs(&self) -> Option<u16> {
132 let range = self.max_function_defs_byte_range();
133 (!range.is_empty())
134 .then(|| self.offset_data().read_at(range.start).ok())
135 .flatten()
136 }
137
138 pub fn max_instruction_defs(&self) -> Option<u16> {
140 let range = self.max_instruction_defs_byte_range();
141 (!range.is_empty())
142 .then(|| self.offset_data().read_at(range.start).ok())
143 .flatten()
144 }
145
146 pub fn max_stack_elements(&self) -> Option<u16> {
150 let range = self.max_stack_elements_byte_range();
151 (!range.is_empty())
152 .then(|| self.offset_data().read_at(range.start).ok())
153 .flatten()
154 }
155
156 pub fn max_size_of_instructions(&self) -> Option<u16> {
158 let range = self.max_size_of_instructions_byte_range();
159 (!range.is_empty())
160 .then(|| self.offset_data().read_at(range.start).ok())
161 .flatten()
162 }
163
164 pub fn max_component_elements(&self) -> Option<u16> {
167 let range = self.max_component_elements_byte_range();
168 (!range.is_empty())
169 .then(|| self.offset_data().read_at(range.start).ok())
170 .flatten()
171 }
172
173 pub fn max_component_depth(&self) -> Option<u16> {
175 let range = self.max_component_depth_byte_range();
176 (!range.is_empty())
177 .then(|| self.offset_data().read_at(range.start).ok())
178 .flatten()
179 }
180
181 pub fn version_byte_range(&self) -> Range<usize> {
182 let start = 0;
183 let end = start + Version16Dot16::RAW_BYTE_LEN;
184 start..end
185 }
186
187 pub fn num_glyphs_byte_range(&self) -> Range<usize> {
188 let start = self.version_byte_range().end;
189 let end = start + u16::RAW_BYTE_LEN;
190 start..end
191 }
192
193 pub fn max_points_byte_range(&self) -> Range<usize> {
194 let start = self.num_glyphs_byte_range().end;
195 let end = if self.version().compatible((1u16, 0u16)) {
196 start + u16::RAW_BYTE_LEN
197 } else {
198 start
199 };
200 start..end
201 }
202
203 pub fn max_contours_byte_range(&self) -> Range<usize> {
204 let start = self.max_points_byte_range().end;
205 let end = if self.version().compatible((1u16, 0u16)) {
206 start + u16::RAW_BYTE_LEN
207 } else {
208 start
209 };
210 start..end
211 }
212
213 pub fn max_composite_points_byte_range(&self) -> Range<usize> {
214 let start = self.max_contours_byte_range().end;
215 let end = if self.version().compatible((1u16, 0u16)) {
216 start + u16::RAW_BYTE_LEN
217 } else {
218 start
219 };
220 start..end
221 }
222
223 pub fn max_composite_contours_byte_range(&self) -> Range<usize> {
224 let start = self.max_composite_points_byte_range().end;
225 let end = if self.version().compatible((1u16, 0u16)) {
226 start + u16::RAW_BYTE_LEN
227 } else {
228 start
229 };
230 start..end
231 }
232
233 pub fn max_zones_byte_range(&self) -> Range<usize> {
234 let start = self.max_composite_contours_byte_range().end;
235 let end = if self.version().compatible((1u16, 0u16)) {
236 start + u16::RAW_BYTE_LEN
237 } else {
238 start
239 };
240 start..end
241 }
242
243 pub fn max_twilight_points_byte_range(&self) -> Range<usize> {
244 let start = self.max_zones_byte_range().end;
245 let end = if self.version().compatible((1u16, 0u16)) {
246 start + u16::RAW_BYTE_LEN
247 } else {
248 start
249 };
250 start..end
251 }
252
253 pub fn max_storage_byte_range(&self) -> Range<usize> {
254 let start = self.max_twilight_points_byte_range().end;
255 let end = if self.version().compatible((1u16, 0u16)) {
256 start + u16::RAW_BYTE_LEN
257 } else {
258 start
259 };
260 start..end
261 }
262
263 pub fn max_function_defs_byte_range(&self) -> Range<usize> {
264 let start = self.max_storage_byte_range().end;
265 let end = if self.version().compatible((1u16, 0u16)) {
266 start + u16::RAW_BYTE_LEN
267 } else {
268 start
269 };
270 start..end
271 }
272
273 pub fn max_instruction_defs_byte_range(&self) -> Range<usize> {
274 let start = self.max_function_defs_byte_range().end;
275 let end = if self.version().compatible((1u16, 0u16)) {
276 start + u16::RAW_BYTE_LEN
277 } else {
278 start
279 };
280 start..end
281 }
282
283 pub fn max_stack_elements_byte_range(&self) -> Range<usize> {
284 let start = self.max_instruction_defs_byte_range().end;
285 let end = if self.version().compatible((1u16, 0u16)) {
286 start + u16::RAW_BYTE_LEN
287 } else {
288 start
289 };
290 start..end
291 }
292
293 pub fn max_size_of_instructions_byte_range(&self) -> Range<usize> {
294 let start = self.max_stack_elements_byte_range().end;
295 let end = if self.version().compatible((1u16, 0u16)) {
296 start + u16::RAW_BYTE_LEN
297 } else {
298 start
299 };
300 start..end
301 }
302
303 pub fn max_component_elements_byte_range(&self) -> Range<usize> {
304 let start = self.max_size_of_instructions_byte_range().end;
305 let end = if self.version().compatible((1u16, 0u16)) {
306 start + u16::RAW_BYTE_LEN
307 } else {
308 start
309 };
310 start..end
311 }
312
313 pub fn max_component_depth_byte_range(&self) -> Range<usize> {
314 let start = self.max_component_elements_byte_range().end;
315 let end = if self.version().compatible((1u16, 0u16)) {
316 start + u16::RAW_BYTE_LEN
317 } else {
318 start
319 };
320 start..end
321 }
322}
323
324const _: () = assert!(FontData::default_data_long_enough(Maxp::MIN_SIZE));
325
326impl Default for Maxp<'_> {
327 fn default() -> Self {
328 Self {
329 data: TableDataRef::new(FontData::default_table_data().as_bytes())
330 .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
331 }
332 }
333}
334
335impl<'a> MinByteRange<'a> for MaxpExtended<'a> {
336 fn min_byte_range(&self) -> Range<usize> {
337 0..self.num_glyphs_byte_range().end
338 }
339 fn min_table_bytes(&self) -> &'a [u8] {
340 let range = self.min_byte_range();
341 self.offset_data().as_bytes().get(range).unwrap_or_default()
342 }
343}
344
345impl TopLevelTable for MaxpExtended<'_> {
346 const TAG: Tag = Tag::new(b"MAXP");
348}
349
350impl ReadArgs for MaxpExtended<'_> {
351 type Args = ();
352}
353
354impl<'a> FontRead<'a> for MaxpExtended<'a> {
355 fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
356 #[allow(clippy::absurd_extreme_comparisons)]
357 if data.len() < Self::MIN_SIZE {
358 return Err(ReadError::OutOfBounds);
359 }
360 let Some(data) = TableDataRef::new(data.as_bytes()) else {
361 return Err(ReadError::OutOfBounds);
362 };
363 Ok(Self { data })
364 }
365}
366
367#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
369#[repr(C, packed)]
370#[doc(hidden)]
371pub struct MaxpExtendedFixedHeader {
372 pub version: BigEndian<Version16Dot16>,
373 pub num_glyphs: BigEndian<Uint24>,
374}
375
376#[allow(clippy::absurd_extreme_comparisons)]
377const _: () = assert!(std::mem::size_of::<MaxpExtendedFixedHeader>() <= MaxpExtended::MIN_SIZE);
378
379#[derive(Clone)]
381pub struct MaxpExtended<'a> {
382 data: TableDataRef<'a, MaxpExtendedFixedHeader>,
383}
384
385#[allow(clippy::needless_lifetimes)]
386impl<'a> MaxpExtended<'a> {
387 pub const MIN_SIZE: usize = (Version16Dot16::RAW_BYTE_LEN + Uint24::RAW_BYTE_LEN);
388 basic_table_impls!(impl_the_methods);
389
390 pub fn version(&self) -> Version16Dot16 {
391 self.data.header().version.get()
392 }
393
394 pub fn num_glyphs(&self) -> Uint24 {
396 self.data.header().num_glyphs.get()
397 }
398
399 pub fn max_points(&self) -> Option<u16> {
401 let range = self.max_points_byte_range();
402 (!range.is_empty())
403 .then(|| self.offset_data().read_at(range.start).ok())
404 .flatten()
405 }
406
407 pub fn max_contours(&self) -> Option<u16> {
409 let range = self.max_contours_byte_range();
410 (!range.is_empty())
411 .then(|| self.offset_data().read_at(range.start).ok())
412 .flatten()
413 }
414
415 pub fn max_composite_points(&self) -> Option<u16> {
417 let range = self.max_composite_points_byte_range();
418 (!range.is_empty())
419 .then(|| self.offset_data().read_at(range.start).ok())
420 .flatten()
421 }
422
423 pub fn max_composite_contours(&self) -> Option<u16> {
425 let range = self.max_composite_contours_byte_range();
426 (!range.is_empty())
427 .then(|| self.offset_data().read_at(range.start).ok())
428 .flatten()
429 }
430
431 pub fn max_zones(&self) -> Option<u16> {
433 let range = self.max_zones_byte_range();
434 (!range.is_empty())
435 .then(|| self.offset_data().read_at(range.start).ok())
436 .flatten()
437 }
438
439 pub fn max_twilight_points(&self) -> Option<u16> {
441 let range = self.max_twilight_points_byte_range();
442 (!range.is_empty())
443 .then(|| self.offset_data().read_at(range.start).ok())
444 .flatten()
445 }
446
447 pub fn max_storage(&self) -> Option<u16> {
449 let range = self.max_storage_byte_range();
450 (!range.is_empty())
451 .then(|| self.offset_data().read_at(range.start).ok())
452 .flatten()
453 }
454
455 pub fn max_function_defs(&self) -> Option<u16> {
457 let range = self.max_function_defs_byte_range();
458 (!range.is_empty())
459 .then(|| self.offset_data().read_at(range.start).ok())
460 .flatten()
461 }
462
463 pub fn max_instruction_defs(&self) -> Option<u16> {
465 let range = self.max_instruction_defs_byte_range();
466 (!range.is_empty())
467 .then(|| self.offset_data().read_at(range.start).ok())
468 .flatten()
469 }
470
471 pub fn max_stack_elements(&self) -> Option<u16> {
473 let range = self.max_stack_elements_byte_range();
474 (!range.is_empty())
475 .then(|| self.offset_data().read_at(range.start).ok())
476 .flatten()
477 }
478
479 pub fn max_size_of_instructions(&self) -> Option<u16> {
481 let range = self.max_size_of_instructions_byte_range();
482 (!range.is_empty())
483 .then(|| self.offset_data().read_at(range.start).ok())
484 .flatten()
485 }
486
487 pub fn max_component_elements(&self) -> Option<u16> {
489 let range = self.max_component_elements_byte_range();
490 (!range.is_empty())
491 .then(|| self.offset_data().read_at(range.start).ok())
492 .flatten()
493 }
494
495 pub fn max_component_depth(&self) -> Option<u16> {
497 let range = self.max_component_depth_byte_range();
498 (!range.is_empty())
499 .then(|| self.offset_data().read_at(range.start).ok())
500 .flatten()
501 }
502
503 pub fn version_byte_range(&self) -> Range<usize> {
504 let start = 0;
505 let end = start + Version16Dot16::RAW_BYTE_LEN;
506 start..end
507 }
508
509 pub fn num_glyphs_byte_range(&self) -> Range<usize> {
510 let start = self.version_byte_range().end;
511 let end = start + Uint24::RAW_BYTE_LEN;
512 start..end
513 }
514
515 pub fn max_points_byte_range(&self) -> Range<usize> {
516 let start = self.num_glyphs_byte_range().end;
517 let end = if self.version().compatible((1u16, 0u16)) {
518 start + u16::RAW_BYTE_LEN
519 } else {
520 start
521 };
522 start..end
523 }
524
525 pub fn max_contours_byte_range(&self) -> Range<usize> {
526 let start = self.max_points_byte_range().end;
527 let end = if self.version().compatible((1u16, 0u16)) {
528 start + u16::RAW_BYTE_LEN
529 } else {
530 start
531 };
532 start..end
533 }
534
535 pub fn max_composite_points_byte_range(&self) -> Range<usize> {
536 let start = self.max_contours_byte_range().end;
537 let end = if self.version().compatible((1u16, 0u16)) {
538 start + u16::RAW_BYTE_LEN
539 } else {
540 start
541 };
542 start..end
543 }
544
545 pub fn max_composite_contours_byte_range(&self) -> Range<usize> {
546 let start = self.max_composite_points_byte_range().end;
547 let end = if self.version().compatible((1u16, 0u16)) {
548 start + u16::RAW_BYTE_LEN
549 } else {
550 start
551 };
552 start..end
553 }
554
555 pub fn max_zones_byte_range(&self) -> Range<usize> {
556 let start = self.max_composite_contours_byte_range().end;
557 let end = if self.version().compatible((1u16, 0u16)) {
558 start + u16::RAW_BYTE_LEN
559 } else {
560 start
561 };
562 start..end
563 }
564
565 pub fn max_twilight_points_byte_range(&self) -> Range<usize> {
566 let start = self.max_zones_byte_range().end;
567 let end = if self.version().compatible((1u16, 0u16)) {
568 start + u16::RAW_BYTE_LEN
569 } else {
570 start
571 };
572 start..end
573 }
574
575 pub fn max_storage_byte_range(&self) -> Range<usize> {
576 let start = self.max_twilight_points_byte_range().end;
577 let end = if self.version().compatible((1u16, 0u16)) {
578 start + u16::RAW_BYTE_LEN
579 } else {
580 start
581 };
582 start..end
583 }
584
585 pub fn max_function_defs_byte_range(&self) -> Range<usize> {
586 let start = self.max_storage_byte_range().end;
587 let end = if self.version().compatible((1u16, 0u16)) {
588 start + u16::RAW_BYTE_LEN
589 } else {
590 start
591 };
592 start..end
593 }
594
595 pub fn max_instruction_defs_byte_range(&self) -> Range<usize> {
596 let start = self.max_function_defs_byte_range().end;
597 let end = if self.version().compatible((1u16, 0u16)) {
598 start + u16::RAW_BYTE_LEN
599 } else {
600 start
601 };
602 start..end
603 }
604
605 pub fn max_stack_elements_byte_range(&self) -> Range<usize> {
606 let start = self.max_instruction_defs_byte_range().end;
607 let end = if self.version().compatible((1u16, 0u16)) {
608 start + u16::RAW_BYTE_LEN
609 } else {
610 start
611 };
612 start..end
613 }
614
615 pub fn max_size_of_instructions_byte_range(&self) -> Range<usize> {
616 let start = self.max_stack_elements_byte_range().end;
617 let end = if self.version().compatible((1u16, 0u16)) {
618 start + u16::RAW_BYTE_LEN
619 } else {
620 start
621 };
622 start..end
623 }
624
625 pub fn max_component_elements_byte_range(&self) -> Range<usize> {
626 let start = self.max_size_of_instructions_byte_range().end;
627 let end = if self.version().compatible((1u16, 0u16)) {
628 start + u16::RAW_BYTE_LEN
629 } else {
630 start
631 };
632 start..end
633 }
634
635 pub fn max_component_depth_byte_range(&self) -> Range<usize> {
636 let start = self.max_component_elements_byte_range().end;
637 let end = if self.version().compatible((1u16, 0u16)) {
638 start + u16::RAW_BYTE_LEN
639 } else {
640 start
641 };
642 start..end
643 }
644}
645
646const _: () = assert!(FontData::default_data_long_enough(MaxpExtended::MIN_SIZE));
647
648impl Default for MaxpExtended<'_> {
649 fn default() -> Self {
650 Self {
651 data: TableDataRef::new(FontData::default_table_data().as_bytes())
652 .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
653 }
654 }
655}