/src/fontations/read-fonts/generated/generated_feat.rs

Source
// THIS FILE IS AUTOGENERATED.
// Any changes to this file will be overwritten.
// For more information about how codegen works, see font-codegen/README.md

#[allow(unused_imports)]
use crate::codegen_prelude::*;

/// The [feature name](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6feat.html) table.
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct FeatMarker {
    names_byte_len: usize,
}

impl FeatMarker {
    pub fn version_byte_range(&self) -> Range<usize> {
        let start = 0;
        start..start + MajorMinor::RAW_BYTE_LEN
    }

    pub fn feature_name_count_byte_range(&self) -> Range<usize> {
        let start = self.version_byte_range().end;
        start..start + u16::RAW_BYTE_LEN
    }

    pub fn _reserved1_byte_range(&self) -> Range<usize> {
        let start = self.feature_name_count_byte_range().end;
        start..start + u16::RAW_BYTE_LEN
    }

    pub fn _reserved2_byte_range(&self) -> Range<usize> {
        let start = self._reserved1_byte_range().end;
        start..start + u32::RAW_BYTE_LEN
    }

    pub fn names_byte_range(&self) -> Range<usize> {
        let start = self._reserved2_byte_range().end;
        start..start + self.names_byte_len
    }
}

impl MinByteRange for FeatMarker {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.names_byte_range().end
    }
}

impl TopLevelTable for Feat<'_> {
    /// `feat`
    const TAG: Tag = Tag::new(b"feat");
}

impl<'a> FontRead<'a> for Feat<'a> {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        let mut cursor = data.cursor();
        cursor.advance::<MajorMinor>();
        let feature_name_count: u16 = cursor.read()?;
        cursor.advance::<u16>();
        cursor.advance::<u32>();
        let names_byte_len = (feature_name_count as usize)
            .checked_mul(FeatureName::RAW_BYTE_LEN)
            .ok_or(ReadError::OutOfBounds)?;
        cursor.advance_by(names_byte_len);
        cursor.finish(FeatMarker { names_byte_len })
    }
}

/// The [feature name](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6feat.html) table.
pub type Feat<'a> = TableRef<'a, FeatMarker>;

#[allow(clippy::needless_lifetimes)]
impl<'a> Feat<'a> {
    /// Version number of the feature name table (0x00010000 for the current
    /// version).
    pub fn version(&self) -> MajorMinor {
        let range = self.shape.version_byte_range();
        self.data.read_at(range.start).unwrap()
    }

    /// The number of entries in the feature name array.
    pub fn feature_name_count(&self) -> u16 {
        let range = self.shape.feature_name_count_byte_range();
        self.data.read_at(range.start).unwrap()
    }

    /// The feature name array, sorted by feature type.
    pub fn names(&self) -> &'a [FeatureName] {
        let range = self.shape.names_byte_range();
        self.data.read_array(range).unwrap()
    }
}

#[cfg(feature = "experimental_traverse")]
impl<'a> SomeTable<'a> for Feat<'a> {
    fn type_name(&self) -> &str {
        "Feat"
    }
    fn get_field(&self, idx: usize) -> Option<Field<'a>> {
        match idx {
            0usize => Some(Field::new("version", self.version())),
            1usize => Some(Field::new("feature_name_count", self.feature_name_count())),
            2usize => Some(Field::new(
                "names",
                traversal::FieldType::array_of_records(
                    stringify!(FeatureName),
                    self.names(),
                    self.offset_data(),
                ),
            )),
            _ => None,
        }
    }
}

#[cfg(feature = "experimental_traverse")]
#[allow(clippy::needless_lifetimes)]
impl<'a> std::fmt::Debug for Feat<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        (self as &dyn SomeTable<'a>).fmt(f)
    }
}

/// Type, flags and names for a feature.
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct FeatureName {
    /// Feature type.
    pub feature: BigEndian<u16>,
    /// The number of records in the setting name array.
    pub n_settings: BigEndian<u16>,
    /// Offset in bytes from the beginning of this table to this feature's
    /// setting name array. The actual type of record this offset refers
    /// to will depend on the exclusivity value, as described below.
    pub setting_table_offset: BigEndian<Offset32>,
    /// Flags associated with the feature type.
    pub feature_flags: BigEndian<u16>,
    /// The name table index for the feature's name.
    pub name_index: BigEndian<NameId>,
}

impl FeatureName {
    /// Feature type.
    pub fn feature(&self) -> u16 {
        self.feature.get()
    }

    /// The number of records in the setting name array.
    pub fn n_settings(&self) -> u16 {
        self.n_settings.get()
    }

    /// Offset in bytes from the beginning of this table to this feature's
    /// setting name array. The actual type of record this offset refers
    /// to will depend on the exclusivity value, as described below.
    pub fn setting_table_offset(&self) -> Offset32 {
        self.setting_table_offset.get()
    }

    /// Offset in bytes from the beginning of this table to this feature's
    /// setting name array. The actual type of record this offset refers
    /// to will depend on the exclusivity value, as described below.
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn setting_table<'a>(&self, data: FontData<'a>) -> Result<SettingNameArray<'a>, ReadError> {
        let args = self.n_settings();
        self.setting_table_offset().resolve_with_args(data, &args)
    }

    /// Flags associated with the feature type.
    pub fn feature_flags(&self) -> u16 {
        self.feature_flags.get()
    }

    /// The name table index for the feature's name.
    pub fn name_index(&self) -> NameId {
        self.name_index.get()
    }
}

impl FixedSize for FeatureName {
    const RAW_BYTE_LEN: usize = u16::RAW_BYTE_LEN
        + u16::RAW_BYTE_LEN
        + Offset32::RAW_BYTE_LEN
        + u16::RAW_BYTE_LEN
        + NameId::RAW_BYTE_LEN;
}

#[cfg(feature = "experimental_traverse")]
impl<'a> SomeRecord<'a> for FeatureName {
    fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
        RecordResolver {
            name: "FeatureName",
            get_field: Box::new(move |idx, _data| match idx {
                0usize => Some(Field::new("feature", self.feature())),
                1usize => Some(Field::new("n_settings", self.n_settings())),
                2usize => Some(Field::new(
                    "setting_table_offset",
                    FieldType::offset(self.setting_table_offset(), self.setting_table(_data)),
                )),
                3usize => Some(Field::new("feature_flags", self.feature_flags())),
                4usize => Some(Field::new("name_index", self.name_index())),
                _ => None,
            }),
            data,
        }
    }
}

#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct SettingNameArrayMarker {
    settings_byte_len: usize,
}

impl SettingNameArrayMarker {
    pub fn settings_byte_range(&self) -> Range<usize> {
        let start = 0;
        start..start + self.settings_byte_len
    }
}

impl MinByteRange for SettingNameArrayMarker {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.settings_byte_range().end
    }
}

impl ReadArgs for SettingNameArray<'_> {
    type Args = u16;
}

impl<'a> FontReadWithArgs<'a> for SettingNameArray<'a> {
    fn read_with_args(data: FontData<'a>, args: &u16) -> Result<Self, ReadError> {
        let n_settings = *args;
        let mut cursor = data.cursor();
        let settings_byte_len = (n_settings as usize)
            .checked_mul(SettingName::RAW_BYTE_LEN)
            .ok_or(ReadError::OutOfBounds)?;
        cursor.advance_by(settings_byte_len);
        cursor.finish(SettingNameArrayMarker { settings_byte_len })
    }
}

impl<'a> SettingNameArray<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(data: FontData<'a>, n_settings: u16) -> Result<Self, ReadError> {
        let args = n_settings;
        Self::read_with_args(data, &args)
    }
}

pub type SettingNameArray<'a> = TableRef<'a, SettingNameArrayMarker>;

#[allow(clippy::needless_lifetimes)]
impl<'a> SettingNameArray<'a> {
    /// List of setting names for a feature.
    pub fn settings(&self) -> &'a [SettingName] {
        let range = self.shape.settings_byte_range();
        self.data.read_array(range).unwrap()
    }
}

#[cfg(feature = "experimental_traverse")]
impl<'a> SomeTable<'a> for SettingNameArray<'a> {
    fn type_name(&self) -> &str {
        "SettingNameArray"
    }
    fn get_field(&self, idx: usize) -> Option<Field<'a>> {
        match idx {
            0usize => Some(Field::new(
                "settings",
                traversal::FieldType::array_of_records(
                    stringify!(SettingName),
                    self.settings(),
                    self.offset_data(),
                ),
            )),
            _ => None,
        }
    }
}

#[cfg(feature = "experimental_traverse")]
#[allow(clippy::needless_lifetimes)]
impl<'a> std::fmt::Debug for SettingNameArray<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        (self as &dyn SomeTable<'a>).fmt(f)
    }
}

/// Associates a setting with a name identifier.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct SettingName {
    /// The setting.
    pub setting: BigEndian<u16>,
    /// The name table index for the setting's name.
    pub name_index: BigEndian<NameId>,
}

impl SettingName {
    /// The setting.
    pub fn setting(&self) -> u16 {
        self.setting.get()
    }

    /// The name table index for the setting's name.
    pub fn name_index(&self) -> NameId {
        self.name_index.get()
    }
}

impl FixedSize for SettingName {
    const RAW_BYTE_LEN: usize = u16::RAW_BYTE_LEN + NameId::RAW_BYTE_LEN;
}

#[cfg(feature = "experimental_traverse")]
impl<'a> SomeRecord<'a> for SettingName {
    fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
        RecordResolver {
            name: "SettingName",
            get_field: Box::new(move |idx, _data| match idx {
                0usize => Some(Field::new("setting", self.setting())),
                1usize => Some(Field::new("name_index", self.name_index())),
                _ => None,
            }),
            data,
        }
    }
}

Coverage Report

Created: 2025-12-31 07:38

Line	Count	Source
1		// THIS FILE IS AUTOGENERATED.
2		// Any changes to this file will be overwritten.
3		// For more information about how codegen works, see font-codegen/README.md
4
5		#[allow(unused_imports)]
6		use crate::codegen_prelude::*;
7
8		/// The [feature name](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6feat.html) table.
9		#[derive(Debug, Clone, Copy)]
10		#[doc(hidden)]
11		pub struct FeatMarker {
12		names_byte_len: usize,
13		}
14
15		impl FeatMarker {
16	0	pub fn version_byte_range(&self) -> Range<usize> {
17	0	let start = 0;
18	0	start..start + MajorMinor::RAW_BYTE_LEN
19	0	}
20
21	0	pub fn feature_name_count_byte_range(&self) -> Range<usize> {
22	0	let start = self.version_byte_range().end;
23	0	start..start + u16::RAW_BYTE_LEN
24	0	}
25
26	0	pub fn _reserved1_byte_range(&self) -> Range<usize> {
27	0	let start = self.feature_name_count_byte_range().end;
28	0	start..start + u16::RAW_BYTE_LEN
29	0	}
30
31	0	pub fn _reserved2_byte_range(&self) -> Range<usize> {
32	0	let start = self._reserved1_byte_range().end;
33	0	start..start + u32::RAW_BYTE_LEN
34	0	}
35
36	0	pub fn names_byte_range(&self) -> Range<usize> {
37	0	let start = self._reserved2_byte_range().end;
38	0	start..start + self.names_byte_len
39	0	}
40		}
41
42		impl MinByteRange for FeatMarker {
43	0	fn min_byte_range(&self) -> Range<usize> {
44	0	0..self.names_byte_range().end
45	0	}
46		}
47
48		impl TopLevelTable for Feat<'_> {
49		/// `feat`
50		const TAG: Tag = Tag::new(b"feat");
51		}
52
53		impl<'a> FontRead<'a> for Feat<'a> {
54	0	fn read(data: FontData<'a>) -> Result<Self, ReadError> {
55	0	let mut cursor = data.cursor();
56	0	cursor.advance::<MajorMinor>();
57	0	let feature_name_count: u16 = cursor.read()?;
58	0	cursor.advance::<u16>();
59	0	cursor.advance::<u32>();
60	0	let names_byte_len = (feature_name_count as usize)
61	0	.checked_mul(FeatureName::RAW_BYTE_LEN)
62	0	.ok_or(ReadError::OutOfBounds)?;
63	0	cursor.advance_by(names_byte_len);
64	0	cursor.finish(FeatMarker { names_byte_len })
65	0	}
66		}
67
68		/// The [feature name](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6feat.html) table.
69		pub type Feat<'a> = TableRef<'a, FeatMarker>;
70
71		#[allow(clippy::needless_lifetimes)]
72		impl<'a> Feat<'a> {
73		/// Version number of the feature name table (0x00010000 for the current
74		/// version).
75	0	pub fn version(&self) -> MajorMinor {
76	0	let range = self.shape.version_byte_range();
77	0	self.data.read_at(range.start).unwrap()
78	0	}
79
80		/// The number of entries in the feature name array.
81	0	pub fn feature_name_count(&self) -> u16 {
82	0	let range = self.shape.feature_name_count_byte_range();
83	0	self.data.read_at(range.start).unwrap()
84	0	}
85
86		/// The feature name array, sorted by feature type.
87	0	pub fn names(&self) -> &'a [FeatureName] {
88	0	let range = self.shape.names_byte_range();
89	0	self.data.read_array(range).unwrap()
90	0	}
91		}
92
93		#[cfg(feature = "experimental_traverse")]
94		impl<'a> SomeTable<'a> for Feat<'a> {
95		fn type_name(&self) -> &str {
96		"Feat"
97		}
98		fn get_field(&self, idx: usize) -> Option<Field<'a>> {
99		match idx {
100		0usize => Some(Field::new("version", self.version())),
101		1usize => Some(Field::new("feature_name_count", self.feature_name_count())),
102		2usize => Some(Field::new(
103		"names",
104		traversal::FieldType::array_of_records(
105		stringify!(FeatureName),
106		self.names(),
107		self.offset_data(),
108		),
109		)),
110		_ => None,
111		}
112		}
113		}
114
115		#[cfg(feature = "experimental_traverse")]
116		#[allow(clippy::needless_lifetimes)]
117		impl<'a> std::fmt::Debug for Feat<'a> {
118		fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
119		(self as &dyn SomeTable<'a>).fmt(f)
120		}
121		}
122
123		/// Type, flags and names for a feature.
124		#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
125		#[repr(C)]
126		#[repr(packed)]
127		pub struct FeatureName {
128		/// Feature type.
129		pub feature: BigEndian<u16>,
130		/// The number of records in the setting name array.
131		pub n_settings: BigEndian<u16>,
132		/// Offset in bytes from the beginning of this table to this feature's
133		/// setting name array. The actual type of record this offset refers
134		/// to will depend on the exclusivity value, as described below.
135		pub setting_table_offset: BigEndian<Offset32>,
136		/// Flags associated with the feature type.
137		pub feature_flags: BigEndian<u16>,
138		/// The name table index for the feature's name.
139		pub name_index: BigEndian<NameId>,
140		}
141
142		impl FeatureName {
143		/// Feature type.
144	0	pub fn feature(&self) -> u16 {
145	0	self.feature.get()
146	0	}
147
148		/// The number of records in the setting name array.
149	0	pub fn n_settings(&self) -> u16 {
150	0	self.n_settings.get()
151	0	}
152
153		/// Offset in bytes from the beginning of this table to this feature's
154		/// setting name array. The actual type of record this offset refers
155		/// to will depend on the exclusivity value, as described below.
156	0	pub fn setting_table_offset(&self) -> Offset32 {
157	0	self.setting_table_offset.get()
158	0	}
159
160		/// Offset in bytes from the beginning of this table to this feature's
161		/// setting name array. The actual type of record this offset refers
162		/// to will depend on the exclusivity value, as described below.
163		///
164		/// The `data` argument should be retrieved from the parent table
165		/// By calling its `offset_data` method.
166	0	pub fn setting_table<'a>(&self, data: FontData<'a>) -> Result<SettingNameArray<'a>, ReadError> {
167	0	let args = self.n_settings();
168	0	self.setting_table_offset().resolve_with_args(data, &args)
169	0	}
170
171		/// Flags associated with the feature type.
172	0	pub fn feature_flags(&self) -> u16 {
173	0	self.feature_flags.get()
174	0	}
175
176		/// The name table index for the feature's name.
177	0	pub fn name_index(&self) -> NameId {
178	0	self.name_index.get()
179	0	}
180		}
181
182		impl FixedSize for FeatureName {
183		const RAW_BYTE_LEN: usize = u16::RAW_BYTE_LEN
184		+ u16::RAW_BYTE_LEN
185		+ Offset32::RAW_BYTE_LEN
186		+ u16::RAW_BYTE_LEN
187		+ NameId::RAW_BYTE_LEN;
188		}
189
190		#[cfg(feature = "experimental_traverse")]
191		impl<'a> SomeRecord<'a> for FeatureName {
192		fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
193		RecordResolver {
194		name: "FeatureName",
195		get_field: Box::new(move \|idx, _data\| match idx {
196		0usize => Some(Field::new("feature", self.feature())),
197		1usize => Some(Field::new("n_settings", self.n_settings())),
198		2usize => Some(Field::new(
199		"setting_table_offset",
200		FieldType::offset(self.setting_table_offset(), self.setting_table(_data)),
201		)),
202		3usize => Some(Field::new("feature_flags", self.feature_flags())),
203		4usize => Some(Field::new("name_index", self.name_index())),
204		_ => None,
205		}),
206		data,
207		}
208		}
209		}
210
211		#[derive(Debug, Clone, Copy)]
212		#[doc(hidden)]
213		pub struct SettingNameArrayMarker {
214		settings_byte_len: usize,
215		}
216
217		impl SettingNameArrayMarker {
218	0	pub fn settings_byte_range(&self) -> Range<usize> {
219	0	let start = 0;
220	0	start..start + self.settings_byte_len
221	0	}
222		}
223
224		impl MinByteRange for SettingNameArrayMarker {
225	0	fn min_byte_range(&self) -> Range<usize> {
226	0	0..self.settings_byte_range().end
227	0	}
228		}
229
230		impl ReadArgs for SettingNameArray<'_> {
231		type Args = u16;
232		}
233
234		impl<'a> FontReadWithArgs<'a> for SettingNameArray<'a> {
235	0	fn read_with_args(data: FontData<'a>, args: &u16) -> Result<Self, ReadError> {
236	0	let n_settings = *args;
237	0	let mut cursor = data.cursor();
238	0	let settings_byte_len = (n_settings as usize)
239	0	.checked_mul(SettingName::RAW_BYTE_LEN)
240	0	.ok_or(ReadError::OutOfBounds)?;
241	0	cursor.advance_by(settings_byte_len);
242	0	cursor.finish(SettingNameArrayMarker { settings_byte_len })
243	0	}
244		}
245
246		impl<'a> SettingNameArray<'a> {
247		/// A constructor that requires additional arguments.
248		///
249		/// This type requires some external state in order to be
250		/// parsed.
251	0	pub fn read(data: FontData<'a>, n_settings: u16) -> Result<Self, ReadError> {
252	0	let args = n_settings;
253	0	Self::read_with_args(data, &args)
254	0	}
255		}
256
257		pub type SettingNameArray<'a> = TableRef<'a, SettingNameArrayMarker>;
258
259		#[allow(clippy::needless_lifetimes)]
260		impl<'a> SettingNameArray<'a> {
261		/// List of setting names for a feature.
262	0	pub fn settings(&self) -> &'a [SettingName] {
263	0	let range = self.shape.settings_byte_range();
264	0	self.data.read_array(range).unwrap()
265	0	}
266		}
267
268		#[cfg(feature = "experimental_traverse")]
269		impl<'a> SomeTable<'a> for SettingNameArray<'a> {
270		fn type_name(&self) -> &str {
271		"SettingNameArray"
272		}
273		fn get_field(&self, idx: usize) -> Option<Field<'a>> {
274		match idx {
275		0usize => Some(Field::new(
276		"settings",
277		traversal::FieldType::array_of_records(
278		stringify!(SettingName),
279		self.settings(),
280		self.offset_data(),
281		),
282		)),
283		_ => None,
284		}
285		}
286		}
287
288		#[cfg(feature = "experimental_traverse")]
289		#[allow(clippy::needless_lifetimes)]
290		impl<'a> std::fmt::Debug for SettingNameArray<'a> {
291		fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
292		(self as &dyn SomeTable<'a>).fmt(f)
293		}
294		}
295
296		/// Associates a setting with a name identifier.
297		#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
298		#[repr(C)]
299		#[repr(packed)]
300		pub struct SettingName {
301		/// The setting.
302		pub setting: BigEndian<u16>,
303		/// The name table index for the setting's name.
304		pub name_index: BigEndian<NameId>,
305		}
306
307		impl SettingName {
308		/// The setting.
309	0	pub fn setting(&self) -> u16 {
310	0	self.setting.get()
311	0	}
312
313		/// The name table index for the setting's name.
314	0	pub fn name_index(&self) -> NameId {
315	0	self.name_index.get()
316	0	}
317		}
318
319		impl FixedSize for SettingName {
320		const RAW_BYTE_LEN: usize = u16::RAW_BYTE_LEN + NameId::RAW_BYTE_LEN;
321		}
322
323		#[cfg(feature = "experimental_traverse")]
324		impl<'a> SomeRecord<'a> for SettingName {
325		fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
326		RecordResolver {
327		name: "SettingName",
328		get_field: Box::new(move \|idx, _data\| match idx {
329		0usize => Some(Field::new("setting", self.setting())),
330		1usize => Some(Field::new("name_index", self.name_index())),
331		_ => None,
332		}),
333		data,
334		}
335		}
336		}