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: u32,
198    pub regions: Vec<OffsetMarker<SparseVariationRegion, WIDTH_32>>,
199}
200
201impl SparseVariationRegionList {
202    /// Construct a new `SparseVariationRegionList`
203    pub fn new(region_count: u32, 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(u32::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 axis_coordinates: Vec<OffsetMarker<SparseRegionAxisCoordinates, WIDTH_32>>,
270}
271
272impl SparseVariationRegion {
273    /// Construct a new `SparseVariationRegion`
274    pub fn new(region_axis_count: u16, axis_coordinates: Vec<SparseRegionAxisCoordinates>) -> Self {
275        Self {
276            region_axis_count,
277            axis_coordinates: axis_coordinates.into_iter().map(Into::into).collect(),
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.axis_coordinates.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("axis_coordinates", |ctx| {
296                if self.axis_coordinates.len() > to_usize(u16::MAX) {
297                    ctx.report("array exceeds max length");
298                }
299                self.axis_coordinates.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        SparseVariationRegion {
311            region_axis_count: obj.region_axis_count(),
312            axis_coordinates: obj.axis_coordinates().to_owned_table(),
313        }
314    }
315}
316
317#[allow(clippy::needless_lifetimes)]
318impl<'a> FromTableRef<read_fonts::tables::varc::SparseVariationRegion<'a>>
319    for SparseVariationRegion
320{
321}
322
323impl ReadArgs for SparseVariationRegion {
324    type Args = ();
325}
326
327impl<'a> FontRead<'a> for SparseVariationRegion {
328    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
329        <read_fonts::tables::varc::SparseVariationRegion as FontRead>::read(data)
330            .map(|x| x.to_owned_table())
331    }
332}
333
334#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
335#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
336pub struct SparseRegionAxisCoordinates {
337    pub axis_index: u16,
338    pub start: F2Dot14,
339    pub peak: F2Dot14,
340    pub end: F2Dot14,
341}
342
343impl SparseRegionAxisCoordinates {
344    /// Construct a new `SparseRegionAxisCoordinates`
345    pub fn new(axis_index: u16, start: F2Dot14, peak: F2Dot14, end: F2Dot14) -> Self {
346        Self {
347            axis_index,
348            start,
349            peak,
350            end,
351        }
352    }
353}
354
355impl FontWrite for SparseRegionAxisCoordinates {
356    fn write_into(&self, writer: &mut TableWriter) {
357        self.axis_index.write_into(writer);
358        self.start.write_into(writer);
359        self.peak.write_into(writer);
360        self.end.write_into(writer);
361    }
362    fn table_type(&self) -> TableType {
363        TableType::Named("SparseRegionAxisCoordinates")
364    }
365}
366
367impl Validate for SparseRegionAxisCoordinates {
368    fn validate_impl(&self, _ctx: &mut ValidationCtx) {}
369}
370
371impl<'a> FromObjRef<read_fonts::tables::varc::SparseRegionAxisCoordinates<'a>>
372    for SparseRegionAxisCoordinates
373{
374    fn from_obj_ref(
375        obj: &read_fonts::tables::varc::SparseRegionAxisCoordinates<'a>,
376        _: FontData,
377    ) -> Self {
378        SparseRegionAxisCoordinates {
379            axis_index: obj.axis_index(),
380            start: obj.start(),
381            peak: obj.peak(),
382            end: obj.end(),
383        }
384    }
385}
386
387#[allow(clippy::needless_lifetimes)]
388impl<'a> FromTableRef<read_fonts::tables::varc::SparseRegionAxisCoordinates<'a>>
389    for SparseRegionAxisCoordinates
390{
391}
392
393impl ReadArgs for SparseRegionAxisCoordinates {
394    type Args = ();
395}
396
397impl<'a> FontRead<'a> for SparseRegionAxisCoordinates {
398    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
399        <read_fonts::tables::varc::SparseRegionAxisCoordinates as FontRead>::read(data)
400            .map(|x| x.to_owned_table())
401    }
402}
403
404#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
405#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
406pub struct MultiItemVariationData {
407    pub region_index_count: u16,
408    pub region_indices: Vec<u16>,
409    pub delta_sets: OffsetMarker<Index2, WIDTH_32>,
410}
411
412impl MultiItemVariationData {
413    /// Construct a new `MultiItemVariationData`
414    pub fn new(region_index_count: u16, region_indices: Vec<u16>, delta_sets: Index2) -> Self {
415        Self {
416            region_index_count,
417            region_indices,
418            delta_sets: delta_sets.into(),
419        }
420    }
421}
422
423impl FontWrite for MultiItemVariationData {
424    #[allow(clippy::unnecessary_cast)]
425    fn write_into(&self, writer: &mut TableWriter) {
426        (1 as u8).write_into(writer);
427        self.region_index_count.write_into(writer);
428        self.region_indices.write_into(writer);
429        self.delta_sets.write_into(writer);
430    }
431    fn table_type(&self) -> TableType {
432        TableType::Named("MultiItemVariationData")
433    }
434}
435
436impl Validate for MultiItemVariationData {
437    fn validate_impl(&self, ctx: &mut ValidationCtx) {
438        ctx.in_table("MultiItemVariationData", |ctx| {
439            ctx.in_field("region_indices", |ctx| {
440                if self.region_indices.len() > to_usize(u16::MAX) {
441                    ctx.report("array exceeds max length");
442                }
443            });
444            ctx.in_field("delta_sets", |ctx| {
445                self.delta_sets.validate_impl(ctx);
446            });
447        })
448    }
449}
450
451impl<'a> FromObjRef<read_fonts::tables::varc::MultiItemVariationData<'a>>
452    for MultiItemVariationData
453{
454    fn from_obj_ref(
455        obj: &read_fonts::tables::varc::MultiItemVariationData<'a>,
456        _: FontData,
457    ) -> Self {
458        let offset_data = obj.offset_data();
459        MultiItemVariationData {
460            region_index_count: obj.region_index_count(),
461            region_indices: obj.region_indices().to_owned_obj(offset_data),
462            delta_sets: obj.delta_sets().to_owned_table(),
463        }
464    }
465}
466
467#[allow(clippy::needless_lifetimes)]
468impl<'a> FromTableRef<read_fonts::tables::varc::MultiItemVariationData<'a>>
469    for MultiItemVariationData
470{
471}
472
473impl ReadArgs for MultiItemVariationData {
474    type Args = ();
475}
476
477impl<'a> FontRead<'a> for MultiItemVariationData {
478    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
479        <read_fonts::tables::varc::MultiItemVariationData as FontRead>::read(data)
480            .map(|x| x.to_owned_table())
481    }
482}
483
484#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
485#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
486pub struct ConditionList {
487    pub condition_count: u32,
488    pub conditions: Vec<OffsetMarker<Condition, WIDTH_32>>,
489}
490
491impl ConditionList {
492    /// Construct a new `ConditionList`
493    pub fn new(condition_count: u32, conditions: Vec<Condition>) -> Self {
494        Self {
495            condition_count,
496            conditions: conditions.into_iter().map(Into::into).collect(),
497        }
498    }
499}
500
501impl FontWrite for ConditionList {
502    fn write_into(&self, writer: &mut TableWriter) {
503        self.condition_count.write_into(writer);
504        self.conditions.write_into(writer);
505    }
506    fn table_type(&self) -> TableType {
507        TableType::Named("ConditionList")
508    }
509}
510
511impl Validate for ConditionList {
512    fn validate_impl(&self, ctx: &mut ValidationCtx) {
513        ctx.in_table("ConditionList", |ctx| {
514            ctx.in_field("conditions", |ctx| {
515                if self.conditions.len() > to_usize(u32::MAX) {
516                    ctx.report("array exceeds max length");
517                }
518                self.conditions.validate_impl(ctx);
519            });
520        })
521    }
522}
523
524impl<'a> FromObjRef<read_fonts::tables::varc::ConditionList<'a>> for ConditionList {
525    fn from_obj_ref(obj: &read_fonts::tables::varc::ConditionList<'a>, _: FontData) -> Self {
526        ConditionList {
527            condition_count: obj.condition_count(),
528            conditions: obj.conditions().to_owned_table(),
529        }
530    }
531}
532
533#[allow(clippy::needless_lifetimes)]
534impl<'a> FromTableRef<read_fonts::tables::varc::ConditionList<'a>> for ConditionList {}
535
536impl ReadArgs for ConditionList {
537    type Args = ();
538}
539
540impl<'a> FontRead<'a> for ConditionList {
541    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
542        <read_fonts::tables::varc::ConditionList as FontRead>::read(data)
543            .map(|x| x.to_owned_table())
544    }
545}
546
547impl FontWrite for VarcFlags {
548    fn write_into(&self, writer: &mut TableWriter) {
549        writer.write_slice(&self.bits().to_be_bytes())
550    }
551}
write_fonts/generated/generated_varc.rs

write_fonts/generated/
generated_varc.rs
