read_fonts/generated/
generated_mvar.rs1#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8#[derive(Debug, Clone, Copy)]
10#[doc(hidden)]
11pub struct MvarMarker {
12 value_records_byte_len: usize,
13}
14
15impl MvarMarker {
16 pub fn version_byte_range(&self) -> Range<usize> {
17 let start = 0;
18 start..start + MajorMinor::RAW_BYTE_LEN
19 }
20
21 pub fn _reserved_byte_range(&self) -> Range<usize> {
22 let start = self.version_byte_range().end;
23 start..start + u16::RAW_BYTE_LEN
24 }
25
26 pub fn value_record_size_byte_range(&self) -> Range<usize> {
27 let start = self._reserved_byte_range().end;
28 start..start + u16::RAW_BYTE_LEN
29 }
30
31 pub fn value_record_count_byte_range(&self) -> Range<usize> {
32 let start = self.value_record_size_byte_range().end;
33 start..start + u16::RAW_BYTE_LEN
34 }
35
36 pub fn item_variation_store_offset_byte_range(&self) -> Range<usize> {
37 let start = self.value_record_count_byte_range().end;
38 start..start + Offset16::RAW_BYTE_LEN
39 }
40
41 pub fn value_records_byte_range(&self) -> Range<usize> {
42 let start = self.item_variation_store_offset_byte_range().end;
43 start..start + self.value_records_byte_len
44 }
45}
46
47impl MinByteRange for MvarMarker {
48 fn min_byte_range(&self) -> Range<usize> {
49 0..self.value_records_byte_range().end
50 }
51}
52
53impl TopLevelTable for Mvar<'_> {
54 const TAG: Tag = Tag::new(b"MVAR");
56}
57
58impl<'a> FontRead<'a> for Mvar<'a> {
59 fn read(data: FontData<'a>) -> Result<Self, ReadError> {
60 let mut cursor = data.cursor();
61 cursor.advance::<MajorMinor>();
62 cursor.advance::<u16>();
63 cursor.advance::<u16>();
64 let value_record_count: u16 = cursor.read()?;
65 cursor.advance::<Offset16>();
66 let value_records_byte_len = (value_record_count as usize)
67 .checked_mul(ValueRecord::RAW_BYTE_LEN)
68 .ok_or(ReadError::OutOfBounds)?;
69 cursor.advance_by(value_records_byte_len);
70 cursor.finish(MvarMarker {
71 value_records_byte_len,
72 })
73 }
74}
75
76pub type Mvar<'a> = TableRef<'a, MvarMarker>;
78
79#[allow(clippy::needless_lifetimes)]
80impl<'a> Mvar<'a> {
81 pub fn version(&self) -> MajorMinor {
84 let range = self.shape.version_byte_range();
85 self.data.read_at(range.start).unwrap()
86 }
87
88 pub fn value_record_size(&self) -> u16 {
90 let range = self.shape.value_record_size_byte_range();
91 self.data.read_at(range.start).unwrap()
92 }
93
94 pub fn value_record_count(&self) -> u16 {
96 let range = self.shape.value_record_count_byte_range();
97 self.data.read_at(range.start).unwrap()
98 }
99
100 pub fn item_variation_store_offset(&self) -> Nullable<Offset16> {
102 let range = self.shape.item_variation_store_offset_byte_range();
103 self.data.read_at(range.start).unwrap()
104 }
105
106 pub fn item_variation_store(&self) -> Option<Result<ItemVariationStore<'a>, ReadError>> {
108 let data = self.data;
109 self.item_variation_store_offset().resolve(data)
110 }
111
112 pub fn value_records(&self) -> &'a [ValueRecord] {
114 let range = self.shape.value_records_byte_range();
115 self.data.read_array(range).unwrap()
116 }
117}
118
119#[cfg(feature = "experimental_traverse")]
120impl<'a> SomeTable<'a> for Mvar<'a> {
121 fn type_name(&self) -> &str {
122 "Mvar"
123 }
124 fn get_field(&self, idx: usize) -> Option<Field<'a>> {
125 match idx {
126 0usize => Some(Field::new("version", self.version())),
127 1usize => Some(Field::new("value_record_size", self.value_record_size())),
128 2usize => Some(Field::new("value_record_count", self.value_record_count())),
129 3usize => Some(Field::new(
130 "item_variation_store_offset",
131 FieldType::offset(
132 self.item_variation_store_offset(),
133 self.item_variation_store(),
134 ),
135 )),
136 4usize => Some(Field::new(
137 "value_records",
138 traversal::FieldType::array_of_records(
139 stringify!(ValueRecord),
140 self.value_records(),
141 self.offset_data(),
142 ),
143 )),
144 _ => None,
145 }
146 }
147}
148
149#[cfg(feature = "experimental_traverse")]
150#[allow(clippy::needless_lifetimes)]
151impl<'a> std::fmt::Debug for Mvar<'a> {
152 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
153 (self as &dyn SomeTable<'a>).fmt(f)
154 }
155}
156
157#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
159#[repr(C)]
160#[repr(packed)]
161pub struct ValueRecord {
162 pub value_tag: BigEndian<Tag>,
164 pub delta_set_outer_index: BigEndian<u16>,
166 pub delta_set_inner_index: BigEndian<u16>,
168}
169
170impl ValueRecord {
171 pub fn value_tag(&self) -> Tag {
173 self.value_tag.get()
174 }
175
176 pub fn delta_set_outer_index(&self) -> u16 {
178 self.delta_set_outer_index.get()
179 }
180
181 pub fn delta_set_inner_index(&self) -> u16 {
183 self.delta_set_inner_index.get()
184 }
185}
186
187impl FixedSize for ValueRecord {
188 const RAW_BYTE_LEN: usize = Tag::RAW_BYTE_LEN + u16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN;
189}
190
191#[cfg(feature = "experimental_traverse")]
192impl<'a> SomeRecord<'a> for ValueRecord {
193 fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
194 RecordResolver {
195 name: "ValueRecord",
196 get_field: Box::new(move |idx, _data| match idx {
197 0usize => Some(Field::new("value_tag", self.value_tag())),
198 1usize => Some(Field::new(
199 "delta_set_outer_index",
200 self.delta_set_outer_index(),
201 )),
202 2usize => Some(Field::new(
203 "delta_set_inner_index",
204 self.delta_set_inner_index(),
205 )),
206 _ => None,
207 }),
208 data,
209 }
210 }
211}