read_fonts/generated/
generated_vorg.rs1#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8impl<'a> MinByteRange<'a> for Vorg<'a> {
9 fn min_byte_range(&self) -> Range<usize> {
10 0..self.vert_origin_y_metrics_byte_range().end
11 }
12 fn min_table_bytes(&self) -> &'a [u8] {
13 let range = self.min_byte_range();
14 self.offset_data().as_bytes().get(range).unwrap_or_default()
15 }
16}
17
18impl TopLevelTable for Vorg<'_> {
19 const TAG: Tag = Tag::new(b"VORG");
21}
22
23impl ReadArgs for Vorg<'_> {
24 type Args = ();
25}
26
27impl<'a> FontRead<'a> for Vorg<'a> {
28 fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
29 #[allow(clippy::absurd_extreme_comparisons)]
30 if data.len() < Self::MIN_SIZE {
31 return Err(ReadError::OutOfBounds);
32 }
33 let Some(data) = TableDataRef::new(data.as_bytes()) else {
34 return Err(ReadError::OutOfBounds);
35 };
36 Ok(Self { data })
37 }
38}
39
40#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
42#[repr(C, packed)]
43#[doc(hidden)]
44pub struct VorgFixedHeader {
45 pub version: BigEndian<MajorMinor>,
46 pub default_vert_origin_y: BigEndian<i16>,
47 pub num_vert_origin_y_metrics: BigEndian<u16>,
48}
49
50#[allow(clippy::absurd_extreme_comparisons)]
51const _: () = assert!(std::mem::size_of::<VorgFixedHeader>() <= Vorg::MIN_SIZE);
52
53#[derive(Clone)]
55pub struct Vorg<'a> {
56 data: TableDataRef<'a, VorgFixedHeader>,
57}
58
59#[allow(clippy::needless_lifetimes)]
60impl<'a> Vorg<'a> {
61 pub const MIN_SIZE: usize = (MajorMinor::RAW_BYTE_LEN + i16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
62 basic_table_impls!(impl_the_methods);
63
64 pub fn version(&self) -> MajorMinor {
66 self.data.header().version.get()
67 }
68
69 pub fn default_vert_origin_y(&self) -> i16 {
73 self.data.header().default_vert_origin_y.get()
74 }
75
76 pub fn num_vert_origin_y_metrics(&self) -> u16 {
78 self.data.header().num_vert_origin_y_metrics.get()
79 }
80
81 pub fn vert_origin_y_metrics(&self) -> &'a [VertOriginYMetrics] {
83 let range = self.vert_origin_y_metrics_byte_range();
84 self.offset_data()
85 .read_array(range)
86 .ok()
87 .unwrap_or_default()
88 }
89
90 pub fn version_byte_range(&self) -> Range<usize> {
91 let start = 0;
92 let end = start + MajorMinor::RAW_BYTE_LEN;
93 start..end
94 }
95
96 pub fn default_vert_origin_y_byte_range(&self) -> Range<usize> {
97 let start = self.version_byte_range().end;
98 let end = start + i16::RAW_BYTE_LEN;
99 start..end
100 }
101
102 pub fn num_vert_origin_y_metrics_byte_range(&self) -> Range<usize> {
103 let start = self.default_vert_origin_y_byte_range().end;
104 let end = start + u16::RAW_BYTE_LEN;
105 start..end
106 }
107
108 pub fn vert_origin_y_metrics_byte_range(&self) -> Range<usize> {
109 let num_vert_origin_y_metrics = self.num_vert_origin_y_metrics();
110 let start = self.num_vert_origin_y_metrics_byte_range().end;
111 let end = start
112 + (transforms::to_usize(num_vert_origin_y_metrics))
113 .saturating_mul(VertOriginYMetrics::RAW_BYTE_LEN);
114 start..end
115 }
116}
117
118const _: () = assert!(FontData::default_data_long_enough(Vorg::MIN_SIZE));
119
120impl Default for Vorg<'_> {
121 fn default() -> Self {
122 Self {
123 data: TableDataRef::new(FontData::default_table_data().as_bytes())
124 .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
125 }
126 }
127}
128
129#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
131#[repr(C)]
132#[repr(packed)]
133pub struct VertOriginYMetrics {
134 pub glyph_index: BigEndian<GlyphId16>,
136 pub vert_origin_y: BigEndian<i16>,
138}
139
140impl VertOriginYMetrics {
141 pub fn glyph_index(&self) -> GlyphId16 {
143 self.glyph_index.get()
144 }
145
146 pub fn vert_origin_y(&self) -> i16 {
148 self.vert_origin_y.get()
149 }
150}
151
152impl FixedSize for VertOriginYMetrics {
153 const RAW_BYTE_LEN: usize = GlyphId16::RAW_BYTE_LEN + i16::RAW_BYTE_LEN;
154}