write-fonts 0.48.1

// 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::*;

pub use read_fonts::tables::varc::VarcFlags;

/// [VARC](https://github.com/harfbuzz/boring-expansion-spec/blob/main/VARC.md) (Variable Composites / Components Table)
///
/// [FontTools VARC](https://github.com/fonttools/fonttools/blob/5e6b12d12fa08abafbeb7570f47707fbedf69a45/Lib/fontTools/ttLib/tables/otData.py#L3459-L3476)
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Varc {
    pub coverage: OffsetMarker<CoverageTable, WIDTH_32>,
    pub multi_var_store: NullableOffsetMarker<MultiItemVariationStore, WIDTH_32>,
    pub condition_list: NullableOffsetMarker<ConditionList, WIDTH_32>,
    pub axis_indices_list: NullableOffsetMarker<Index2, WIDTH_32>,
    pub var_composite_glyphs: OffsetMarker<Index2, WIDTH_32>,
}

impl Varc {
    /// Construct a new `Varc`
    pub fn new(
        coverage: CoverageTable,
        multi_var_store: Option<MultiItemVariationStore>,
        condition_list: Option<ConditionList>,
        axis_indices_list: Option<Index2>,
        var_composite_glyphs: Index2,
    ) -> Self {
        Self {
            coverage: coverage.into(),
            multi_var_store: multi_var_store.into(),
            condition_list: condition_list.into(),
            axis_indices_list: axis_indices_list.into(),
            var_composite_glyphs: var_composite_glyphs.into(),
        }
    }
}

impl FontWrite for Varc {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        (MajorMinor::VERSION_1_0 as MajorMinor).write_into(writer);
        self.coverage.write_into(writer);
        self.multi_var_store.write_into(writer);
        self.condition_list.write_into(writer);
        self.axis_indices_list.write_into(writer);
        self.var_composite_glyphs.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::TopLevel(Varc::TAG)
    }
}

impl Validate for Varc {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("Varc", |ctx| {
            ctx.in_field("coverage", |ctx| {
                self.coverage.validate_impl(ctx);
            });
            ctx.in_field("multi_var_store", |ctx| {
                self.multi_var_store.validate_impl(ctx);
            });
            ctx.in_field("condition_list", |ctx| {
                self.condition_list.validate_impl(ctx);
            });
            ctx.in_field("axis_indices_list", |ctx| {
                self.axis_indices_list.validate_impl(ctx);
            });
            ctx.in_field("var_composite_glyphs", |ctx| {
                self.var_composite_glyphs.validate_impl(ctx);
            });
        })
    }
}

impl TopLevelTable for Varc {
    const TAG: Tag = Tag::new(b"VARC");
}

impl<'a> FromObjRef<read_fonts::tables::varc::Varc<'a>> for Varc {
    fn from_obj_ref(obj: &read_fonts::tables::varc::Varc<'a>, _: FontData) -> Self {
        Varc {
            coverage: obj.coverage().to_owned_table(),
            multi_var_store: obj.multi_var_store().to_owned_table(),
            condition_list: obj.condition_list().to_owned_table(),
            axis_indices_list: obj.axis_indices_list().to_owned_table(),
            var_composite_glyphs: obj.var_composite_glyphs().to_owned_table(),
        }
    }
}

#[allow(clippy::needless_lifetimes)]
impl<'a> FromTableRef<read_fonts::tables::varc::Varc<'a>> for Varc {}

impl<'a> FontRead<'a> for Varc {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::varc::Varc as FontRead>::read(data).map(|x| x.to_owned_table())
    }
}

/// * <https://github.com/fonttools/fonttools/blob/5e6b12d12fa08abafbeb7570f47707fbedf69a45/Lib/fontTools/ttLib/tables/otData.py#L3451-L3457>
/// * <https://github.com/harfbuzz/harfbuzz/blob/7be12b33e3f07067c159d8f516eb31df58c75876/src/hb-ot-layout-common.hh#L3517-L3520C3>
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MultiItemVariationStore {
    pub region_list: OffsetMarker<SparseVariationRegionList, WIDTH_32>,
    pub variation_data_count: u16,
    pub variation_data: Vec<OffsetMarker<MultiItemVariationData, WIDTH_32>>,
}

impl MultiItemVariationStore {
    /// Construct a new `MultiItemVariationStore`
    pub fn new(
        region_list: SparseVariationRegionList,
        variation_data_count: u16,
        variation_data: Vec<MultiItemVariationData>,
    ) -> Self {
        Self {
            region_list: region_list.into(),
            variation_data_count,
            variation_data: variation_data.into_iter().map(Into::into).collect(),
        }
    }
}

impl FontWrite for MultiItemVariationStore {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        (1 as u16).write_into(writer);
        self.region_list.write_into(writer);
        self.variation_data_count.write_into(writer);
        self.variation_data.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("MultiItemVariationStore")
    }
}

impl Validate for MultiItemVariationStore {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("MultiItemVariationStore", |ctx| {
            ctx.in_field("region_list", |ctx| {
                self.region_list.validate_impl(ctx);
            });
            ctx.in_field("variation_data", |ctx| {
                if self.variation_data.len() > (u16::MAX as usize) {
                    ctx.report("array exceeds max length");
                }
                self.variation_data.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::varc::MultiItemVariationStore<'a>>
    for MultiItemVariationStore
{
    fn from_obj_ref(
        obj: &read_fonts::tables::varc::MultiItemVariationStore<'a>,
        _: FontData,
    ) -> Self {
        MultiItemVariationStore {
            region_list: obj.region_list().to_owned_table(),
            variation_data_count: obj.variation_data_count(),
            variation_data: obj.variation_data().to_owned_table(),
        }
    }
}

#[allow(clippy::needless_lifetimes)]
impl<'a> FromTableRef<read_fonts::tables::varc::MultiItemVariationStore<'a>>
    for MultiItemVariationStore
{
}

impl<'a> FontRead<'a> for MultiItemVariationStore {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::varc::MultiItemVariationStore as FontRead>::read(data)
            .map(|x| x.to_owned_table())
    }
}

#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SparseVariationRegionList {
    pub region_count: u16,
    pub regions: Vec<OffsetMarker<SparseVariationRegion, WIDTH_32>>,
}

impl SparseVariationRegionList {
    /// Construct a new `SparseVariationRegionList`
    pub fn new(region_count: u16, regions: Vec<SparseVariationRegion>) -> Self {
        Self {
            region_count,
            regions: regions.into_iter().map(Into::into).collect(),
        }
    }
}

impl FontWrite for SparseVariationRegionList {
    fn write_into(&self, writer: &mut TableWriter) {
        self.region_count.write_into(writer);
        self.regions.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("SparseVariationRegionList")
    }
}

impl Validate for SparseVariationRegionList {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("SparseVariationRegionList", |ctx| {
            ctx.in_field("regions", |ctx| {
                if self.regions.len() > (u16::MAX as usize) {
                    ctx.report("array exceeds max length");
                }
                self.regions.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::varc::SparseVariationRegionList<'a>>
    for SparseVariationRegionList
{
    fn from_obj_ref(
        obj: &read_fonts::tables::varc::SparseVariationRegionList<'a>,
        _: FontData,
    ) -> Self {
        SparseVariationRegionList {
            region_count: obj.region_count(),
            regions: obj.regions().to_owned_table(),
        }
    }
}

#[allow(clippy::needless_lifetimes)]
impl<'a> FromTableRef<read_fonts::tables::varc::SparseVariationRegionList<'a>>
    for SparseVariationRegionList
{
}

impl<'a> FontRead<'a> for SparseVariationRegionList {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::varc::SparseVariationRegionList as FontRead>::read(data)
            .map(|x| x.to_owned_table())
    }
}

#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SparseVariationRegion {
    pub region_axis_count: u16,
    pub region_axes: Vec<SparseRegionAxisCoordinates>,
}

impl SparseVariationRegion {
    /// Construct a new `SparseVariationRegion`
    pub fn new(region_axis_count: u16, region_axes: Vec<SparseRegionAxisCoordinates>) -> Self {
        Self {
            region_axis_count,
            region_axes,
        }
    }
}

impl FontWrite for SparseVariationRegion {
    fn write_into(&self, writer: &mut TableWriter) {
        self.region_axis_count.write_into(writer);
        self.region_axes.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("SparseVariationRegion")
    }
}

impl Validate for SparseVariationRegion {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("SparseVariationRegion", |ctx| {
            ctx.in_field("region_axes", |ctx| {
                if self.region_axes.len() > (u16::MAX as usize) {
                    ctx.report("array exceeds max length");
                }
                self.region_axes.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::varc::SparseVariationRegion<'a>> for SparseVariationRegion {
    fn from_obj_ref(
        obj: &read_fonts::tables::varc::SparseVariationRegion<'a>,
        _: FontData,
    ) -> Self {
        let offset_data = obj.offset_data();
        SparseVariationRegion {
            region_axis_count: obj.region_axis_count(),
            region_axes: obj.region_axes().to_owned_obj(offset_data),
        }
    }
}

#[allow(clippy::needless_lifetimes)]
impl<'a> FromTableRef<read_fonts::tables::varc::SparseVariationRegion<'a>>
    for SparseVariationRegion
{
}

impl<'a> FontRead<'a> for SparseVariationRegion {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::varc::SparseVariationRegion as FontRead>::read(data)
            .map(|x| x.to_owned_table())
    }
}

#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SparseRegionAxisCoordinates {
    pub axis_index: u16,
    pub start: F2Dot14,
    pub peak: F2Dot14,
    pub end: F2Dot14,
}

impl SparseRegionAxisCoordinates {
    /// Construct a new `SparseRegionAxisCoordinates`
    pub fn new(axis_index: u16, start: F2Dot14, peak: F2Dot14, end: F2Dot14) -> Self {
        Self {
            axis_index,
            start,
            peak,
            end,
        }
    }
}

impl FontWrite for SparseRegionAxisCoordinates {
    fn write_into(&self, writer: &mut TableWriter) {
        self.axis_index.write_into(writer);
        self.start.write_into(writer);
        self.peak.write_into(writer);
        self.end.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("SparseRegionAxisCoordinates")
    }
}

impl Validate for SparseRegionAxisCoordinates {
    fn validate_impl(&self, _ctx: &mut ValidationCtx) {}
}

impl FromObjRef<read_fonts::tables::varc::SparseRegionAxisCoordinates>
    for SparseRegionAxisCoordinates
{
    fn from_obj_ref(
        obj: &read_fonts::tables::varc::SparseRegionAxisCoordinates,
        _: FontData,
    ) -> Self {
        SparseRegionAxisCoordinates {
            axis_index: obj.axis_index(),
            start: obj.start(),
            peak: obj.peak(),
            end: obj.end(),
        }
    }
}

#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MultiItemVariationData {
    pub region_index_count: u16,
    pub region_indices: Vec<u16>,
    pub raw_delta_sets: Vec<u8>,
}

impl MultiItemVariationData {
    /// Construct a new `MultiItemVariationData`
    pub fn new(region_index_count: u16, region_indices: Vec<u16>, raw_delta_sets: Vec<u8>) -> Self {
        Self {
            region_index_count,
            region_indices,
            raw_delta_sets,
        }
    }
}

impl FontWrite for MultiItemVariationData {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        (1 as u8).write_into(writer);
        self.region_index_count.write_into(writer);
        self.region_indices.write_into(writer);
        self.raw_delta_sets.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("MultiItemVariationData")
    }
}

impl Validate for MultiItemVariationData {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("MultiItemVariationData", |ctx| {
            ctx.in_field("region_indices", |ctx| {
                if self.region_indices.len() > (u16::MAX as usize) {
                    ctx.report("array exceeds max length");
                }
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::varc::MultiItemVariationData<'a>>
    for MultiItemVariationData
{
    fn from_obj_ref(
        obj: &read_fonts::tables::varc::MultiItemVariationData<'a>,
        _: FontData,
    ) -> Self {
        let offset_data = obj.offset_data();
        MultiItemVariationData {
            region_index_count: obj.region_index_count(),
            region_indices: obj.region_indices().to_owned_obj(offset_data),
            raw_delta_sets: obj.raw_delta_sets().to_owned_obj(offset_data),
        }
    }
}

#[allow(clippy::needless_lifetimes)]
impl<'a> FromTableRef<read_fonts::tables::varc::MultiItemVariationData<'a>>
    for MultiItemVariationData
{
}

impl<'a> FontRead<'a> for MultiItemVariationData {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::varc::MultiItemVariationData as FontRead>::read(data)
            .map(|x| x.to_owned_table())
    }
}

#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ConditionList {
    pub condition_count: u32,
    pub conditions: Vec<OffsetMarker<Condition, WIDTH_32>>,
}

impl ConditionList {
    /// Construct a new `ConditionList`
    pub fn new(condition_count: u32, conditions: Vec<Condition>) -> Self {
        Self {
            condition_count,
            conditions: conditions.into_iter().map(Into::into).collect(),
        }
    }
}

impl FontWrite for ConditionList {
    fn write_into(&self, writer: &mut TableWriter) {
        self.condition_count.write_into(writer);
        self.conditions.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("ConditionList")
    }
}

impl Validate for ConditionList {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("ConditionList", |ctx| {
            ctx.in_field("conditions", |ctx| {
                if self.conditions.len() > (u32::MAX as usize) {
                    ctx.report("array exceeds max length");
                }
                self.conditions.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::varc::ConditionList<'a>> for ConditionList {
    fn from_obj_ref(obj: &read_fonts::tables::varc::ConditionList<'a>, _: FontData) -> Self {
        ConditionList {
            condition_count: obj.condition_count(),
            conditions: obj.conditions().to_owned_table(),
        }
    }
}

#[allow(clippy::needless_lifetimes)]
impl<'a> FromTableRef<read_fonts::tables::varc::ConditionList<'a>> for ConditionList {}

impl<'a> FontRead<'a> for ConditionList {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::varc::ConditionList as FontRead>::read(data)
            .map(|x| x.to_owned_table())
    }
}

impl FontWrite for VarcFlags {
    fn write_into(&self, writer: &mut TableWriter) {
        writer.write_slice(&self.bits().to_be_bytes())
    }
}