read_fonts/generated/
generated_hvar.rs1#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8#[derive(Debug, Clone, Copy)]
10#[doc(hidden)]
11pub struct HvarMarker {}
12
13impl HvarMarker {
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 item_variation_store_offset_byte_range(&self) -> Range<usize> {
20 let start = self.version_byte_range().end;
21 start..start + Offset32::RAW_BYTE_LEN
22 }
23
24 pub fn advance_width_mapping_offset_byte_range(&self) -> Range<usize> {
25 let start = self.item_variation_store_offset_byte_range().end;
26 start..start + Offset32::RAW_BYTE_LEN
27 }
28
29 pub fn lsb_mapping_offset_byte_range(&self) -> Range<usize> {
30 let start = self.advance_width_mapping_offset_byte_range().end;
31 start..start + Offset32::RAW_BYTE_LEN
32 }
33
34 pub fn rsb_mapping_offset_byte_range(&self) -> Range<usize> {
35 let start = self.lsb_mapping_offset_byte_range().end;
36 start..start + Offset32::RAW_BYTE_LEN
37 }
38}
39
40impl MinByteRange for HvarMarker {
41 fn min_byte_range(&self) -> Range<usize> {
42 0..self.rsb_mapping_offset_byte_range().end
43 }
44}
45
46impl TopLevelTable for Hvar<'_> {
47 const TAG: Tag = Tag::new(b"HVAR");
49}
50
51impl<'a> FontRead<'a> for Hvar<'a> {
52 fn read(data: FontData<'a>) -> Result<Self, ReadError> {
53 let mut cursor = data.cursor();
54 cursor.advance::<MajorMinor>();
55 cursor.advance::<Offset32>();
56 cursor.advance::<Offset32>();
57 cursor.advance::<Offset32>();
58 cursor.advance::<Offset32>();
59 cursor.finish(HvarMarker {})
60 }
61}
62
63pub type Hvar<'a> = TableRef<'a, HvarMarker>;
65
66#[allow(clippy::needless_lifetimes)]
67impl<'a> Hvar<'a> {
68 pub fn version(&self) -> MajorMinor {
71 let range = self.shape.version_byte_range();
72 self.data.read_at(range.start).unwrap()
73 }
74
75 pub fn item_variation_store_offset(&self) -> Offset32 {
77 let range = self.shape.item_variation_store_offset_byte_range();
78 self.data.read_at(range.start).unwrap()
79 }
80
81 pub fn item_variation_store(&self) -> Result<ItemVariationStore<'a>, ReadError> {
83 let data = self.data;
84 self.item_variation_store_offset().resolve(data)
85 }
86
87 pub fn advance_width_mapping_offset(&self) -> Nullable<Offset32> {
89 let range = self.shape.advance_width_mapping_offset_byte_range();
90 self.data.read_at(range.start).unwrap()
91 }
92
93 pub fn advance_width_mapping(&self) -> Option<Result<DeltaSetIndexMap<'a>, ReadError>> {
95 let data = self.data;
96 self.advance_width_mapping_offset().resolve(data)
97 }
98
99 pub fn lsb_mapping_offset(&self) -> Nullable<Offset32> {
101 let range = self.shape.lsb_mapping_offset_byte_range();
102 self.data.read_at(range.start).unwrap()
103 }
104
105 pub fn lsb_mapping(&self) -> Option<Result<DeltaSetIndexMap<'a>, ReadError>> {
107 let data = self.data;
108 self.lsb_mapping_offset().resolve(data)
109 }
110
111 pub fn rsb_mapping_offset(&self) -> Nullable<Offset32> {
113 let range = self.shape.rsb_mapping_offset_byte_range();
114 self.data.read_at(range.start).unwrap()
115 }
116
117 pub fn rsb_mapping(&self) -> Option<Result<DeltaSetIndexMap<'a>, ReadError>> {
119 let data = self.data;
120 self.rsb_mapping_offset().resolve(data)
121 }
122}
123
124#[cfg(feature = "experimental_traverse")]
125impl<'a> SomeTable<'a> for Hvar<'a> {
126 fn type_name(&self) -> &str {
127 "Hvar"
128 }
129 fn get_field(&self, idx: usize) -> Option<Field<'a>> {
130 match idx {
131 0usize => Some(Field::new("version", self.version())),
132 1usize => Some(Field::new(
133 "item_variation_store_offset",
134 FieldType::offset(
135 self.item_variation_store_offset(),
136 self.item_variation_store(),
137 ),
138 )),
139 2usize => Some(Field::new(
140 "advance_width_mapping_offset",
141 FieldType::offset(
142 self.advance_width_mapping_offset(),
143 self.advance_width_mapping(),
144 ),
145 )),
146 3usize => Some(Field::new(
147 "lsb_mapping_offset",
148 FieldType::offset(self.lsb_mapping_offset(), self.lsb_mapping()),
149 )),
150 4usize => Some(Field::new(
151 "rsb_mapping_offset",
152 FieldType::offset(self.rsb_mapping_offset(), self.rsb_mapping()),
153 )),
154 _ => None,
155 }
156 }
157}
158
159#[cfg(feature = "experimental_traverse")]
160#[allow(clippy::needless_lifetimes)]
161impl<'a> std::fmt::Debug for Hvar<'a> {
162 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
163 (self as &dyn SomeTable<'a>).fmt(f)
164 }
165}