/src/fontations/read-fonts/generated/generated_vorg.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::*;

impl<'a> MinByteRange<'a> for Vorg<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.vert_origin_y_metrics_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

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

impl<'a> FontRead<'a> for Vorg<'a> {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// The [VORG (Vertical Origin)](https://docs.microsoft.com/en-us/typography/opentype/spec/vorg) table.
#[derive(Clone)]
pub struct Vorg<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> Vorg<'a> {
    pub const MIN_SIZE: usize = (MajorMinor::RAW_BYTE_LEN + i16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Major/minor version number. Set to 1.0.
    pub fn version(&self) -> MajorMinor {
        let range = self.version_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// The y coordinate of a glyph’s vertical origin, in the font’s design
    /// coordinate system, to be used if no entry is present for the glyph
    /// in the vertOriginYMetrics array.
    pub fn default_vert_origin_y(&self) -> i16 {
        let range = self.default_vert_origin_y_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Number of elements in the vertOriginYMetrics array.
    pub fn num_vert_origin_y_metrics(&self) -> u16 {
        let range = self.num_vert_origin_y_metrics_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Array of VertOriginYMetrics records, sorted by glyph ID.
    pub fn vert_origin_y_metrics(&self) -> &'a [VertOriginYMetrics] {
        let range = self.vert_origin_y_metrics_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

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

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

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

    pub fn vert_origin_y_metrics_byte_range(&self) -> Range<usize> {
        let num_vert_origin_y_metrics = self.num_vert_origin_y_metrics();
        let start = self.num_vert_origin_y_metrics_byte_range().end;
        start
            ..start
                + (num_vert_origin_y_metrics as usize)
                    .saturating_mul(VertOriginYMetrics::RAW_BYTE_LEN)
    }
}

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

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

/// Vertical origin Y metrics record.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct VertOriginYMetrics {
    /// Glyph index.
    pub glyph_index: BigEndian<GlyphId16>,
    /// Y coordinate, in the font’s design coordinate system, of the glyph’s vertical origin.
    pub vert_origin_y: BigEndian<i16>,
}

impl VertOriginYMetrics {
    /// Glyph index.
    pub fn glyph_index(&self) -> GlyphId16 {
        self.glyph_index.get()
    }

    /// Y coordinate, in the font’s design coordinate system, of the glyph’s vertical origin.
    pub fn vert_origin_y(&self) -> i16 {
        self.vert_origin_y.get()
    }
}

impl FixedSize for VertOriginYMetrics {
    const RAW_BYTE_LEN: usize = GlyphId16::RAW_BYTE_LEN + i16::RAW_BYTE_LEN;
}

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

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		impl<'a> MinByteRange<'a> for Vorg<'a> {
9	0	fn min_byte_range(&self) -> Range<usize> {
10	0	0..self.vert_origin_y_metrics_byte_range().end
11	0	}
12	0	fn min_table_bytes(&self) -> &'a [u8] {
13	0	let range = self.min_byte_range();
14	0	self.data.as_bytes().get(range).unwrap_or_default()
15	0	}
16		}
17
18		impl TopLevelTable for Vorg<'_> {
19		/// `VORG`
20		const TAG: Tag = Tag::new(b"VORG");
21		}
22
23		impl<'a> FontRead<'a> for Vorg<'a> {
24	0	fn read(data: FontData<'a>) -> Result<Self, ReadError> {
25		#[allow(clippy::absurd_extreme_comparisons)]
26	0	if data.len() < Self::MIN_SIZE {
27	0	return Err(ReadError::OutOfBounds);
28	0	}
29	0	Ok(Self { data })
30	0	}
31		}
32
33		/// The [VORG (Vertical Origin)](https://docs.microsoft.com/en-us/typography/opentype/spec/vorg) table.
34		#[derive(Clone)]
35		pub struct Vorg<'a> {
36		data: FontData<'a>,
37		}
38
39		#[allow(clippy::needless_lifetimes)]
40		impl<'a> Vorg<'a> {
41		pub const MIN_SIZE: usize = (MajorMinor::RAW_BYTE_LEN + i16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
42		basic_table_impls!(impl_the_methods);
43
44		/// Major/minor version number. Set to 1.0.
45	0	pub fn version(&self) -> MajorMinor {
46	0	let range = self.version_byte_range();
47	0	self.data.read_at(range.start).ok().unwrap()
48	0	}
49
50		/// The y coordinate of a glyph’s vertical origin, in the font’s design
51		/// coordinate system, to be used if no entry is present for the glyph
52		/// in the vertOriginYMetrics array.
53	0	pub fn default_vert_origin_y(&self) -> i16 {
54	0	let range = self.default_vert_origin_y_byte_range();
55	0	self.data.read_at(range.start).ok().unwrap()
56	0	}
57
58		/// Number of elements in the vertOriginYMetrics array.
59	0	pub fn num_vert_origin_y_metrics(&self) -> u16 {
60	0	let range = self.num_vert_origin_y_metrics_byte_range();
61	0	self.data.read_at(range.start).ok().unwrap()
62	0	}
63
64		/// Array of VertOriginYMetrics records, sorted by glyph ID.
65	0	pub fn vert_origin_y_metrics(&self) -> &'a [VertOriginYMetrics] {
66	0	let range = self.vert_origin_y_metrics_byte_range();
67	0	self.data.read_array(range).ok().unwrap_or_default()
68	0	}
69
70	0	pub fn version_byte_range(&self) -> Range<usize> {
71	0	let start = 0;
72	0	start..start + MajorMinor::RAW_BYTE_LEN
73	0	}
74
75	0	pub fn default_vert_origin_y_byte_range(&self) -> Range<usize> {
76	0	let start = self.version_byte_range().end;
77	0	start..start + i16::RAW_BYTE_LEN
78	0	}
79
80	0	pub fn num_vert_origin_y_metrics_byte_range(&self) -> Range<usize> {
81	0	let start = self.default_vert_origin_y_byte_range().end;
82	0	start..start + u16::RAW_BYTE_LEN
83	0	}
84
85	0	pub fn vert_origin_y_metrics_byte_range(&self) -> Range<usize> {
86	0	let num_vert_origin_y_metrics = self.num_vert_origin_y_metrics();
87	0	let start = self.num_vert_origin_y_metrics_byte_range().end;
88	0	start
89	0	..start
90	0	+ (num_vert_origin_y_metrics as usize)
91	0	.saturating_mul(VertOriginYMetrics::RAW_BYTE_LEN)
92	0	}
93		}
94
95		#[cfg(feature = "experimental_traverse")]
96		impl<'a> SomeTable<'a> for Vorg<'a> {
97		fn type_name(&self) -> &str {
98		"Vorg"
99		}
100		fn get_field(&self, idx: usize) -> Option<Field<'a>> {
101		match idx {
102		0usize => Some(Field::new("version", self.version())),
103		1usize => Some(Field::new(
104		"default_vert_origin_y",
105		self.default_vert_origin_y(),
106		)),
107		2usize => Some(Field::new(
108		"num_vert_origin_y_metrics",
109		self.num_vert_origin_y_metrics(),
110		)),
111		3usize => Some(Field::new(
112		"vert_origin_y_metrics",
113		traversal::FieldType::array_of_records(
114		stringify!(VertOriginYMetrics),
115		self.vert_origin_y_metrics(),
116		self.offset_data(),
117		),
118		)),
119		_ => None,
120		}
121		}
122		}
123
124		#[cfg(feature = "experimental_traverse")]
125		#[allow(clippy::needless_lifetimes)]
126		impl<'a> std::fmt::Debug for Vorg<'a> {
127		fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
128		(self as &dyn SomeTable<'a>).fmt(f)
129		}
130		}
131
132		/// Vertical origin Y metrics record.
133		#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
134		#[repr(C)]
135		#[repr(packed)]
136		pub struct VertOriginYMetrics {
137		/// Glyph index.
138		pub glyph_index: BigEndian<GlyphId16>,
139		/// Y coordinate, in the font’s design coordinate system, of the glyph’s vertical origin.
140		pub vert_origin_y: BigEndian<i16>,
141		}
142
143		impl VertOriginYMetrics {
144		/// Glyph index.
145	0	pub fn glyph_index(&self) -> GlyphId16 {
146	0	self.glyph_index.get()
147	0	}
148
149		/// Y coordinate, in the font’s design coordinate system, of the glyph’s vertical origin.
150	0	pub fn vert_origin_y(&self) -> i16 {
151	0	self.vert_origin_y.get()
152	0	}
153		}
154
155		impl FixedSize for VertOriginYMetrics {
156		const RAW_BYTE_LEN: usize = GlyphId16::RAW_BYTE_LEN + i16::RAW_BYTE_LEN;
157		}
158
159		#[cfg(feature = "experimental_traverse")]
160		impl<'a> SomeRecord<'a> for VertOriginYMetrics {
161		fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
162		RecordResolver {
163		name: "VertOriginYMetrics",
164		get_field: Box::new(move \|idx, _data\| match idx {
165		0usize => Some(Field::new("glyph_index", self.glyph_index())),
166		1usize => Some(Field::new("vert_origin_y", self.vert_origin_y())),
167		_ => None,
168		}),
169		data,
170		}
171		}
172		}

Coverage Report

Created: 2026-04-01 07:11