/rust/registry/src/index.crates.io-1949cf8c6b5b557f/read-fonts-0.46.0/generated/generated_gdef.rs

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

impl<'a> MinByteRange<'a> for Gdef<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.mark_attach_class_def_offset_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

impl TopLevelTable for Gdef<'_> {
    /// `GDEF`
    const TAG: Tag = Tag::new(b"GDEF");
}

impl ReadArgs for Gdef<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for Gdef<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct GdefFixedHeader {
    pub version: BigEndian<MajorMinor>,
    pub glyph_class_def_offset: BigEndian<Nullable<Offset16>>,
    pub attach_list_offset: BigEndian<Nullable<Offset16>>,
    pub lig_caret_list_offset: BigEndian<Nullable<Offset16>>,
    pub mark_attach_class_def_offset: BigEndian<Nullable<Offset16>>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<GdefFixedHeader>() <= Gdef::MIN_SIZE);

/// [GDEF](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#gdef-header) 1.0
#[derive(Clone)]
pub struct Gdef<'a> {
    data: TableDataRef<'a, GdefFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> Gdef<'a> {
    pub const MIN_SIZE: usize = (MajorMinor::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// The major/minor version of the GDEF table
    pub fn version(&self) -> MajorMinor {
        self.data.header().version.get()
    }

    /// Offset to class definition table for glyph type, from beginning
    /// of GDEF header (may be NULL)
    pub fn glyph_class_def_offset(&self) -> Nullable<Offset16> {
        self.data.header().glyph_class_def_offset.get()
    }

    /// Offset to attachment point list table, from beginning of GDEF
    /// header (may be NULL)
    pub fn attach_list_offset(&self) -> Nullable<Offset16> {
        self.data.header().attach_list_offset.get()
    }

    /// Offset to ligature caret list table, from beginning of GDEF
    /// header (may be NULL)
    pub fn lig_caret_list_offset(&self) -> Nullable<Offset16> {
        self.data.header().lig_caret_list_offset.get()
    }

    /// Offset to class definition table for mark attachment type, from
    /// beginning of GDEF header (may be NULL)
    pub fn mark_attach_class_def_offset(&self) -> Nullable<Offset16> {
        self.data.header().mark_attach_class_def_offset.get()
    }

    /// Offset to the table of mark glyph set definitions, from
    /// beginning of GDEF header (may be NULL)
    pub fn mark_glyph_sets_def_offset(&self) -> Option<Nullable<Offset16>> {
        let range = self.mark_glyph_sets_def_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Offset to the Item Variation Store table, from beginning of
    /// GDEF header (may be NULL)
    pub fn item_var_store_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.item_var_store_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Attempt to resolve [`item_var_store_offset`][Self::item_var_store_offset].
    pub fn item_var_store(&self) -> Option<Result<ItemVariationStore<'a>, ReadError>> {
        let data = self.offset_data();
        self.item_var_store_offset().map(|x| x.resolve(data))?
    }

    /// 32-bit offset taking precedence over glyph_class_def_offset when nonzero.
    pub fn glyph_class_def2_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.glyph_class_def2_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Attempt to resolve [`glyph_class_def2_offset`][Self::glyph_class_def2_offset].
    pub fn glyph_class_def2(&self) -> Option<Result<ClassDef<'a>, ReadError>> {
        let data = self.offset_data();
        self.glyph_class_def2_offset().map(|x| x.resolve(data))?
    }

    /// 32-bit offset taking precedence over attach_list_offset when nonzero.
    pub fn attach_list2_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.attach_list2_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Attempt to resolve [`attach_list2_offset`][Self::attach_list2_offset].
    pub fn attach_list2(&self) -> Option<Result<AttachList<'a>, ReadError>> {
        let data = self.offset_data();
        self.attach_list2_offset().map(|x| x.resolve(data))?
    }

    /// 32-bit offset taking precedence over lig_caret_list_offset when nonzero.
    pub fn lig_caret_list2_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.lig_caret_list2_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Attempt to resolve [`lig_caret_list2_offset`][Self::lig_caret_list2_offset].
    pub fn lig_caret_list2(&self) -> Option<Result<LigCaretList2<'a>, ReadError>> {
        let data = self.offset_data();
        self.lig_caret_list2_offset().map(|x| x.resolve(data))?
    }

    /// 32-bit offset taking precedence over mark_attach_class_def_offset when nonzero.
    pub fn mark_attach_class_def2_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.mark_attach_class_def2_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Attempt to resolve [`mark_attach_class_def2_offset`][Self::mark_attach_class_def2_offset].
    pub fn mark_attach_class_def2(&self) -> Option<Result<ClassDef<'a>, ReadError>> {
        let data = self.offset_data();
        self.mark_attach_class_def2_offset()
            .map(|x| x.resolve(data))?
    }

    /// 32-bit offset taking precedence over mark_glyph_sets_def_offset when nonzero.
    pub fn mark_glyph_sets_def2_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.mark_glyph_sets_def2_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Attempt to resolve [`mark_glyph_sets_def2_offset`][Self::mark_glyph_sets_def2_offset].
    pub fn mark_glyph_sets_def2(&self) -> Option<Result<MarkGlyphSets<'a>, ReadError>> {
        let data = self.offset_data();
        self.mark_glyph_sets_def2_offset()
            .map(|x| x.resolve(data))?
    }

    pub fn version_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + MajorMinor::RAW_BYTE_LEN;
        start..end
    }

    pub fn glyph_class_def_offset_byte_range(&self) -> Range<usize> {
        let start = self.version_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn attach_list_offset_byte_range(&self) -> Range<usize> {
        let start = self.glyph_class_def_offset_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn lig_caret_list_offset_byte_range(&self) -> Range<usize> {
        let start = self.attach_list_offset_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn mark_attach_class_def_offset_byte_range(&self) -> Range<usize> {
        let start = self.lig_caret_list_offset_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn mark_glyph_sets_def_offset_byte_range(&self) -> Range<usize> {
        let start = self.mark_attach_class_def_offset_byte_range().end;
        let end = if self.version().compatible((1u16, 2u16)) {
            start + Offset16::RAW_BYTE_LEN
        } else {
            start
        };
        start..end
    }

    pub fn item_var_store_offset_byte_range(&self) -> Range<usize> {
        let start = self.mark_glyph_sets_def_offset_byte_range().end;
        let end = if self.version().compatible((1u16, 3u16)) {
            start + Offset32::RAW_BYTE_LEN
        } else {
            start
        };
        start..end
    }

    pub fn glyph_class_def2_offset_byte_range(&self) -> Range<usize> {
        let start = self.item_var_store_offset_byte_range().end;
        let end = if self.version().compatible((1u16, 4u16)) {
            start + Offset32::RAW_BYTE_LEN
        } else {
            start
        };
        start..end
    }

    pub fn attach_list2_offset_byte_range(&self) -> Range<usize> {
        let start = self.glyph_class_def2_offset_byte_range().end;
        let end = if self.version().compatible((1u16, 4u16)) {
            start + Offset32::RAW_BYTE_LEN
        } else {
            start
        };
        start..end
    }

    pub fn lig_caret_list2_offset_byte_range(&self) -> Range<usize> {
        let start = self.attach_list2_offset_byte_range().end;
        let end = if self.version().compatible((1u16, 4u16)) {
            start + Offset32::RAW_BYTE_LEN
        } else {
            start
        };
        start..end
    }

    pub fn mark_attach_class_def2_offset_byte_range(&self) -> Range<usize> {
        let start = self.lig_caret_list2_offset_byte_range().end;
        let end = if self.version().compatible((1u16, 4u16)) {
            start + Offset32::RAW_BYTE_LEN
        } else {
            start
        };
        start..end
    }

    pub fn mark_glyph_sets_def2_offset_byte_range(&self) -> Range<usize> {
        let start = self.mark_attach_class_def2_offset_byte_range().end;
        let end = if self.version().compatible((1u16, 4u16)) {
            start + Offset32::RAW_BYTE_LEN
        } else {
            start
        };
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(Gdef::MIN_SIZE));

impl Default for Gdef<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

/// Used in the [Glyph Class Definition Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#glyph-class-definition-table)
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
#[allow(clippy::manual_non_exhaustive)]
pub enum GlyphClassDef {
    #[default]
    Base = 1,
    Ligature = 2,
    Mark = 3,
    Component = 4,
    #[doc(hidden)]
    /// If font data is malformed we will map unknown values to this variant
    Unknown,
}

impl GlyphClassDef {
    /// Create from a raw scalar.
    ///
    /// This will never fail; unknown values will be mapped to the `Unknown` variant
    pub fn new(raw: u16) -> Self {
        match raw {
            1 => Self::Base,
            2 => Self::Ligature,
            3 => Self::Mark,
            4 => Self::Component,
            _ => Self::Unknown,
        }
    }
}

impl font_types::Scalar for GlyphClassDef {
    type Raw = <u16 as font_types::Scalar>::Raw;
    fn to_raw(self) -> Self::Raw {
        (self as u16).to_raw()
    }
    fn from_raw(raw: Self::Raw) -> Self {
        let t = <u16>::from_raw(raw);
        Self::new(t)
    }
}

impl<'a> MinByteRange<'a> for AttachList<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.attach_point_offsets_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for AttachList<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for AttachList<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct AttachListFixedHeader {
    pub coverage_offset: BigEndian<Offset16>,
    pub glyph_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<AttachListFixedHeader>() <= AttachList::MIN_SIZE);

/// [Attachment Point List Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#attachment-point-list-table)
#[derive(Clone)]
pub struct AttachList<'a> {
    data: TableDataRef<'a, AttachListFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> AttachList<'a> {
    pub const MIN_SIZE: usize = (Offset16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Offset to Coverage table - from beginning of AttachList table
    pub fn coverage_offset(&self) -> Offset16 {
        self.data.header().coverage_offset.get()
    }

    /// Attempt to resolve [`coverage_offset`][Self::coverage_offset].
    pub fn coverage(&self) -> Result<CoverageTable<'a>, ReadError> {
        let data = self.offset_data();
        self.coverage_offset().resolve(data)
    }

    /// Number of glyphs with attachment points
    pub fn glyph_count(&self) -> u16 {
        self.data.header().glyph_count.get()
    }

    /// Array of offsets to AttachPoint tables-from beginning of
    /// AttachList table-in Coverage Index order
    pub fn attach_point_offsets(&self) -> &'a [BigEndian<Offset16>] {
        let range = self.attach_point_offsets_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    /// A dynamically resolving wrapper for [`attach_point_offsets`][Self::attach_point_offsets].
    pub fn attach_points(&self) -> ArrayOfOffsets<'a, AttachPoint<'a>, Offset16> {
        let data = self.offset_data();
        let offsets = self.attach_point_offsets();
        ArrayOfOffsets::new(offsets, data, ())
    }

    pub fn coverage_offset_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn glyph_count_byte_range(&self) -> Range<usize> {
        let start = self.coverage_offset_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn attach_point_offsets_byte_range(&self) -> Range<usize> {
        let glyph_count = self.glyph_count();
        let start = self.glyph_count_byte_range().end;
        let end =
            start + (transforms::to_usize(glyph_count)).saturating_mul(Offset16::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(AttachList::MIN_SIZE));

impl Default for AttachList<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

impl<'a> MinByteRange<'a> for AttachPoint<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.point_indices_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for AttachPoint<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for AttachPoint<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct AttachPointFixedHeader {
    pub point_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<AttachPointFixedHeader>() <= AttachPoint::MIN_SIZE);

/// Part of [AttachList]
#[derive(Clone)]
pub struct AttachPoint<'a> {
    data: TableDataRef<'a, AttachPointFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> AttachPoint<'a> {
    pub const MIN_SIZE: usize = u16::RAW_BYTE_LEN;
    basic_table_impls!(impl_the_methods);

    /// Number of attachment points on this glyph
    pub fn point_count(&self) -> u16 {
        self.data.header().point_count.get()
    }

    /// Array of contour point indices -in increasing numerical order
    pub fn point_indices(&self) -> &'a [BigEndian<u16>] {
        let range = self.point_indices_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    pub fn point_count_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn point_indices_byte_range(&self) -> Range<usize> {
        let point_count = self.point_count();
        let start = self.point_count_byte_range().end;
        let end = start + (transforms::to_usize(point_count)).saturating_mul(u16::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(AttachPoint::MIN_SIZE));

impl Default for AttachPoint<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

impl<'a> MinByteRange<'a> for LigCaretList<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.lig_glyph_offsets_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for LigCaretList<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for LigCaretList<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct LigCaretListFixedHeader {
    pub coverage_offset: BigEndian<Offset16>,
    pub lig_glyph_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<LigCaretListFixedHeader>() <= LigCaretList::MIN_SIZE);

/// [Ligature Caret List Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#ligature-caret-list-table)
#[derive(Clone)]
pub struct LigCaretList<'a> {
    data: TableDataRef<'a, LigCaretListFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> LigCaretList<'a> {
    pub const MIN_SIZE: usize = (Offset16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Offset to Coverage table - from beginning of LigCaretList table
    pub fn coverage_offset(&self) -> Offset16 {
        self.data.header().coverage_offset.get()
    }

    /// Attempt to resolve [`coverage_offset`][Self::coverage_offset].
    pub fn coverage(&self) -> Result<CoverageTable<'a>, ReadError> {
        let data = self.offset_data();
        self.coverage_offset().resolve(data)
    }

    /// Number of ligature glyphs
    pub fn lig_glyph_count(&self) -> u16 {
        self.data.header().lig_glyph_count.get()
    }

    /// Array of offsets to LigGlyph tables, from beginning of
    /// LigCaretList table —in Coverage Index order
    pub fn lig_glyph_offsets(&self) -> &'a [BigEndian<Offset16>] {
        let range = self.lig_glyph_offsets_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    /// A dynamically resolving wrapper for [`lig_glyph_offsets`][Self::lig_glyph_offsets].
    pub fn lig_glyphs(&self) -> ArrayOfOffsets<'a, LigGlyph<'a>, Offset16> {
        let data = self.offset_data();
        let offsets = self.lig_glyph_offsets();
        ArrayOfOffsets::new(offsets, data, ())
    }

    pub fn coverage_offset_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn lig_glyph_count_byte_range(&self) -> Range<usize> {
        let start = self.coverage_offset_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn lig_glyph_offsets_byte_range(&self) -> Range<usize> {
        let lig_glyph_count = self.lig_glyph_count();
        let start = self.lig_glyph_count_byte_range().end;
        let end =
            start + (transforms::to_usize(lig_glyph_count)).saturating_mul(Offset16::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(LigCaretList::MIN_SIZE));

impl Default for LigCaretList<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

impl<'a> MinByteRange<'a> for LigGlyph<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.caret_value_offsets_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for LigGlyph<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for LigGlyph<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct LigGlyphFixedHeader {
    pub caret_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<LigGlyphFixedHeader>() <= LigGlyph::MIN_SIZE);

/// [Ligature Glyph Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#ligature-glyph-table)
#[derive(Clone)]
pub struct LigGlyph<'a> {
    data: TableDataRef<'a, LigGlyphFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> LigGlyph<'a> {
    pub const MIN_SIZE: usize = u16::RAW_BYTE_LEN;
    basic_table_impls!(impl_the_methods);

    /// Number of CaretValue tables for this ligature (components - 1)
    pub fn caret_count(&self) -> u16 {
        self.data.header().caret_count.get()
    }

    /// Array of offsets to CaretValue tables, from beginning of
    /// LigGlyph table — in increasing coordinate order
    pub fn caret_value_offsets(&self) -> &'a [BigEndian<Offset16>] {
        let range = self.caret_value_offsets_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    /// A dynamically resolving wrapper for [`caret_value_offsets`][Self::caret_value_offsets].
    pub fn caret_values(&self) -> ArrayOfOffsets<'a, CaretValue<'a>, Offset16> {
        let data = self.offset_data();
        let offsets = self.caret_value_offsets();
        ArrayOfOffsets::new(offsets, data, ())
    }

    pub fn caret_count_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn caret_value_offsets_byte_range(&self) -> Range<usize> {
        let caret_count = self.caret_count();
        let start = self.caret_count_byte_range().end;
        let end =
            start + (transforms::to_usize(caret_count)).saturating_mul(Offset16::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(LigGlyph::MIN_SIZE));

impl Default for LigGlyph<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

/// [Caret Value Tables](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#caret-value-tables)
#[derive(Clone)]
pub enum CaretValue<'a> {
    Format1(CaretValueFormat1<'a>),
    Format2(CaretValueFormat2<'a>),
    Format3(CaretValueFormat3<'a>),
}

impl Default for CaretValue<'_> {
    fn default() -> Self {
        Self::Format1(Default::default())
    }
}

impl<'a> CaretValue<'a> {
    ///Return the `FontData` used to resolve offsets for this table.
    pub fn offset_data(&self) -> FontData<'a> {
        match self {
            Self::Format1(item) => item.offset_data(),
            Self::Format2(item) => item.offset_data(),
            Self::Format3(item) => item.offset_data(),
        }
    }

    /// Format identifier: format = 1
    pub fn caret_value_format(&self) -> u16 {
        match self {
            Self::Format1(item) => item.caret_value_format(),
            Self::Format2(item) => item.caret_value_format(),
            Self::Format3(item) => item.caret_value_format(),
        }
    }
}

impl ReadArgs for CaretValue<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for CaretValue<'a> {
    #[inline]
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        let format: u16 = data.read_at(0usize)?;
        match format {
            CaretValueFormat1::FORMAT => Ok(Self::Format1(FontRead::read(data)?)),
            CaretValueFormat2::FORMAT => Ok(Self::Format2(FontRead::read(data)?)),
            CaretValueFormat3::FORMAT => Ok(Self::Format3(FontRead::read(data)?)),
            other => Err(ReadError::InvalidFormat(other.into())),
        }
    }
}

impl<'a> MinByteRange<'a> for CaretValue<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        match self {
            Self::Format1(item) => item.min_byte_range(),
            Self::Format2(item) => item.min_byte_range(),
            Self::Format3(item) => item.min_byte_range(),
        }
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        match self {
            Self::Format1(item) => item.min_table_bytes(),
            Self::Format2(item) => item.min_table_bytes(),
            Self::Format3(item) => item.min_table_bytes(),
        }
    }
}

impl Format<u16> for CaretValueFormat1<'_> {
    const FORMAT: u16 = 1;
}

impl<'a> MinByteRange<'a> for CaretValueFormat1<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.coordinate_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for CaretValueFormat1<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for CaretValueFormat1<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct CaretValueFormat1FixedHeader {
    pub caret_value_format: BigEndian<u16>,
    pub coordinate: BigEndian<i16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () =
    assert!(std::mem::size_of::<CaretValueFormat1FixedHeader>() <= CaretValueFormat1::MIN_SIZE);

/// [CaretValue Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#caretvalue-format-1)
#[derive(Clone)]
pub struct CaretValueFormat1<'a> {
    data: TableDataRef<'a, CaretValueFormat1FixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> CaretValueFormat1<'a> {
    pub const MIN_SIZE: usize = (u16::RAW_BYTE_LEN + i16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Format identifier: format = 1
    pub fn caret_value_format(&self) -> u16 {
        self.data.header().caret_value_format.get()
    }

    /// X or Y value, in design units
    pub fn coordinate(&self) -> i16 {
        self.data.header().coordinate.get()
    }

    pub fn caret_value_format_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn coordinate_byte_range(&self) -> Range<usize> {
        let start = self.caret_value_format_byte_range().end;
        let end = start + i16::RAW_BYTE_LEN;
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(
    CaretValueFormat1::MIN_SIZE
));

impl Default for CaretValueFormat1<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_format_1_u16_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

impl Format<u16> for CaretValueFormat2<'_> {
    const FORMAT: u16 = 2;
}

impl<'a> MinByteRange<'a> for CaretValueFormat2<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.caret_value_point_index_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for CaretValueFormat2<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for CaretValueFormat2<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct CaretValueFormat2FixedHeader {
    pub caret_value_format: BigEndian<u16>,
    pub caret_value_point_index: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () =
    assert!(std::mem::size_of::<CaretValueFormat2FixedHeader>() <= CaretValueFormat2::MIN_SIZE);

/// [CaretValue Format 2](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#caretvalue-format-2)
#[derive(Clone)]
pub struct CaretValueFormat2<'a> {
    data: TableDataRef<'a, CaretValueFormat2FixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> CaretValueFormat2<'a> {
    pub const MIN_SIZE: usize = (u16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Format identifier: format = 2
    pub fn caret_value_format(&self) -> u16 {
        self.data.header().caret_value_format.get()
    }

    /// Contour point index on glyph
    pub fn caret_value_point_index(&self) -> u16 {
        self.data.header().caret_value_point_index.get()
    }

    pub fn caret_value_format_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn caret_value_point_index_byte_range(&self) -> Range<usize> {
        let start = self.caret_value_format_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }
}

impl Format<u16> for CaretValueFormat3<'_> {
    const FORMAT: u16 = 3;
}

impl<'a> MinByteRange<'a> for CaretValueFormat3<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.device_offset_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for CaretValueFormat3<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for CaretValueFormat3<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct CaretValueFormat3FixedHeader {
    pub caret_value_format: BigEndian<u16>,
    pub coordinate: BigEndian<i16>,
    pub device_offset: BigEndian<Offset16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () =
    assert!(std::mem::size_of::<CaretValueFormat3FixedHeader>() <= CaretValueFormat3::MIN_SIZE);

/// [CaretValue Format 3](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#caretvalue-format-3)
#[derive(Clone)]
pub struct CaretValueFormat3<'a> {
    data: TableDataRef<'a, CaretValueFormat3FixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> CaretValueFormat3<'a> {
    pub const MIN_SIZE: usize = (u16::RAW_BYTE_LEN + i16::RAW_BYTE_LEN + Offset16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Format identifier-format = 3
    pub fn caret_value_format(&self) -> u16 {
        self.data.header().caret_value_format.get()
    }

    /// X or Y value, in design units
    pub fn coordinate(&self) -> i16 {
        self.data.header().coordinate.get()
    }

    /// Offset to Device table (non-variable font) / Variation Index
    /// table (variable font) for X or Y value-from beginning of
    /// CaretValue table
    pub fn device_offset(&self) -> Offset16 {
        self.data.header().device_offset.get()
    }

    /// Attempt to resolve [`device_offset`][Self::device_offset].
    pub fn device(&self) -> Result<DeviceOrVariationIndex<'a>, ReadError> {
        let data = self.offset_data();
        self.device_offset().resolve(data)
    }

    pub fn caret_value_format_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn coordinate_byte_range(&self) -> Range<usize> {
        let start = self.caret_value_format_byte_range().end;
        let end = start + i16::RAW_BYTE_LEN;
        start..end
    }

    pub fn device_offset_byte_range(&self) -> Range<usize> {
        let start = self.coordinate_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }
}

impl Format<u16> for MarkGlyphSets<'_> {
    const FORMAT: u16 = 1;
}

impl<'a> MinByteRange<'a> for MarkGlyphSets<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.coverage_offsets_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for MarkGlyphSets<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for MarkGlyphSets<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct MarkGlyphSetsFixedHeader {
    pub format: BigEndian<u16>,
    pub mark_glyph_set_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<MarkGlyphSetsFixedHeader>() <= MarkGlyphSets::MIN_SIZE);

/// [Mark Glyph Sets Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#mark-glyph-sets-table)
#[derive(Clone)]
pub struct MarkGlyphSets<'a> {
    data: TableDataRef<'a, MarkGlyphSetsFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> MarkGlyphSets<'a> {
    pub const MIN_SIZE: usize = (u16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Format identifier == 1
    pub fn format(&self) -> u16 {
        self.data.header().format.get()
    }

    /// Number of mark glyph sets defined
    pub fn mark_glyph_set_count(&self) -> u16 {
        self.data.header().mark_glyph_set_count.get()
    }

    /// Array of offsets to mark glyph set coverage tables, from the
    /// start of the MarkGlyphSets table.
    pub fn coverage_offsets(&self) -> &'a [BigEndian<Offset32>] {
        let range = self.coverage_offsets_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    /// A dynamically resolving wrapper for [`coverage_offsets`][Self::coverage_offsets].
    pub fn coverages(&self) -> ArrayOfOffsets<'a, CoverageTable<'a>, Offset32> {
        let data = self.offset_data();
        let offsets = self.coverage_offsets();
        ArrayOfOffsets::new(offsets, data, ())
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn mark_glyph_set_count_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn coverage_offsets_byte_range(&self) -> Range<usize> {
        let mark_glyph_set_count = self.mark_glyph_set_count();
        let start = self.mark_glyph_set_count_byte_range().end;
        let end = start
            + (transforms::to_usize(mark_glyph_set_count)).saturating_mul(Offset32::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(MarkGlyphSets::MIN_SIZE));

impl Default for MarkGlyphSets<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_format_1_u16_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

impl<'a> MinByteRange<'a> for LigCaretList2<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.lig_glyph_offsets_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for LigCaretList2<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for LigCaretList2<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct LigCaretList2FixedHeader {
    pub coverage_offset: BigEndian<Offset32>,
    pub lig_glyph_count: BigEndian<Uint24>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<LigCaretList2FixedHeader>() <= LigCaretList2::MIN_SIZE);

/// LigCaretList2 (ISO/IEC 14496-22:2026).
#[derive(Clone)]
pub struct LigCaretList2<'a> {
    data: TableDataRef<'a, LigCaretList2FixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> LigCaretList2<'a> {
    pub const MIN_SIZE: usize = (Offset32::RAW_BYTE_LEN + Uint24::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Offset to Coverage table - from beginning of LigCaretList2 table
    pub fn coverage_offset(&self) -> Offset32 {
        self.data.header().coverage_offset.get()
    }

    /// Attempt to resolve [`coverage_offset`][Self::coverage_offset].
    pub fn coverage(&self) -> Result<CoverageTable<'a>, ReadError> {
        let data = self.offset_data();
        self.coverage_offset().resolve(data)
    }

    /// Number of ligature glyphs
    pub fn lig_glyph_count(&self) -> Uint24 {
        self.data.header().lig_glyph_count.get()
    }

    /// Array of offsets to LigGlyph tables, from beginning of
    /// LigCaretList2 table —in Coverage Index order
    pub fn lig_glyph_offsets(&self) -> &'a [BigEndian<Offset24>] {
        let range = self.lig_glyph_offsets_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    /// A dynamically resolving wrapper for [`lig_glyph_offsets`][Self::lig_glyph_offsets].
    pub fn lig_glyphs(&self) -> ArrayOfOffsets<'a, LigGlyph<'a>, Offset24> {
        let data = self.offset_data();
        let offsets = self.lig_glyph_offsets();
        ArrayOfOffsets::new(offsets, data, ())
    }

    pub fn coverage_offset_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + Offset32::RAW_BYTE_LEN;
        start..end
    }

    pub fn lig_glyph_count_byte_range(&self) -> Range<usize> {
        let start = self.coverage_offset_byte_range().end;
        let end = start + Uint24::RAW_BYTE_LEN;
        start..end
    }

    pub fn lig_glyph_offsets_byte_range(&self) -> Range<usize> {
        let lig_glyph_count = self.lig_glyph_count();
        let start = self.lig_glyph_count_byte_range().end;
        let end =
            start + (transforms::to_usize(lig_glyph_count)).saturating_mul(Offset24::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(LigCaretList2::MIN_SIZE));

impl Default for LigCaretList2<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

Coverage Report

Created: 2026-10-24 07:19