read_fonts/generated/
generated_cff.rs1#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8#[derive(Debug, Clone, Copy)]
10#[doc(hidden)]
11pub struct CffHeaderMarker {
12 _padding_byte_len: usize,
13 trailing_data_byte_len: usize,
14}
15
16impl CffHeaderMarker {
17 pub fn major_byte_range(&self) -> Range<usize> {
18 let start = 0;
19 start..start + u8::RAW_BYTE_LEN
20 }
21
22 pub fn minor_byte_range(&self) -> Range<usize> {
23 let start = self.major_byte_range().end;
24 start..start + u8::RAW_BYTE_LEN
25 }
26
27 pub fn hdr_size_byte_range(&self) -> Range<usize> {
28 let start = self.minor_byte_range().end;
29 start..start + u8::RAW_BYTE_LEN
30 }
31
32 pub fn off_size_byte_range(&self) -> Range<usize> {
33 let start = self.hdr_size_byte_range().end;
34 start..start + u8::RAW_BYTE_LEN
35 }
36
37 pub fn _padding_byte_range(&self) -> Range<usize> {
38 let start = self.off_size_byte_range().end;
39 start..start + self._padding_byte_len
40 }
41
42 pub fn trailing_data_byte_range(&self) -> Range<usize> {
43 let start = self._padding_byte_range().end;
44 start..start + self.trailing_data_byte_len
45 }
46}
47
48impl MinByteRange for CffHeaderMarker {
49 fn min_byte_range(&self) -> Range<usize> {
50 0..self.trailing_data_byte_range().end
51 }
52}
53
54impl<'a> FontRead<'a> for CffHeader<'a> {
55 fn read(data: FontData<'a>) -> Result<Self, ReadError> {
56 let mut cursor = data.cursor();
57 cursor.advance::<u8>();
58 cursor.advance::<u8>();
59 let hdr_size: u8 = cursor.read()?;
60 cursor.advance::<u8>();
61 let _padding_byte_len = (transforms::subtract(hdr_size, 4_usize))
62 .checked_mul(u8::RAW_BYTE_LEN)
63 .ok_or(ReadError::OutOfBounds)?;
64 cursor.advance_by(_padding_byte_len);
65 let trailing_data_byte_len = cursor.remaining_bytes() / u8::RAW_BYTE_LEN * u8::RAW_BYTE_LEN;
66 cursor.advance_by(trailing_data_byte_len);
67 cursor.finish(CffHeaderMarker {
68 _padding_byte_len,
69 trailing_data_byte_len,
70 })
71 }
72}
73
74pub type CffHeader<'a> = TableRef<'a, CffHeaderMarker>;
76
77#[allow(clippy::needless_lifetimes)]
78impl<'a> CffHeader<'a> {
79 pub fn major(&self) -> u8 {
81 let range = self.shape.major_byte_range();
82 self.data.read_at(range.start).unwrap()
83 }
84
85 pub fn minor(&self) -> u8 {
87 let range = self.shape.minor_byte_range();
88 self.data.read_at(range.start).unwrap()
89 }
90
91 pub fn hdr_size(&self) -> u8 {
93 let range = self.shape.hdr_size_byte_range();
94 self.data.read_at(range.start).unwrap()
95 }
96
97 pub fn off_size(&self) -> u8 {
99 let range = self.shape.off_size_byte_range();
100 self.data.read_at(range.start).unwrap()
101 }
102
103 pub fn _padding(&self) -> &'a [u8] {
105 let range = self.shape._padding_byte_range();
106 self.data.read_array(range).unwrap()
107 }
108
109 pub fn trailing_data(&self) -> &'a [u8] {
111 let range = self.shape.trailing_data_byte_range();
112 self.data.read_array(range).unwrap()
113 }
114}
115
116#[cfg(feature = "experimental_traverse")]
117impl<'a> SomeTable<'a> for CffHeader<'a> {
118 fn type_name(&self) -> &str {
119 "CffHeader"
120 }
121 fn get_field(&self, idx: usize) -> Option<Field<'a>> {
122 match idx {
123 0usize => Some(Field::new("major", self.major())),
124 1usize => Some(Field::new("minor", self.minor())),
125 2usize => Some(Field::new("hdr_size", self.hdr_size())),
126 3usize => Some(Field::new("off_size", self.off_size())),
127 4usize => Some(Field::new("_padding", self._padding())),
128 5usize => Some(Field::new("trailing_data", self.trailing_data())),
129 _ => None,
130 }
131 }
132}
133
134#[cfg(feature = "experimental_traverse")]
135#[allow(clippy::needless_lifetimes)]
136impl<'a> std::fmt::Debug for CffHeader<'a> {
137 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
138 (self as &dyn SomeTable<'a>).fmt(f)
139 }
140}