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.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 Ok(Self { data })
34 }
35}
36
37#[derive(Clone)]
39pub struct Vhea<'a> {
40 data: FontData<'a>,
41}
42
43#[allow(clippy::needless_lifetimes)]
44impl<'a> Vhea<'a> {
45 pub const MIN_SIZE: usize = (Version16Dot16::RAW_BYTE_LEN
46 + FWord::RAW_BYTE_LEN
47 + FWord::RAW_BYTE_LEN
48 + FWord::RAW_BYTE_LEN
49 + UfWord::RAW_BYTE_LEN
50 + FWord::RAW_BYTE_LEN
51 + FWord::RAW_BYTE_LEN
52 + FWord::RAW_BYTE_LEN
53 + i16::RAW_BYTE_LEN
54 + i16::RAW_BYTE_LEN
55 + i16::RAW_BYTE_LEN
56 + i16::RAW_BYTE_LEN
57 + i16::RAW_BYTE_LEN
58 + i16::RAW_BYTE_LEN
59 + i16::RAW_BYTE_LEN
60 + i16::RAW_BYTE_LEN
61 + u16::RAW_BYTE_LEN);
62 basic_table_impls!(impl_the_methods);
63
64 pub fn version(&self) -> Version16Dot16 {
66 let range = self.version_byte_range();
67 self.data.read_at(range.start).ok().unwrap()
68 }
69
70 pub fn ascender(&self) -> FWord {
72 let range = self.ascender_byte_range();
73 self.data.read_at(range.start).ok().unwrap()
74 }
75
76 pub fn descender(&self) -> FWord {
78 let range = self.descender_byte_range();
79 self.data.read_at(range.start).ok().unwrap()
80 }
81
82 pub fn line_gap(&self) -> FWord {
85 let range = self.line_gap_byte_range();
86 self.data.read_at(range.start).ok().unwrap()
87 }
88
89 pub fn advance_height_max(&self) -> UfWord {
91 let range = self.advance_height_max_byte_range();
92 self.data.read_at(range.start).ok().unwrap()
93 }
94
95 pub fn min_top_side_bearing(&self) -> FWord {
98 let range = self.min_top_side_bearing_byte_range();
99 self.data.read_at(range.start).ok().unwrap()
100 }
101
102 pub fn min_bottom_side_bearing(&self) -> FWord {
104 let range = self.min_bottom_side_bearing_byte_range();
105 self.data.read_at(range.start).ok().unwrap()
106 }
107
108 pub fn y_max_extent(&self) -> FWord {
110 let range = self.y_max_extent_byte_range();
111 self.data.read_at(range.start).ok().unwrap()
112 }
113
114 pub fn caret_slope_rise(&self) -> i16 {
117 let range = self.caret_slope_rise_byte_range();
118 self.data.read_at(range.start).ok().unwrap()
119 }
120
121 pub fn caret_slope_run(&self) -> i16 {
123 let range = self.caret_slope_run_byte_range();
124 self.data.read_at(range.start).ok().unwrap()
125 }
126
127 pub fn caret_offset(&self) -> i16 {
131 let range = self.caret_offset_byte_range();
132 self.data.read_at(range.start).ok().unwrap()
133 }
134
135 pub fn metric_data_format(&self) -> i16 {
137 let range = self.metric_data_format_byte_range();
138 self.data.read_at(range.start).ok().unwrap()
139 }
140
141 pub fn number_of_long_ver_metrics(&self) -> u16 {
143 let range = self.number_of_long_ver_metrics_byte_range();
144 self.data.read_at(range.start).ok().unwrap()
145 }
146
147 pub fn version_byte_range(&self) -> Range<usize> {
148 let start = 0;
149 let end = start + Version16Dot16::RAW_BYTE_LEN;
150 start..end
151 }
152
153 pub fn ascender_byte_range(&self) -> Range<usize> {
154 let start = self.version_byte_range().end;
155 let end = start + FWord::RAW_BYTE_LEN;
156 start..end
157 }
158
159 pub fn descender_byte_range(&self) -> Range<usize> {
160 let start = self.ascender_byte_range().end;
161 let end = start + FWord::RAW_BYTE_LEN;
162 start..end
163 }
164
165 pub fn line_gap_byte_range(&self) -> Range<usize> {
166 let start = self.descender_byte_range().end;
167 let end = start + FWord::RAW_BYTE_LEN;
168 start..end
169 }
170
171 pub fn advance_height_max_byte_range(&self) -> Range<usize> {
172 let start = self.line_gap_byte_range().end;
173 let end = start + UfWord::RAW_BYTE_LEN;
174 start..end
175 }
176
177 pub fn min_top_side_bearing_byte_range(&self) -> Range<usize> {
178 let start = self.advance_height_max_byte_range().end;
179 let end = start + FWord::RAW_BYTE_LEN;
180 start..end
181 }
182
183 pub fn min_bottom_side_bearing_byte_range(&self) -> Range<usize> {
184 let start = self.min_top_side_bearing_byte_range().end;
185 let end = start + FWord::RAW_BYTE_LEN;
186 start..end
187 }
188
189 pub fn y_max_extent_byte_range(&self) -> Range<usize> {
190 let start = self.min_bottom_side_bearing_byte_range().end;
191 let end = start + FWord::RAW_BYTE_LEN;
192 start..end
193 }
194
195 pub fn caret_slope_rise_byte_range(&self) -> Range<usize> {
196 let start = self.y_max_extent_byte_range().end;
197 let end = start + i16::RAW_BYTE_LEN;
198 start..end
199 }
200
201 pub fn caret_slope_run_byte_range(&self) -> Range<usize> {
202 let start = self.caret_slope_rise_byte_range().end;
203 let end = start + i16::RAW_BYTE_LEN;
204 start..end
205 }
206
207 pub fn caret_offset_byte_range(&self) -> Range<usize> {
208 let start = self.caret_slope_run_byte_range().end;
209 let end = start + i16::RAW_BYTE_LEN;
210 start..end
211 }
212
213 pub fn reserved1_byte_range(&self) -> Range<usize> {
214 let start = self.caret_offset_byte_range().end;
215 let end = start + i16::RAW_BYTE_LEN;
216 start..end
217 }
218
219 pub fn reserved2_byte_range(&self) -> Range<usize> {
220 let start = self.reserved1_byte_range().end;
221 let end = start + i16::RAW_BYTE_LEN;
222 start..end
223 }
224
225 pub fn reserved3_byte_range(&self) -> Range<usize> {
226 let start = self.reserved2_byte_range().end;
227 let end = start + i16::RAW_BYTE_LEN;
228 start..end
229 }
230
231 pub fn reserved4_byte_range(&self) -> Range<usize> {
232 let start = self.reserved3_byte_range().end;
233 let end = start + i16::RAW_BYTE_LEN;
234 start..end
235 }
236
237 pub fn metric_data_format_byte_range(&self) -> Range<usize> {
238 let start = self.reserved4_byte_range().end;
239 let end = start + i16::RAW_BYTE_LEN;
240 start..end
241 }
242
243 pub fn number_of_long_ver_metrics_byte_range(&self) -> Range<usize> {
244 let start = self.metric_data_format_byte_range().end;
245 let end = start + u16::RAW_BYTE_LEN;
246 start..end
247 }
248}
249
250const _: () = assert!(FontData::default_data_long_enough(Vhea::MIN_SIZE));
251
252impl Default for Vhea<'_> {
253 fn default() -> Self {
254 Self {
255 data: FontData::default_table_data(),
256 }
257 }
258}