write_fonts/generated/

generated_ift.rs

// 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::ift::{
    EntryFormatFlags, GlyphKeyedFlags, PatchMapFieldPresenceFlags, TablePatchFlags,
};

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

/// [Patch Map Table](https://w3c.github.io/IFT/Overview.html#patch-map-table)
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IftPatchMap {
    /// Format identifier: format = 2
    pub format: u8,
    pub field_flags: PatchMapFieldPresenceFlags,
    /// Unique ID that identifies compatible patches.
    pub compatibility_id: CompatibilityId,
    /// Patch format number for patches referenced by this mapping.
    pub default_patch_format: u8,
    pub entry_count: Uint24,
    pub entries: OffsetMarker<MappingEntries, WIDTH_32>,
    pub entry_id_string_data: NullableOffsetMarker<IdStringData, WIDTH_32>,
    pub url_template_length: u16,
    pub url_template: Vec<u8>,
    pub cff_charstrings_offset: Option<u32>,
    pub cff2_charstrings_offset: Option<u32>,
}

impl IftPatchMap {
    /// Construct a new `IftPatchMap`
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        format: u8,
        field_flags: PatchMapFieldPresenceFlags,
        compatibility_id: CompatibilityId,
        default_patch_format: u8,
        entry_count: Uint24,
        entries: MappingEntries,
        entry_id_string_data: Option<IdStringData>,
        url_template_length: u16,
        url_template: Vec<u8>,
    ) -> Self {
        Self {
            format,
            field_flags,
            compatibility_id,
            default_patch_format,
            entry_count,
            entries: entries.into(),
            entry_id_string_data: entry_id_string_data.into(),
            url_template_length,
            url_template,
            ..Default::default()
        }
    }
}

impl FontWrite for IftPatchMap {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        self.format.write_into(writer);
        (0 as u8).write_into(writer);
        (0 as u8).write_into(writer);
        (0 as u8).write_into(writer);
        self.field_flags.write_into(writer);
        self.compatibility_id.write_into(writer);
        self.default_patch_format.write_into(writer);
        self.entry_count.write_into(writer);
        self.entries.write_into(writer);
        self.entry_id_string_data.write_into(writer);
        self.url_template_length.write_into(writer);
        self.url_template.write_into(writer);
        self.field_flags
            .contains(PatchMapFieldPresenceFlags::CFF_CHARSTRINGS_OFFSET)
            .then(|| {
                self.cff_charstrings_offset
                    .as_ref()
                    .expect("missing conditional field should have failed validation")
                    .write_into(writer)
            });
        self.field_flags
            .contains(PatchMapFieldPresenceFlags::CFF2_CHARSTRINGS_OFFSET)
            .then(|| {
                self.cff2_charstrings_offset
                    .as_ref()
                    .expect("missing conditional field should have failed validation")
                    .write_into(writer)
            });
    }
    fn table_type(&self) -> TableType {
        TableType::Named("IftPatchMap")
    }
}

impl Validate for IftPatchMap {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("IftPatchMap", |ctx| {
            ctx.in_field("entries", |ctx| {
                self.entries.validate_impl(ctx);
            });
            ctx.in_field("entry_id_string_data", |ctx| {
                self.entry_id_string_data.validate_impl(ctx);
            });
            ctx.in_field("url_template", |ctx| {
                if self.url_template.len() > to_usize(u16::MAX) {
                    ctx.report("array exceeds max length");
                }
            });
            ctx.in_field("cff_charstrings_offset", |ctx| {
                if !(self
                    .field_flags
                    .contains(PatchMapFieldPresenceFlags::CFF_CHARSTRINGS_OFFSET))
                    && self.cff_charstrings_offset.is_some()
                {
                    ctx.report(
                        "'cff_charstrings_offset' is present but CFF_CHARSTRINGS_OFFSET not set",
                    )
                }
                if (self
                    .field_flags
                    .contains(PatchMapFieldPresenceFlags::CFF_CHARSTRINGS_OFFSET))
                    && self.cff_charstrings_offset.is_none()
                {
                    ctx.report("CFF_CHARSTRINGS_OFFSET is set but 'cff_charstrings_offset' is None")
                }
            });
            ctx.in_field("cff2_charstrings_offset", |ctx| {
                if !(self
                    .field_flags
                    .contains(PatchMapFieldPresenceFlags::CFF2_CHARSTRINGS_OFFSET))
                    && self.cff2_charstrings_offset.is_some()
                {
                    ctx.report(
                        "'cff2_charstrings_offset' is present but CFF2_CHARSTRINGS_OFFSET not set",
                    )
                }
                if (self
                    .field_flags
                    .contains(PatchMapFieldPresenceFlags::CFF2_CHARSTRINGS_OFFSET))
                    && self.cff2_charstrings_offset.is_none()
                {
                    ctx.report(
                        "CFF2_CHARSTRINGS_OFFSET is set but 'cff2_charstrings_offset' is None",
                    )
                }
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::ift::IftPatchMap<'a>> for IftPatchMap {
    fn from_obj_ref(obj: &read_fonts::tables::ift::IftPatchMap<'a>, _: FontData) -> Self {
        let offset_data = obj.offset_data();
        IftPatchMap {
            format: obj.format(),
            field_flags: obj.field_flags(),
            compatibility_id: obj.compatibility_id(),
            default_patch_format: obj.default_patch_format(),
            entry_count: obj.entry_count(),
            entries: obj.entries().to_owned_table(),
            entry_id_string_data: obj.entry_id_string_data().to_owned_table(),
            url_template_length: obj.url_template_length(),
            url_template: obj.url_template().to_owned_obj(offset_data),
            cff_charstrings_offset: obj.cff_charstrings_offset(),
            cff2_charstrings_offset: obj.cff2_charstrings_offset(),
        }
    }
}

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

impl ReadArgs for IftPatchMap {
    type Args = ();
}

impl<'a> FontRead<'a> for IftPatchMap {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        <read_fonts::tables::ift::IftPatchMap 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 MappingEntries {
    pub entry_data: Vec<u8>,
}

impl MappingEntries {
    /// Construct a new `MappingEntries`
    pub fn new(entry_data: Vec<u8>) -> Self {
        Self { entry_data }
    }
}

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

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

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

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

impl ReadArgs for MappingEntries {
    type Args = ();
}

impl<'a> FontRead<'a> for MappingEntries {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        <read_fonts::tables::ift::MappingEntries 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 EntryData {
    pub format_flags: EntryFormatFlags,
    pub feature_count: Option<u8>,
    pub feature_tags: Option<Vec<Tag>>,
    pub design_space_count: Option<u16>,
    pub design_space_segments: Option<Vec<DesignSpaceSegment>>,
    pub child_indices: Option<Vec<Uint24>>,
    pub trailing_data: Vec<u8>,
}

impl EntryData {
    /// Construct a new `EntryData`
    pub fn new(format_flags: EntryFormatFlags, trailing_data: Vec<u8>) -> Self {
        Self {
            format_flags,
            trailing_data,
            ..Default::default()
        }
    }
}

impl FontWrite for EntryData {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        self.format_flags.write_into(writer);
        self.format_flags
            .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE)
            .then(|| {
                self.feature_count
                    .as_ref()
                    .expect("missing conditional field should have failed validation")
                    .write_into(writer)
            });
        self.format_flags
            .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE)
            .then(|| {
                self.feature_tags
                    .as_ref()
                    .expect("missing conditional field should have failed validation")
                    .write_into(writer)
            });
        self.format_flags
            .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE)
            .then(|| {
                self.design_space_count
                    .as_ref()
                    .expect("missing conditional field should have failed validation")
                    .write_into(writer)
            });
        self.format_flags
            .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE)
            .then(|| {
                self.design_space_segments
                    .as_ref()
                    .expect("missing conditional field should have failed validation")
                    .write_into(writer)
            });
        self.format_flags
            .contains(EntryFormatFlags::CHILD_INDICES)
            .then(|| {
                self.child_indices
                    .as_ref()
                    .expect("missing conditional field should have failed validation")
                    .write_into(writer)
            });
        self.trailing_data.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("EntryData")
    }
}

impl Validate for EntryData {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("EntryData", |ctx| {
            ctx.in_field("feature_count", |ctx| {
                if !(self
                    .format_flags
                    .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE))
                    && self.feature_count.is_some()
                {
                    ctx.report("'feature_count' is present but FEATURES_AND_DESIGN_SPACE not set")
                }
                if (self
                    .format_flags
                    .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE))
                    && self.feature_count.is_none()
                {
                    ctx.report("FEATURES_AND_DESIGN_SPACE is set but 'feature_count' is None")
                }
            });
            ctx.in_field("feature_tags", |ctx| {
                if !(self
                    .format_flags
                    .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE))
                    && self.feature_tags.is_some()
                {
                    ctx.report("'feature_tags' is present but FEATURES_AND_DESIGN_SPACE not set")
                }
                if (self
                    .format_flags
                    .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE))
                    && self.feature_tags.is_none()
                {
                    ctx.report("FEATURES_AND_DESIGN_SPACE is set but 'feature_tags' is None")
                }
                if self.feature_tags.is_some()
                    && self.feature_tags.as_ref().unwrap().len() > to_usize(u8::MAX)
                {
                    ctx.report("array exceeds max length");
                }
            });
            ctx.in_field("design_space_count", |ctx| {
                if !(self
                    .format_flags
                    .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE))
                    && self.design_space_count.is_some()
                {
                    ctx.report(
                        "'design_space_count' is present but FEATURES_AND_DESIGN_SPACE not set",
                    )
                }
                if (self
                    .format_flags
                    .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE))
                    && self.design_space_count.is_none()
                {
                    ctx.report("FEATURES_AND_DESIGN_SPACE is set but 'design_space_count' is None")
                }
            });
            ctx.in_field("design_space_segments", |ctx| {
                if !(self
                    .format_flags
                    .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE))
                    && self.design_space_segments.is_some()
                {
                    ctx.report(
                        "'design_space_segments' is present but FEATURES_AND_DESIGN_SPACE not set",
                    )
                }
                if (self
                    .format_flags
                    .contains(EntryFormatFlags::FEATURES_AND_DESIGN_SPACE))
                    && self.design_space_segments.is_none()
                {
                    ctx.report(
                        "FEATURES_AND_DESIGN_SPACE is set but 'design_space_segments' is None",
                    )
                }
                if self.design_space_segments.is_some()
                    && self.design_space_segments.as_ref().unwrap().len() > to_usize(u16::MAX)
                {
                    ctx.report("array exceeds max length");
                }
                self.design_space_segments.validate_impl(ctx);
            });
            ctx.in_field("child_indices", |ctx| {
                if !(self.format_flags.contains(EntryFormatFlags::CHILD_INDICES))
                    && self.child_indices.is_some()
                {
                    ctx.report("'child_indices' is present but CHILD_INDICES not set")
                }
                if (self.format_flags.contains(EntryFormatFlags::CHILD_INDICES))
                    && self.child_indices.is_none()
                {
                    ctx.report("CHILD_INDICES is set but 'child_indices' is None")
                }
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::ift::EntryData<'a>> for EntryData {
    fn from_obj_ref(obj: &read_fonts::tables::ift::EntryData<'a>, _: FontData) -> Self {
        let offset_data = obj.offset_data();
        EntryData {
            format_flags: obj.format_flags(),
            feature_count: obj.feature_count(),
            feature_tags: obj.feature_tags().to_owned_obj(offset_data),
            design_space_count: obj.design_space_count(),
            design_space_segments: obj.design_space_segments().to_owned_obj(offset_data),
            child_indices: obj.child_indices().to_owned_obj(offset_data),
            trailing_data: obj.trailing_data().to_owned_obj(offset_data),
        }
    }
}

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

impl ReadArgs for EntryData {
    type Args = ();
}

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

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

#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DesignSpaceSegment {
    pub axis_tag: Tag,
    pub start: Fixed,
    pub end: Fixed,
}

impl DesignSpaceSegment {
    /// Construct a new `DesignSpaceSegment`
    pub fn new(axis_tag: Tag, start: Fixed, end: Fixed) -> Self {
        Self {
            axis_tag,
            start,
            end,
        }
    }
}

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

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

impl FromObjRef<read_fonts::tables::ift::DesignSpaceSegment> for DesignSpaceSegment {
    fn from_obj_ref(obj: &read_fonts::tables::ift::DesignSpaceSegment, _: FontData) -> Self {
        DesignSpaceSegment {
            axis_tag: obj.axis_tag(),
            start: obj.start(),
            end: obj.end(),
        }
    }
}

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

impl IdStringData {
    /// Construct a new `IdStringData`
    pub fn new(id_data: Vec<u8>) -> Self {
        Self { id_data }
    }
}

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

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

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

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

impl ReadArgs for IdStringData {
    type Args = ();
}

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

/// [Table Keyed Patch](https://w3c.github.io/IFT/Overview.html#table-keyed)
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TableKeyedPatch {
    pub format: Tag,
    /// Unique ID that identifies compatible patches.
    pub compatibility_id: CompatibilityId,
    pub patches_count: u16,
    pub patches: Vec<OffsetMarker<TablePatch, WIDTH_32>>,
}

impl TableKeyedPatch {
    /// Construct a new `TableKeyedPatch`
    pub fn new(
        format: Tag,
        compatibility_id: CompatibilityId,
        patches_count: u16,
        patches: Vec<TablePatch>,
    ) -> Self {
        Self {
            format,
            compatibility_id,
            patches_count,
            patches: patches.into_iter().map(Into::into).collect(),
        }
    }
}

impl FontWrite for TableKeyedPatch {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        self.format.write_into(writer);
        (0 as u32).write_into(writer);
        self.compatibility_id.write_into(writer);
        self.patches_count.write_into(writer);
        self.patches.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("TableKeyedPatch")
    }
}

impl Validate for TableKeyedPatch {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("TableKeyedPatch", |ctx| {
            ctx.in_field("patches", |ctx| {
                self.patches.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::ift::TableKeyedPatch<'a>> for TableKeyedPatch {
    fn from_obj_ref(obj: &read_fonts::tables::ift::TableKeyedPatch<'a>, _: FontData) -> Self {
        TableKeyedPatch {
            format: obj.format(),
            compatibility_id: obj.compatibility_id(),
            patches_count: obj.patches_count(),
            patches: obj.patches().to_owned_table(),
        }
    }
}

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

impl ReadArgs for TableKeyedPatch {
    type Args = ();
}

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

/// [TablePatch](https://w3c.github.io/IFT/Overview.html#tablepatch)
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TablePatch {
    pub tag: Tag,
    pub flags: TablePatchFlags,
    pub max_uncompressed_length: u32,
    pub brotli_stream: Vec<u8>,
}

impl TablePatch {
    /// Construct a new `TablePatch`
    pub fn new(
        tag: Tag,
        flags: TablePatchFlags,
        max_uncompressed_length: u32,
        brotli_stream: Vec<u8>,
    ) -> Self {
        Self {
            tag,
            flags,
            max_uncompressed_length,
            brotli_stream,
        }
    }
}

impl FontWrite for TablePatch {
    fn write_into(&self, writer: &mut TableWriter) {
        self.tag.write_into(writer);
        self.flags.write_into(writer);
        self.max_uncompressed_length.write_into(writer);
        self.brotli_stream.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("TablePatch")
    }
}

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

impl<'a> FromObjRef<read_fonts::tables::ift::TablePatch<'a>> for TablePatch {
    fn from_obj_ref(obj: &read_fonts::tables::ift::TablePatch<'a>, _: FontData) -> Self {
        let offset_data = obj.offset_data();
        TablePatch {
            tag: obj.tag(),
            flags: obj.flags(),
            max_uncompressed_length: obj.max_uncompressed_length(),
            brotli_stream: obj.brotli_stream().to_owned_obj(offset_data),
        }
    }
}

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

impl ReadArgs for TablePatch {
    type Args = ();
}

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

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

/// [Glyph Keyed Patch](https://w3c.github.io/IFT/Overview.html#glyph-keyed)
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GlyphKeyedPatch {
    pub format: Tag,
    pub flags: GlyphKeyedFlags,
    pub compatibility_id: CompatibilityId,
    pub max_uncompressed_length: u32,
    pub brotli_stream: Vec<u8>,
}

impl GlyphKeyedPatch {
    /// Construct a new `GlyphKeyedPatch`
    pub fn new(
        format: Tag,
        flags: GlyphKeyedFlags,
        compatibility_id: CompatibilityId,
        max_uncompressed_length: u32,
        brotli_stream: Vec<u8>,
    ) -> Self {
        Self {
            format,
            flags,
            compatibility_id,
            max_uncompressed_length,
            brotli_stream,
        }
    }
}

impl FontWrite for GlyphKeyedPatch {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        self.format.write_into(writer);
        (0 as u32).write_into(writer);
        self.flags.write_into(writer);
        self.compatibility_id.write_into(writer);
        self.max_uncompressed_length.write_into(writer);
        self.brotli_stream.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("GlyphKeyedPatch")
    }
}

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

impl<'a> FromObjRef<read_fonts::tables::ift::GlyphKeyedPatch<'a>> for GlyphKeyedPatch {
    fn from_obj_ref(obj: &read_fonts::tables::ift::GlyphKeyedPatch<'a>, _: FontData) -> Self {
        let offset_data = obj.offset_data();
        GlyphKeyedPatch {
            format: obj.format(),
            flags: obj.flags(),
            compatibility_id: obj.compatibility_id(),
            max_uncompressed_length: obj.max_uncompressed_length(),
            brotli_stream: obj.brotli_stream().to_owned_obj(offset_data),
        }
    }
}

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

impl ReadArgs for GlyphKeyedPatch {
    type Args = ();
}

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

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

/// [GlyphPatches](https://w3c.github.io/IFT/Overview.html#glyphpatches)
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GlyphPatches {
    pub glyph_count: u32,
    pub table_count: u8,
    pub tables: Vec<Tag>,
    pub glyph_data: Vec<OffsetMarker<GlyphData, WIDTH_32>>,
}

impl GlyphPatches {
    /// Construct a new `GlyphPatches`
    pub fn new(
        glyph_count: u32,
        table_count: u8,
        tables: Vec<Tag>,
        glyph_data: Vec<GlyphData>,
    ) -> Self {
        Self {
            glyph_count,
            table_count,
            tables,
            glyph_data: glyph_data.into_iter().map(Into::into).collect(),
        }
    }
}

impl FontWrite for GlyphPatches {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        self.glyph_count.write_into(writer);
        self.table_count.write_into(writer);
        self.tables.write_into(writer);
        self.glyph_data.write_into(writer);
    }
    fn table_type(&self) -> TableType {
        TableType::Named("GlyphPatches")
    }
}

impl Validate for GlyphPatches {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("GlyphPatches", |ctx| {
            ctx.in_field("tables", |ctx| {
                if self.tables.len() > to_usize(u8::MAX) {
                    ctx.report("array exceeds max length");
                }
            });
            ctx.in_field("glyph_data", |ctx| {
                self.glyph_data.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::ift::GlyphPatches<'a>> for GlyphPatches {
    fn from_obj_ref(obj: &read_fonts::tables::ift::GlyphPatches<'a>, _: FontData) -> Self {
        let offset_data = obj.offset_data();
        GlyphPatches {
            glyph_count: obj.glyph_count(),
            table_count: obj.table_count(),
            tables: obj.tables().to_owned_obj(offset_data),
            glyph_data: obj.glyph_data().to_owned_table(),
        }
    }
}

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

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

impl GlyphData {
    /// Construct a new `GlyphData`
    pub fn new(data: Vec<u8>) -> Self {
        Self { data }
    }
}

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

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

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

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

impl ReadArgs for GlyphData {
    type Args = ();
}

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