read_fonts/generated/
generated_trak.rs1#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8#[derive(Debug, Clone, Copy)]
10#[doc(hidden)]
11pub struct TrakMarker {}
12
13impl TrakMarker {
14 pub fn version_byte_range(&self) -> Range<usize> {
15 let start = 0;
16 start..start + MajorMinor::RAW_BYTE_LEN
17 }
18
19 pub fn format_byte_range(&self) -> Range<usize> {
20 let start = self.version_byte_range().end;
21 start..start + u16::RAW_BYTE_LEN
22 }
23
24 pub fn horiz_offset_byte_range(&self) -> Range<usize> {
25 let start = self.format_byte_range().end;
26 start..start + Offset16::RAW_BYTE_LEN
27 }
28
29 pub fn vert_offset_byte_range(&self) -> Range<usize> {
30 let start = self.horiz_offset_byte_range().end;
31 start..start + Offset16::RAW_BYTE_LEN
32 }
33
34 pub fn reserved_byte_range(&self) -> Range<usize> {
35 let start = self.vert_offset_byte_range().end;
36 start..start + u16::RAW_BYTE_LEN
37 }
38}
39
40impl MinByteRange for TrakMarker {
41 fn min_byte_range(&self) -> Range<usize> {
42 0..self.reserved_byte_range().end
43 }
44}
45
46impl TopLevelTable for Trak<'_> {
47 const TAG: Tag = Tag::new(b"trak");
49}
50
51impl<'a> FontRead<'a> for Trak<'a> {
52 fn read(data: FontData<'a>) -> Result<Self, ReadError> {
53 let mut cursor = data.cursor();
54 cursor.advance::<MajorMinor>();
55 cursor.advance::<u16>();
56 cursor.advance::<Offset16>();
57 cursor.advance::<Offset16>();
58 cursor.advance::<u16>();
59 cursor.finish(TrakMarker {})
60 }
61}
62
63pub type Trak<'a> = TableRef<'a, TrakMarker>;
65
66#[allow(clippy::needless_lifetimes)]
67impl<'a> Trak<'a> {
68 pub fn version(&self) -> MajorMinor {
70 let range = self.shape.version_byte_range();
71 self.data.read_at(range.start).unwrap()
72 }
73
74 pub fn format(&self) -> u16 {
76 let range = self.shape.format_byte_range();
77 self.data.read_at(range.start).unwrap()
78 }
79
80 pub fn horiz_offset(&self) -> Nullable<Offset16> {
82 let range = self.shape.horiz_offset_byte_range();
83 self.data.read_at(range.start).unwrap()
84 }
85
86 pub fn horiz(&self) -> Option<Result<TrackData<'a>, ReadError>> {
88 let data = self.data;
89 self.horiz_offset().resolve(data)
90 }
91
92 pub fn vert_offset(&self) -> Nullable<Offset16> {
94 let range = self.shape.vert_offset_byte_range();
95 self.data.read_at(range.start).unwrap()
96 }
97
98 pub fn vert(&self) -> Option<Result<TrackData<'a>, ReadError>> {
100 let data = self.data;
101 self.vert_offset().resolve(data)
102 }
103}
104
105#[cfg(feature = "experimental_traverse")]
106impl<'a> SomeTable<'a> for Trak<'a> {
107 fn type_name(&self) -> &str {
108 "Trak"
109 }
110 fn get_field(&self, idx: usize) -> Option<Field<'a>> {
111 match idx {
112 0usize => Some(Field::new("version", self.version())),
113 1usize => Some(Field::new("format", self.format())),
114 2usize => Some(Field::new(
115 "horiz_offset",
116 FieldType::offset(self.horiz_offset(), self.horiz()),
117 )),
118 3usize => Some(Field::new(
119 "vert_offset",
120 FieldType::offset(self.vert_offset(), self.vert()),
121 )),
122 _ => None,
123 }
124 }
125}
126
127#[cfg(feature = "experimental_traverse")]
128#[allow(clippy::needless_lifetimes)]
129impl<'a> std::fmt::Debug for Trak<'a> {
130 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
131 (self as &dyn SomeTable<'a>).fmt(f)
132 }
133}
134
135#[derive(Debug, Clone, Copy)]
137#[doc(hidden)]
138pub struct TrackDataMarker {
139 track_table_byte_len: usize,
140}
141
142impl TrackDataMarker {
143 pub fn n_tracks_byte_range(&self) -> Range<usize> {
144 let start = 0;
145 start..start + u16::RAW_BYTE_LEN
146 }
147
148 pub fn n_sizes_byte_range(&self) -> Range<usize> {
149 let start = self.n_tracks_byte_range().end;
150 start..start + u16::RAW_BYTE_LEN
151 }
152
153 pub fn size_table_offset_byte_range(&self) -> Range<usize> {
154 let start = self.n_sizes_byte_range().end;
155 start..start + u32::RAW_BYTE_LEN
156 }
157
158 pub fn track_table_byte_range(&self) -> Range<usize> {
159 let start = self.size_table_offset_byte_range().end;
160 start..start + self.track_table_byte_len
161 }
162}
163
164impl MinByteRange for TrackDataMarker {
165 fn min_byte_range(&self) -> Range<usize> {
166 0..self.track_table_byte_range().end
167 }
168}
169
170impl<'a> FontRead<'a> for TrackData<'a> {
171 fn read(data: FontData<'a>) -> Result<Self, ReadError> {
172 let mut cursor = data.cursor();
173 let n_tracks: u16 = cursor.read()?;
174 cursor.advance::<u16>();
175 cursor.advance::<u32>();
176 let track_table_byte_len = (n_tracks as usize)
177 .checked_mul(TrackTableEntry::RAW_BYTE_LEN)
178 .ok_or(ReadError::OutOfBounds)?;
179 cursor.advance_by(track_table_byte_len);
180 cursor.finish(TrackDataMarker {
181 track_table_byte_len,
182 })
183 }
184}
185
186pub type TrackData<'a> = TableRef<'a, TrackDataMarker>;
188
189#[allow(clippy::needless_lifetimes)]
190impl<'a> TrackData<'a> {
191 pub fn n_tracks(&self) -> u16 {
193 let range = self.shape.n_tracks_byte_range();
194 self.data.read_at(range.start).unwrap()
195 }
196
197 pub fn n_sizes(&self) -> u16 {
199 let range = self.shape.n_sizes_byte_range();
200 self.data.read_at(range.start).unwrap()
201 }
202
203 pub fn size_table_offset(&self) -> u32 {
205 let range = self.shape.size_table_offset_byte_range();
206 self.data.read_at(range.start).unwrap()
207 }
208
209 pub fn track_table(&self) -> &'a [TrackTableEntry] {
211 let range = self.shape.track_table_byte_range();
212 self.data.read_array(range).unwrap()
213 }
214}
215
216#[cfg(feature = "experimental_traverse")]
217impl<'a> SomeTable<'a> for TrackData<'a> {
218 fn type_name(&self) -> &str {
219 "TrackData"
220 }
221 fn get_field(&self, idx: usize) -> Option<Field<'a>> {
222 match idx {
223 0usize => Some(Field::new("n_tracks", self.n_tracks())),
224 1usize => Some(Field::new("n_sizes", self.n_sizes())),
225 2usize => Some(Field::new("size_table_offset", self.size_table_offset())),
226 3usize => Some(Field::new(
227 "track_table",
228 traversal::FieldType::array_of_records(
229 stringify!(TrackTableEntry),
230 self.track_table(),
231 self.offset_data(),
232 ),
233 )),
234 _ => None,
235 }
236 }
237}
238
239#[cfg(feature = "experimental_traverse")]
240#[allow(clippy::needless_lifetimes)]
241impl<'a> std::fmt::Debug for TrackData<'a> {
242 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
243 (self as &dyn SomeTable<'a>).fmt(f)
244 }
245}
246
247#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
249#[repr(C)]
250#[repr(packed)]
251pub struct TrackTableEntry {
252 pub track: BigEndian<Fixed>,
254 pub name_index: BigEndian<NameId>,
256 pub offset: BigEndian<u16>,
258}
259
260impl TrackTableEntry {
261 pub fn track(&self) -> Fixed {
263 self.track.get()
264 }
265
266 pub fn name_index(&self) -> NameId {
268 self.name_index.get()
269 }
270
271 pub fn offset(&self) -> u16 {
273 self.offset.get()
274 }
275}
276
277impl FixedSize for TrackTableEntry {
278 const RAW_BYTE_LEN: usize = Fixed::RAW_BYTE_LEN + NameId::RAW_BYTE_LEN + u16::RAW_BYTE_LEN;
279}
280
281#[cfg(feature = "experimental_traverse")]
282impl<'a> SomeRecord<'a> for TrackTableEntry {
283 fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
284 RecordResolver {
285 name: "TrackTableEntry",
286 get_field: Box::new(move |idx, _data| match idx {
287 0usize => Some(Field::new("track", self.track())),
288 1usize => Some(Field::new("name_index", self.name_index())),
289 2usize => Some(Field::new("offset", self.offset())),
290 _ => None,
291 }),
292 data,
293 }
294 }
295}