write_fonts/generated/
generated_varc.rs

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)]
6use crate::codegen_prelude::*;
7
8pub use read_fonts::tables::varc::VarcFlags;
9
10/// [VARC](https://github.com/harfbuzz/boring-expansion-spec/blob/main/VARC.md) (Variable Composites / Components Table)
11///
12/// [FontTools VARC](https://github.com/fonttools/fonttools/blob/5e6b12d12fa08abafbeb7570f47707fbedf69a45/Lib/fontTools/ttLib/tables/otData.py#L3459-L3476)
13#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
14#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15pub struct Varc {
16    pub coverage: OffsetMarker<CoverageTable, WIDTH_32>,
17    pub multi_var_store: NullableOffsetMarker<MultiItemVariationStore, WIDTH_32>,
18    pub condition_list: NullableOffsetMarker<ConditionList, WIDTH_32>,
19    pub axis_indices_list: NullableOffsetMarker<Index2, WIDTH_32>,
20    pub var_composite_glyphs: OffsetMarker<Index2, WIDTH_32>,
21}
22
23impl Varc {
24    /// Construct a new `Varc`
25    pub fn new(
26        coverage: CoverageTable,
27        multi_var_store: Option<MultiItemVariationStore>,
28        condition_list: Option<ConditionList>,
29        axis_indices_list: Option<Index2>,
30        var_composite_glyphs: Index2,
31    ) -> Self {
32        Self {
33            coverage: coverage.into(),
34            multi_var_store: multi_var_store.into(),
35            condition_list: condition_list.into(),
36            axis_indices_list: axis_indices_list.into(),
37            var_composite_glyphs: var_composite_glyphs.into(),
38        }
39    }
40}
41
42impl FontWrite for Varc {
43    #[allow(clippy::unnecessary_cast)]
44    fn write_into(&self, writer: &mut TableWriter) {
45        (MajorMinor::VERSION_1_0 as MajorMinor).write_into(writer);
46        self.coverage.write_into(writer);
47        self.multi_var_store.write_into(writer);
48        self.condition_list.write_into(writer);
49        self.axis_indices_list.write_into(writer);
50        self.var_composite_glyphs.write_into(writer);
51    }
52    fn table_type(&self) -> TableType {
53        TableType::TopLevel(Varc::TAG)
54    }
55}
56
57impl Validate for Varc {
58    fn validate_impl(&self, ctx: &mut ValidationCtx) {
59        ctx.in_table("Varc", |ctx| {
60            ctx.in_field("coverage", |ctx| {
61                self.coverage.validate_impl(ctx);
62            });
63            ctx.in_field("multi_var_store", |ctx| {
64                self.multi_var_store.validate_impl(ctx);
65            });
66            ctx.in_field("condition_list", |ctx| {
67                self.condition_list.validate_impl(ctx);
68            });
69            ctx.in_field("axis_indices_list", |ctx| {
70                self.axis_indices_list.validate_impl(ctx);
71            });
72            ctx.in_field("var_composite_glyphs", |ctx| {
73                self.var_composite_glyphs.validate_impl(ctx);
74            });
75        })
76    }
77}
78
79impl TopLevelTable for Varc {
80    const TAG: Tag = Tag::new(b"VARC");
81}
82
83impl<'a> FromObjRef<read_fonts::tables::varc::Varc<'a>> for Varc {
84    fn from_obj_ref(obj: &read_fonts::tables::varc::Varc<'a>, _: FontData) -> Self {
85        Varc {
86            coverage: obj.coverage().to_owned_table(),
87            multi_var_store: obj.multi_var_store().to_owned_table(),
88            condition_list: obj.condition_list().to_owned_table(),
89            axis_indices_list: obj.axis_indices_list().to_owned_table(),
90            var_composite_glyphs: obj.var_composite_glyphs().to_owned_table(),
91        }
92    }
93}
94
95#[allow(clippy::needless_lifetimes)]
96impl<'a> FromTableRef<read_fonts::tables::varc::Varc<'a>> for Varc {}
97
98impl<'a> FontRead<'a> for Varc {
99    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
100        <read_fonts::tables::varc::Varc as FontRead>::read(data).map(|x| x.to_owned_table())
101    }
102}
103
104/// * <https://github.com/fonttools/fonttools/blob/5e6b12d12fa08abafbeb7570f47707fbedf69a45/Lib/fontTools/ttLib/tables/otData.py#L3451-L3457>
105/// * <https://github.com/harfbuzz/harfbuzz/blob/7be12b33e3f07067c159d8f516eb31df58c75876/src/hb-ot-layout-common.hh#L3517-L3520C3>
106#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
107#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
108pub struct MultiItemVariationStore {
109    pub region_list: OffsetMarker<SparseVariationRegionList, WIDTH_32>,
110    pub variation_data_count: u16,
111    pub variation_data: Vec<OffsetMarker<MultiItemVariationData, WIDTH_32>>,
112}
113
114impl MultiItemVariationStore {
115    /// Construct a new `MultiItemVariationStore`
116    pub fn new(
117        region_list: SparseVariationRegionList,
118        variation_data_count: u16,
119        variation_data: Vec<MultiItemVariationData>,
120    ) -> Self {
121        Self {
122            region_list: region_list.into(),
123            variation_data_count,
124            variation_data: variation_data.into_iter().map(Into::into).collect(),
125        }
126    }
127}
128
129impl FontWrite for MultiItemVariationStore {
130    #[allow(clippy::unnecessary_cast)]
131    fn write_into(&self, writer: &mut TableWriter) {
132        (1 as u16).write_into(writer);
133        self.region_list.write_into(writer);
134        self.variation_data_count.write_into(writer);
135        self.variation_data.write_into(writer);
136    }
137    fn table_type(&self) -> TableType {
138        TableType::Named("MultiItemVariationStore")
139    }
140}
141
142impl Validate for MultiItemVariationStore {
143    fn validate_impl(&self, ctx: &mut ValidationCtx) {
144        ctx.in_table("MultiItemVariationStore", |ctx| {
145            ctx.in_field("region_list", |ctx| {
146                self.region_list.validate_impl(ctx);
147            });
148            ctx.in_field("variation_data", |ctx| {
149                if self.variation_data.len() > (u16::MAX as usize) {
150                    ctx.report("array exceeds max length");
151                }
152                self.variation_data.validate_impl(ctx);
153            });
154        })
155    }
156}
157
158impl<'a> FromObjRef<read_fonts::tables::varc::MultiItemVariationStore<'a>>
159    for MultiItemVariationStore
160{
161    fn from_obj_ref(
162        obj: &read_fonts::tables::varc::MultiItemVariationStore<'a>,
163        _: FontData,
164    ) -> Self {
165        MultiItemVariationStore {
166            region_list: obj.region_list().to_owned_table(),
167            variation_data_count: obj.variation_data_count(),
168            variation_data: obj.variation_data().to_owned_table(),
169        }
170    }
171}
172
173#[allow(clippy::needless_lifetimes)]
174impl<'a> FromTableRef<read_fonts::tables::varc::MultiItemVariationStore<'a>>
175    for MultiItemVariationStore
176{
177}
178
179impl<'a> FontRead<'a> for MultiItemVariationStore {
180    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
181        <read_fonts::tables::varc::MultiItemVariationStore as FontRead>::read(data)
182            .map(|x| x.to_owned_table())
183    }
184}
185
186#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
187#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
188pub struct SparseVariationRegionList {
189    pub region_count: u16,
190    pub regions: Vec<OffsetMarker<SparseVariationRegion, WIDTH_32>>,
191}
192
193impl SparseVariationRegionList {
194    /// Construct a new `SparseVariationRegionList`
195    pub fn new(region_count: u16, regions: Vec<SparseVariationRegion>) -> Self {
196        Self {
197            region_count,
198            regions: regions.into_iter().map(Into::into).collect(),
199        }
200    }
201}
202
203impl FontWrite for SparseVariationRegionList {
204    fn write_into(&self, writer: &mut TableWriter) {
205        self.region_count.write_into(writer);
206        self.regions.write_into(writer);
207    }
208    fn table_type(&self) -> TableType {
209        TableType::Named("SparseVariationRegionList")
210    }
211}
212
213impl Validate for SparseVariationRegionList {
214    fn validate_impl(&self, ctx: &mut ValidationCtx) {
215        ctx.in_table("SparseVariationRegionList", |ctx| {
216            ctx.in_field("regions", |ctx| {
217                if self.regions.len() > (u16::MAX as usize) {
218                    ctx.report("array exceeds max length");
219                }
220                self.regions.validate_impl(ctx);
221            });
222        })
223    }
224}
225
226impl<'a> FromObjRef<read_fonts::tables::varc::SparseVariationRegionList<'a>>
227    for SparseVariationRegionList
228{
229    fn from_obj_ref(
230        obj: &read_fonts::tables::varc::SparseVariationRegionList<'a>,
231        _: FontData,
232    ) -> Self {
233        SparseVariationRegionList {
234            region_count: obj.region_count(),
235            regions: obj.regions().to_owned_table(),
236        }
237    }
238}
239
240#[allow(clippy::needless_lifetimes)]
241impl<'a> FromTableRef<read_fonts::tables::varc::SparseVariationRegionList<'a>>
242    for SparseVariationRegionList
243{
244}
245
246impl<'a> FontRead<'a> for SparseVariationRegionList {
247    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
248        <read_fonts::tables::varc::SparseVariationRegionList as FontRead>::read(data)
249            .map(|x| x.to_owned_table())
250    }
251}
252
253#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
254#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
255pub struct SparseVariationRegion {
256    pub region_axis_count: u16,
257    pub region_axes: Vec<SparseRegionAxisCoordinates>,
258}
259
260impl SparseVariationRegion {
261    /// Construct a new `SparseVariationRegion`
262    pub fn new(region_axis_count: u16, region_axes: Vec<SparseRegionAxisCoordinates>) -> Self {
263        Self {
264            region_axis_count,
265            region_axes,
266        }
267    }
268}
269
270impl FontWrite for SparseVariationRegion {
271    fn write_into(&self, writer: &mut TableWriter) {
272        self.region_axis_count.write_into(writer);
273        self.region_axes.write_into(writer);
274    }
275    fn table_type(&self) -> TableType {
276        TableType::Named("SparseVariationRegion")
277    }
278}
279
280impl Validate for SparseVariationRegion {
281    fn validate_impl(&self, ctx: &mut ValidationCtx) {
282        ctx.in_table("SparseVariationRegion", |ctx| {
283            ctx.in_field("region_axes", |ctx| {
284                if self.region_axes.len() > (u16::MAX as usize) {
285                    ctx.report("array exceeds max length");
286                }
287                self.region_axes.validate_impl(ctx);
288            });
289        })
290    }
291}
292
293impl<'a> FromObjRef<read_fonts::tables::varc::SparseVariationRegion<'a>> for SparseVariationRegion {
294    fn from_obj_ref(
295        obj: &read_fonts::tables::varc::SparseVariationRegion<'a>,
296        _: FontData,
297    ) -> Self {
298        let offset_data = obj.offset_data();
299        SparseVariationRegion {
300            region_axis_count: obj.region_axis_count(),
301            region_axes: obj.region_axes().to_owned_obj(offset_data),
302        }
303    }
304}
305
306#[allow(clippy::needless_lifetimes)]
307impl<'a> FromTableRef<read_fonts::tables::varc::SparseVariationRegion<'a>>
308    for SparseVariationRegion
309{
310}
311
312impl<'a> FontRead<'a> for SparseVariationRegion {
313    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
314        <read_fonts::tables::varc::SparseVariationRegion as FontRead>::read(data)
315            .map(|x| x.to_owned_table())
316    }
317}
318
319#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
320#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
321pub struct SparseRegionAxisCoordinates {
322    pub axis_index: u16,
323    pub start: F2Dot14,
324    pub peak: F2Dot14,
325    pub end: F2Dot14,
326}
327
328impl SparseRegionAxisCoordinates {
329    /// Construct a new `SparseRegionAxisCoordinates`
330    pub fn new(axis_index: u16, start: F2Dot14, peak: F2Dot14, end: F2Dot14) -> Self {
331        Self {
332            axis_index,
333            start,
334            peak,
335            end,
336        }
337    }
338}
339
340impl FontWrite for SparseRegionAxisCoordinates {
341    fn write_into(&self, writer: &mut TableWriter) {
342        self.axis_index.write_into(writer);
343        self.start.write_into(writer);
344        self.peak.write_into(writer);
345        self.end.write_into(writer);
346    }
347    fn table_type(&self) -> TableType {
348        TableType::Named("SparseRegionAxisCoordinates")
349    }
350}
351
352impl Validate for SparseRegionAxisCoordinates {
353    fn validate_impl(&self, _ctx: &mut ValidationCtx) {}
354}
355
356impl FromObjRef<read_fonts::tables::varc::SparseRegionAxisCoordinates>
357    for SparseRegionAxisCoordinates
358{
359    fn from_obj_ref(
360        obj: &read_fonts::tables::varc::SparseRegionAxisCoordinates,
361        _: FontData,
362    ) -> Self {
363        SparseRegionAxisCoordinates {
364            axis_index: obj.axis_index(),
365            start: obj.start(),
366            peak: obj.peak(),
367            end: obj.end(),
368        }
369    }
370}
371
372#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
373#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
374pub struct MultiItemVariationData {
375    pub region_index_count: u16,
376    pub region_indices: Vec<u16>,
377    pub raw_delta_sets: Vec<u8>,
378}
379
380impl MultiItemVariationData {
381    /// Construct a new `MultiItemVariationData`
382    pub fn new(region_index_count: u16, region_indices: Vec<u16>, raw_delta_sets: Vec<u8>) -> Self {
383        Self {
384            region_index_count,
385            region_indices,
386            raw_delta_sets,
387        }
388    }
389}
390
391impl FontWrite for MultiItemVariationData {
392    #[allow(clippy::unnecessary_cast)]
393    fn write_into(&self, writer: &mut TableWriter) {
394        (1 as u8).write_into(writer);
395        self.region_index_count.write_into(writer);
396        self.region_indices.write_into(writer);
397        self.raw_delta_sets.write_into(writer);
398    }
399    fn table_type(&self) -> TableType {
400        TableType::Named("MultiItemVariationData")
401    }
402}
403
404impl Validate for MultiItemVariationData {
405    fn validate_impl(&self, ctx: &mut ValidationCtx) {
406        ctx.in_table("MultiItemVariationData", |ctx| {
407            ctx.in_field("region_indices", |ctx| {
408                if self.region_indices.len() > (u16::MAX as usize) {
409                    ctx.report("array exceeds max length");
410                }
411            });
412        })
413    }
414}
415
416impl<'a> FromObjRef<read_fonts::tables::varc::MultiItemVariationData<'a>>
417    for MultiItemVariationData
418{
419    fn from_obj_ref(
420        obj: &read_fonts::tables::varc::MultiItemVariationData<'a>,
421        _: FontData,
422    ) -> Self {
423        let offset_data = obj.offset_data();
424        MultiItemVariationData {
425            region_index_count: obj.region_index_count(),
426            region_indices: obj.region_indices().to_owned_obj(offset_data),
427            raw_delta_sets: obj.raw_delta_sets().to_owned_obj(offset_data),
428        }
429    }
430}
431
432#[allow(clippy::needless_lifetimes)]
433impl<'a> FromTableRef<read_fonts::tables::varc::MultiItemVariationData<'a>>
434    for MultiItemVariationData
435{
436}
437
438impl<'a> FontRead<'a> for MultiItemVariationData {
439    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
440        <read_fonts::tables::varc::MultiItemVariationData as FontRead>::read(data)
441            .map(|x| x.to_owned_table())
442    }
443}
444
445#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
446#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
447pub struct ConditionList {
448    pub condition_count: u32,
449    pub conditions: Vec<OffsetMarker<Condition, WIDTH_32>>,
450}
451
452impl ConditionList {
453    /// Construct a new `ConditionList`
454    pub fn new(condition_count: u32, conditions: Vec<Condition>) -> Self {
455        Self {
456            condition_count,
457            conditions: conditions.into_iter().map(Into::into).collect(),
458        }
459    }
460}
461
462impl FontWrite for ConditionList {
463    fn write_into(&self, writer: &mut TableWriter) {
464        self.condition_count.write_into(writer);
465        self.conditions.write_into(writer);
466    }
467    fn table_type(&self) -> TableType {
468        TableType::Named("ConditionList")
469    }
470}
471
472impl Validate for ConditionList {
473    fn validate_impl(&self, ctx: &mut ValidationCtx) {
474        ctx.in_table("ConditionList", |ctx| {
475            ctx.in_field("conditions", |ctx| {
476                if self.conditions.len() > (u32::MAX as usize) {
477                    ctx.report("array exceeds max length");
478                }
479                self.conditions.validate_impl(ctx);
480            });
481        })
482    }
483}
484
485impl<'a> FromObjRef<read_fonts::tables::varc::ConditionList<'a>> for ConditionList {
486    fn from_obj_ref(obj: &read_fonts::tables::varc::ConditionList<'a>, _: FontData) -> Self {
487        ConditionList {
488            condition_count: obj.condition_count(),
489            conditions: obj.conditions().to_owned_table(),
490        }
491    }
492}
493
494#[allow(clippy::needless_lifetimes)]
495impl<'a> FromTableRef<read_fonts::tables::varc::ConditionList<'a>> for ConditionList {}
496
497impl<'a> FontRead<'a> for ConditionList {
498    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
499        <read_fonts::tables::varc::ConditionList as FontRead>::read(data)
500            .map(|x| x.to_owned_table())
501    }
502}
503
504impl FontWrite for VarcFlags {
505    fn write_into(&self, writer: &mut TableWriter) {
506        writer.write_slice(&self.bits().to_be_bytes())
507    }
508}
write_fonts/generated/generated_varc.rs

write_fonts/generated/
generated_varc.rs
