read_fonts/generated/
generated_cvar.rs1#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8#[derive(Debug, Clone, Copy)]
10#[doc(hidden)]
11pub struct CvarMarker {
12 tuple_variation_headers_byte_len: usize,
13}
14
15impl CvarMarker {
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 tuple_variation_count_byte_range(&self) -> Range<usize> {
22 let start = self.version_byte_range().end;
23 start..start + TupleVariationCount::RAW_BYTE_LEN
24 }
25
26 pub fn data_offset_byte_range(&self) -> Range<usize> {
27 let start = self.tuple_variation_count_byte_range().end;
28 start..start + Offset16::RAW_BYTE_LEN
29 }
30
31 pub fn tuple_variation_headers_byte_range(&self) -> Range<usize> {
32 let start = self.data_offset_byte_range().end;
33 start..start + self.tuple_variation_headers_byte_len
34 }
35}
36
37impl MinByteRange for CvarMarker {
38 fn min_byte_range(&self) -> Range<usize> {
39 0..self.tuple_variation_headers_byte_range().end
40 }
41}
42
43impl TopLevelTable for Cvar<'_> {
44 const TAG: Tag = Tag::new(b"cvar");
46}
47
48impl<'a> FontRead<'a> for Cvar<'a> {
49 fn read(data: FontData<'a>) -> Result<Self, ReadError> {
50 let mut cursor = data.cursor();
51 cursor.advance::<MajorMinor>();
52 cursor.advance::<TupleVariationCount>();
53 cursor.advance::<Offset16>();
54 let tuple_variation_headers_byte_len = cursor.remaining_bytes();
55 cursor.advance_by(tuple_variation_headers_byte_len);
56 cursor.finish(CvarMarker {
57 tuple_variation_headers_byte_len,
58 })
59 }
60}
61
62pub type Cvar<'a> = TableRef<'a, CvarMarker>;
64
65#[allow(clippy::needless_lifetimes)]
66impl<'a> Cvar<'a> {
67 pub fn version(&self) -> MajorMinor {
69 let range = self.shape.version_byte_range();
70 self.data.read_at(range.start).unwrap()
71 }
72
73 pub fn tuple_variation_count(&self) -> TupleVariationCount {
78 let range = self.shape.tuple_variation_count_byte_range();
79 self.data.read_at(range.start).unwrap()
80 }
81
82 pub fn data_offset(&self) -> Offset16 {
84 let range = self.shape.data_offset_byte_range();
85 self.data.read_at(range.start).unwrap()
86 }
87
88 pub fn data(&self) -> Result<FontData<'a>, ReadError> {
90 let data = self.data;
91 self.data_offset().resolve(data)
92 }
93
94 pub fn tuple_variation_headers(&self) -> VarLenArray<'a, TupleVariationHeader> {
96 let range = self.shape.tuple_variation_headers_byte_range();
97 VarLenArray::read(self.data.split_off(range.start).unwrap()).unwrap()
98 }
99}
100
101#[cfg(feature = "experimental_traverse")]
102impl<'a> SomeTable<'a> for Cvar<'a> {
103 fn type_name(&self) -> &str {
104 "Cvar"
105 }
106 fn get_field(&self, idx: usize) -> Option<Field<'a>> {
107 match idx {
108 0usize => Some(Field::new("version", self.version())),
109 1usize => Some(Field::new(
110 "tuple_variation_count",
111 traversal::FieldType::Unknown,
112 )),
113 2usize => Some(Field::new("data_offset", traversal::FieldType::Unknown)),
114 3usize => Some(Field::new(
115 "tuple_variation_headers",
116 traversal::FieldType::Unknown,
117 )),
118 _ => None,
119 }
120 }
121}
122
123#[cfg(feature = "experimental_traverse")]
124#[allow(clippy::needless_lifetimes)]
125impl<'a> std::fmt::Debug for Cvar<'a> {
126 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
127 (self as &dyn SomeTable<'a>).fmt(f)
128 }
129}