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 ReadArgs for Varc {
99    type Args = ();
100}
101
102impl<'a> FontRead<'a> for Varc {
103    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
104        <read_fonts::tables::varc::Varc as FontRead>::read(data).map(|x| x.to_owned_table())
105    }
106}
107
108/// * <https://github.com/fonttools/fonttools/blob/5e6b12d12fa08abafbeb7570f47707fbedf69a45/Lib/fontTools/ttLib/tables/otData.py#L3451-L3457>
109/// * <https://github.com/harfbuzz/harfbuzz/blob/7be12b33e3f07067c159d8f516eb31df58c75876/src/hb-ot-layout-common.hh#L3517-L3520C3>
110#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
111#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
112pub struct MultiItemVariationStore {
113    pub region_list: OffsetMarker<SparseVariationRegionList, WIDTH_32>,
114    pub variation_data_count: u16,
115    pub variation_data: Vec<OffsetMarker<MultiItemVariationData, WIDTH_32>>,
116}
117
118impl MultiItemVariationStore {
119    /// Construct a new `MultiItemVariationStore`
120    pub fn new(
121        region_list: SparseVariationRegionList,
122        variation_data_count: u16,
123        variation_data: Vec<MultiItemVariationData>,
124    ) -> Self {
125        Self {
126            region_list: region_list.into(),
127            variation_data_count,
128            variation_data: variation_data.into_iter().map(Into::into).collect(),
129        }
130    }
131}
132
133impl FontWrite for MultiItemVariationStore {
134    #[allow(clippy::unnecessary_cast)]
135    fn write_into(&self, writer: &mut TableWriter) {
136        (1 as u16).write_into(writer);
137        self.region_list.write_into(writer);
138        self.variation_data_count.write_into(writer);
139        self.variation_data.write_into(writer);
140    }
141    fn table_type(&self) -> TableType {
142        TableType::Named("MultiItemVariationStore")
143    }
144}
145
146impl Validate for MultiItemVariationStore {
147    fn validate_impl(&self, ctx: &mut ValidationCtx) {
148        ctx.in_table("MultiItemVariationStore", |ctx| {
149            ctx.in_field("region_list", |ctx| {
150                self.region_list.validate_impl(ctx);
151            });
152            ctx.in_field("variation_data", |ctx| {
153                if self.variation_data.len() > to_usize(u16::MAX) {
154                    ctx.report("array exceeds max length");
155                }
156                self.variation_data.validate_impl(ctx);
157            });
158        })
159    }
160}
161
162impl<'a> FromObjRef<read_fonts::tables::varc::MultiItemVariationStore<'a>>
163    for MultiItemVariationStore
164{
165    fn from_obj_ref(
166        obj: &read_fonts::tables::varc::MultiItemVariationStore<'a>,
167        _: FontData,
168    ) -> Self {
169        MultiItemVariationStore {
170            region_list: obj.region_list().to_owned_table(),
171            variation_data_count: obj.variation_data_count(),
172            variation_data: obj.variation_data().to_owned_table(),
173        }
174    }
175}
176
177#[allow(clippy::needless_lifetimes)]
178impl<'a> FromTableRef<read_fonts::tables::varc::MultiItemVariationStore<'a>>
179    for MultiItemVariationStore
180{
181}
182
183impl ReadArgs for MultiItemVariationStore {
184    type Args = ();
185}
186
187impl<'a> FontRead<'a> for MultiItemVariationStore {
188    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
189        <read_fonts::tables::varc::MultiItemVariationStore as FontRead>::read(data)
190            .map(|x| x.to_owned_table())
191    }
192}
193
194#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
195#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
196pub struct SparseVariationRegionList {
197    pub region_count: u16,
198    pub regions: Vec<OffsetMarker<SparseVariationRegion, WIDTH_32>>,
199}
200
201impl SparseVariationRegionList {
202    /// Construct a new `SparseVariationRegionList`
203    pub fn new(region_count: u16, regions: Vec<SparseVariationRegion>) -> Self {
204        Self {
205            region_count,
206            regions: regions.into_iter().map(Into::into).collect(),
207        }
208    }
209}
210
211impl FontWrite for SparseVariationRegionList {
212    fn write_into(&self, writer: &mut TableWriter) {
213        self.region_count.write_into(writer);
214        self.regions.write_into(writer);
215    }
216    fn table_type(&self) -> TableType {
217        TableType::Named("SparseVariationRegionList")
218    }
219}
220
221impl Validate for SparseVariationRegionList {
222    fn validate_impl(&self, ctx: &mut ValidationCtx) {
223        ctx.in_table("SparseVariationRegionList", |ctx| {
224            ctx.in_field("regions", |ctx| {
225                if self.regions.len() > to_usize(u16::MAX) {
226                    ctx.report("array exceeds max length");
227                }
228                self.regions.validate_impl(ctx);
229            });
230        })
231    }
232}
233
234impl<'a> FromObjRef<read_fonts::tables::varc::SparseVariationRegionList<'a>>
235    for SparseVariationRegionList
236{
237    fn from_obj_ref(
238        obj: &read_fonts::tables::varc::SparseVariationRegionList<'a>,
239        _: FontData,
240    ) -> Self {
241        SparseVariationRegionList {
242            region_count: obj.region_count(),
243            regions: obj.regions().to_owned_table(),
244        }
245    }
246}
247
248#[allow(clippy::needless_lifetimes)]
249impl<'a> FromTableRef<read_fonts::tables::varc::SparseVariationRegionList<'a>>
250    for SparseVariationRegionList
251{
252}
253
254impl ReadArgs for SparseVariationRegionList {
255    type Args = ();
256}
257
258impl<'a> FontRead<'a> for SparseVariationRegionList {
259    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
260        <read_fonts::tables::varc::SparseVariationRegionList as FontRead>::read(data)
261            .map(|x| x.to_owned_table())
262    }
263}
264
265#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
266#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
267pub struct SparseVariationRegion {
268    pub region_axis_count: u16,
269    pub region_axes: Vec<SparseRegionAxisCoordinates>,
270}
271
272impl SparseVariationRegion {
273    /// Construct a new `SparseVariationRegion`
274    pub fn new(region_axis_count: u16, region_axes: Vec<SparseRegionAxisCoordinates>) -> Self {
275        Self {
276            region_axis_count,
277            region_axes,
278        }
279    }
280}
281
282impl FontWrite for SparseVariationRegion {
283    fn write_into(&self, writer: &mut TableWriter) {
284        self.region_axis_count.write_into(writer);
285        self.region_axes.write_into(writer);
286    }
287    fn table_type(&self) -> TableType {
288        TableType::Named("SparseVariationRegion")
289    }
290}
291
292impl Validate for SparseVariationRegion {
293    fn validate_impl(&self, ctx: &mut ValidationCtx) {
294        ctx.in_table("SparseVariationRegion", |ctx| {
295            ctx.in_field("region_axes", |ctx| {
296                if self.region_axes.len() > to_usize(u16::MAX) {
297                    ctx.report("array exceeds max length");
298                }
299                self.region_axes.validate_impl(ctx);
300            });
301        })
302    }
303}
304
305impl<'a> FromObjRef<read_fonts::tables::varc::SparseVariationRegion<'a>> for SparseVariationRegion {
306    fn from_obj_ref(
307        obj: &read_fonts::tables::varc::SparseVariationRegion<'a>,
308        _: FontData,
309    ) -> Self {
310        let offset_data = obj.offset_data();
311        SparseVariationRegion {
312            region_axis_count: obj.region_axis_count(),
313            region_axes: obj.region_axes().to_owned_obj(offset_data),
314        }
315    }
316}
317
318#[allow(clippy::needless_lifetimes)]
319impl<'a> FromTableRef<read_fonts::tables::varc::SparseVariationRegion<'a>>
320    for SparseVariationRegion
321{
322}
323
324impl ReadArgs for SparseVariationRegion {
325    type Args = ();
326}
327
328impl<'a> FontRead<'a> for SparseVariationRegion {
329    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
330        <read_fonts::tables::varc::SparseVariationRegion as FontRead>::read(data)
331            .map(|x| x.to_owned_table())
332    }
333}
334
335#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
336#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
337pub struct SparseRegionAxisCoordinates {
338    pub axis_index: u16,
339    pub start: F2Dot14,
340    pub peak: F2Dot14,
341    pub end: F2Dot14,
342}
343
344impl SparseRegionAxisCoordinates {
345    /// Construct a new `SparseRegionAxisCoordinates`
346    pub fn new(axis_index: u16, start: F2Dot14, peak: F2Dot14, end: F2Dot14) -> Self {
347        Self {
348            axis_index,
349            start,
350            peak,
351            end,
352        }
353    }
354}
355
356impl FontWrite for SparseRegionAxisCoordinates {
357    fn write_into(&self, writer: &mut TableWriter) {
358        self.axis_index.write_into(writer);
359        self.start.write_into(writer);
360        self.peak.write_into(writer);
361        self.end.write_into(writer);
362    }
363    fn table_type(&self) -> TableType {
364        TableType::Named("SparseRegionAxisCoordinates")
365    }
366}
367
368impl Validate for SparseRegionAxisCoordinates {
369    fn validate_impl(&self, _ctx: &mut ValidationCtx) {}
370}
371
372impl FromObjRef<read_fonts::tables::varc::SparseRegionAxisCoordinates>
373    for SparseRegionAxisCoordinates
374{
375    fn from_obj_ref(
376        obj: &read_fonts::tables::varc::SparseRegionAxisCoordinates,
377        _: FontData,
378    ) -> Self {
379        SparseRegionAxisCoordinates {
380            axis_index: obj.axis_index(),
381            start: obj.start(),
382            peak: obj.peak(),
383            end: obj.end(),
384        }
385    }
386}
387
388#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
389#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
390pub struct MultiItemVariationData {
391    pub region_index_count: u16,
392    pub region_indices: Vec<u16>,
393    pub raw_delta_sets: Vec<u8>,
394}
395
396impl MultiItemVariationData {
397    /// Construct a new `MultiItemVariationData`
398    pub fn new(region_index_count: u16, region_indices: Vec<u16>, raw_delta_sets: Vec<u8>) -> Self {
399        Self {
400            region_index_count,
401            region_indices,
402            raw_delta_sets,
403        }
404    }
405}
406
407impl FontWrite for MultiItemVariationData {
408    #[allow(clippy::unnecessary_cast)]
409    fn write_into(&self, writer: &mut TableWriter) {
410        (1 as u8).write_into(writer);
411        self.region_index_count.write_into(writer);
412        self.region_indices.write_into(writer);
413        self.raw_delta_sets.write_into(writer);
414    }
415    fn table_type(&self) -> TableType {
416        TableType::Named("MultiItemVariationData")
417    }
418}
419
420impl Validate for MultiItemVariationData {
421    fn validate_impl(&self, ctx: &mut ValidationCtx) {
422        ctx.in_table("MultiItemVariationData", |ctx| {
423            ctx.in_field("region_indices", |ctx| {
424                if self.region_indices.len() > to_usize(u16::MAX) {
425                    ctx.report("array exceeds max length");
426                }
427            });
428        })
429    }
430}
431
432impl<'a> FromObjRef<read_fonts::tables::varc::MultiItemVariationData<'a>>
433    for MultiItemVariationData
434{
435    fn from_obj_ref(
436        obj: &read_fonts::tables::varc::MultiItemVariationData<'a>,
437        _: FontData,
438    ) -> Self {
439        let offset_data = obj.offset_data();
440        MultiItemVariationData {
441            region_index_count: obj.region_index_count(),
442            region_indices: obj.region_indices().to_owned_obj(offset_data),
443            raw_delta_sets: obj.raw_delta_sets().to_owned_obj(offset_data),
444        }
445    }
446}
447
448#[allow(clippy::needless_lifetimes)]
449impl<'a> FromTableRef<read_fonts::tables::varc::MultiItemVariationData<'a>>
450    for MultiItemVariationData
451{
452}
453
454impl ReadArgs for MultiItemVariationData {
455    type Args = ();
456}
457
458impl<'a> FontRead<'a> for MultiItemVariationData {
459    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
460        <read_fonts::tables::varc::MultiItemVariationData as FontRead>::read(data)
461            .map(|x| x.to_owned_table())
462    }
463}
464
465#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
466#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
467pub struct ConditionList {
468    pub condition_count: u32,
469    pub conditions: Vec<OffsetMarker<Condition, WIDTH_32>>,
470}
471
472impl ConditionList {
473    /// Construct a new `ConditionList`
474    pub fn new(condition_count: u32, conditions: Vec<Condition>) -> Self {
475        Self {
476            condition_count,
477            conditions: conditions.into_iter().map(Into::into).collect(),
478        }
479    }
480}
481
482impl FontWrite for ConditionList {
483    fn write_into(&self, writer: &mut TableWriter) {
484        self.condition_count.write_into(writer);
485        self.conditions.write_into(writer);
486    }
487    fn table_type(&self) -> TableType {
488        TableType::Named("ConditionList")
489    }
490}
491
492impl Validate for ConditionList {
493    fn validate_impl(&self, ctx: &mut ValidationCtx) {
494        ctx.in_table("ConditionList", |ctx| {
495            ctx.in_field("conditions", |ctx| {
496                if self.conditions.len() > to_usize(u32::MAX) {
497                    ctx.report("array exceeds max length");
498                }
499                self.conditions.validate_impl(ctx);
500            });
501        })
502    }
503}
504
505impl<'a> FromObjRef<read_fonts::tables::varc::ConditionList<'a>> for ConditionList {
506    fn from_obj_ref(obj: &read_fonts::tables::varc::ConditionList<'a>, _: FontData) -> Self {
507        ConditionList {
508            condition_count: obj.condition_count(),
509            conditions: obj.conditions().to_owned_table(),
510        }
511    }
512}
513
514#[allow(clippy::needless_lifetimes)]
515impl<'a> FromTableRef<read_fonts::tables::varc::ConditionList<'a>> for ConditionList {}
516
517impl ReadArgs for ConditionList {
518    type Args = ();
519}
520
521impl<'a> FontRead<'a> for ConditionList {
522    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
523        <read_fonts::tables::varc::ConditionList as FontRead>::read(data)
524            .map(|x| x.to_owned_table())
525    }
526}
527
528impl FontWrite for VarcFlags {
529    fn write_into(&self, writer: &mut TableWriter) {
530        writer.write_slice(&self.bits().to_be_bytes())
531    }
532}
write_fonts/generated/generated_varc.rs

write_fonts/generated/
generated_varc.rs
