/rust/registry/src/index.crates.io-1949cf8c6b5b557f/read-fonts-0.46.0/generated/generated_base.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 Base<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.vert_axis_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 Base<'_> {
    /// `BASE`
    const TAG: Tag = Tag::new(b"BASE");
}

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

impl<'a> FontRead<'a> for Base<'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 BaseFixedHeader {
    pub version: BigEndian<MajorMinor>,
    pub horiz_axis_offset: BigEndian<Nullable<Offset16>>,
    pub vert_axis_offset: BigEndian<Nullable<Offset16>>,
}

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

/// The [BASE](https://learn.microsoft.com/en-us/typography/opentype/spec/base) (Baseline) table
#[derive(Clone)]
pub struct Base<'a> {
    data: TableDataRef<'a, BaseFixedHeader>,
}

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

    /// (major, minor) Version for the BASE table (1,0) or (1,1)
    pub fn version(&self) -> MajorMinor {
        self.data.header().version.get()
    }

    /// Offset to horizontal Axis table, from beginning of BASE table (may be NULL)
    pub fn horiz_axis_offset(&self) -> Nullable<Offset16> {
        self.data.header().horiz_axis_offset.get()
    }

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

    /// Offset to vertical Axis table, from beginning of BASE table (may be NULL)
    pub fn vert_axis_offset(&self) -> Nullable<Offset16> {
        self.data.header().vert_axis_offset.get()
    }

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

    /// Offset to Item Variation Store table, from beginning of BASE table (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))?
    }

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

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

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

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

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

impl Default for Base<'_> {
    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 Axis<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.base_script_list_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 Axis<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for Axis<'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 AxisFixedHeader {
    pub base_tag_list_offset: BigEndian<Nullable<Offset16>>,
    pub base_script_list_offset: BigEndian<Offset16>,
}

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

/// [Axis Table](https://learn.microsoft.com/en-us/typography/opentype/spec/base#axis-tables-horizaxis-and-vertaxis)
#[derive(Clone)]
pub struct Axis<'a> {
    data: TableDataRef<'a, AxisFixedHeader>,
}

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

    /// Offset to BaseTagList table, from beginning of Axis table (may
    /// be NULL)
    pub fn base_tag_list_offset(&self) -> Nullable<Offset16> {
        self.data.header().base_tag_list_offset.get()
    }

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

    /// Offset to BaseScriptList table, from beginning of Axis table
    pub fn base_script_list_offset(&self) -> Offset16 {
        self.data.header().base_script_list_offset.get()
    }

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

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

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

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

impl Default for Axis<'_> {
    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 BaseTagList<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.baseline_tags_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 BaseTagList<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for BaseTagList<'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 BaseTagListFixedHeader {
    pub base_tag_count: BigEndian<u16>,
}

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

/// [BaseTagList Table](https://learn.microsoft.com/en-us/typography/opentype/spec/base#basetaglist-table)
#[derive(Clone)]
pub struct BaseTagList<'a> {
    data: TableDataRef<'a, BaseTagListFixedHeader>,
}

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

    /// Number of baseline identification tags in this text direction
    /// — may be zero (0)
    pub fn base_tag_count(&self) -> u16 {
        self.data.header().base_tag_count.get()
    }

    /// Array of 4-byte baseline identification tags — must be in
    /// alphabetical order
    pub fn baseline_tags(&self) -> &'a [BigEndian<Tag>] {
        let range = self.baseline_tags_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

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

    pub fn baseline_tags_byte_range(&self) -> Range<usize> {
        let base_tag_count = self.base_tag_count();
        let start = self.base_tag_count_byte_range().end;
        let end = start + (transforms::to_usize(base_tag_count)).saturating_mul(Tag::RAW_BYTE_LEN);
        start..end
    }
}

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

impl Default for BaseTagList<'_> {
    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 BaseScriptList<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.base_script_records_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 BaseScriptList<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for BaseScriptList<'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 BaseScriptListFixedHeader {
    pub base_script_count: BigEndian<u16>,
}

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

/// [BaseScriptList Table](https://learn.microsoft.com/en-us/typography/opentype/spec/base#basescriptlist-table)
#[derive(Clone)]
pub struct BaseScriptList<'a> {
    data: TableDataRef<'a, BaseScriptListFixedHeader>,
}

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

    /// Number of BaseScriptRecords defined
    pub fn base_script_count(&self) -> u16 {
        self.data.header().base_script_count.get()
    }

    /// Array of BaseScriptRecords, in alphabetical order by
    /// baseScriptTag
    pub fn base_script_records(&self) -> &'a [BaseScriptRecord] {
        let range = self.base_script_records_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

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

    pub fn base_script_records_byte_range(&self) -> Range<usize> {
        let base_script_count = self.base_script_count();
        let start = self.base_script_count_byte_range().end;
        let end = start
            + (transforms::to_usize(base_script_count))
                .saturating_mul(BaseScriptRecord::RAW_BYTE_LEN);
        start..end
    }
}

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

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

/// [BaseScriptRecord](https://learn.microsoft.com/en-us/typography/opentype/spec/base#basescriptrecord)
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct BaseScriptRecord {
    /// 4-byte script identification tag
    pub base_script_tag: BigEndian<Tag>,
    /// Offset to BaseScript table, from beginning of BaseScriptList
    pub base_script_offset: BigEndian<Offset16>,
}

impl BaseScriptRecord {
    /// 4-byte script identification tag
    pub fn base_script_tag(&self) -> Tag {
        self.base_script_tag.get()
    }

    /// Offset to BaseScript table, from beginning of BaseScriptList
    pub fn base_script_offset(&self) -> Offset16 {
        self.base_script_offset.get()
    }

    /// Offset to BaseScript table, from beginning of BaseScriptList
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn base_script<'a>(&self, data: FontData<'a>) -> Result<BaseScript<'a>, ReadError> {
        self.base_script_offset().resolve(data)
    }
}

impl FixedSize for BaseScriptRecord {
    const RAW_BYTE_LEN: usize = Tag::RAW_BYTE_LEN + Offset16::RAW_BYTE_LEN;
}

impl<'a> MinByteRange<'a> for BaseScript<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.base_lang_sys_records_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 BaseScript<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for BaseScript<'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 BaseScriptFixedHeader {
    pub base_values_offset: BigEndian<Nullable<Offset16>>,
    pub default_min_max_offset: BigEndian<Nullable<Offset16>>,
    pub base_lang_sys_count: BigEndian<u16>,
}

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

/// [BaseScript Table](https://learn.microsoft.com/en-us/typography/opentype/spec/base#basescript-table)
#[derive(Clone)]
pub struct BaseScript<'a> {
    data: TableDataRef<'a, BaseScriptFixedHeader>,
}

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

    /// Offset to BaseValues table, from beginning of BaseScript table (may be NULL)
    pub fn base_values_offset(&self) -> Nullable<Offset16> {
        self.data.header().base_values_offset.get()
    }

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

    /// Offset to MinMax table, from beginning of BaseScript table (may be NULL)
    pub fn default_min_max_offset(&self) -> Nullable<Offset16> {
        self.data.header().default_min_max_offset.get()
    }

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

    /// Number of BaseLangSysRecords defined — may be zero (0)
    pub fn base_lang_sys_count(&self) -> u16 {
        self.data.header().base_lang_sys_count.get()
    }

    /// Array of BaseLangSysRecords, in alphabetical order by
    /// BaseLangSysTag
    pub fn base_lang_sys_records(&self) -> &'a [BaseLangSysRecord] {
        let range = self.base_lang_sys_records_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

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

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

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

    pub fn base_lang_sys_records_byte_range(&self) -> Range<usize> {
        let base_lang_sys_count = self.base_lang_sys_count();
        let start = self.base_lang_sys_count_byte_range().end;
        let end = start
            + (transforms::to_usize(base_lang_sys_count))
                .saturating_mul(BaseLangSysRecord::RAW_BYTE_LEN);
        start..end
    }
}

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

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

/// [BaseLangSysRecord](https://learn.microsoft.com/en-us/typography/opentype/spec/base#baselangsysrecord)
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct BaseLangSysRecord {
    /// 4-byte language system identification tag
    pub base_lang_sys_tag: BigEndian<Tag>,
    /// Offset to MinMax table, from beginning of BaseScript table
    pub min_max_offset: BigEndian<Offset16>,
}

impl BaseLangSysRecord {
    /// 4-byte language system identification tag
    pub fn base_lang_sys_tag(&self) -> Tag {
        self.base_lang_sys_tag.get()
    }

    /// Offset to MinMax table, from beginning of BaseScript table
    pub fn min_max_offset(&self) -> Offset16 {
        self.min_max_offset.get()
    }

    /// Offset to MinMax table, from beginning of BaseScript table
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn min_max<'a>(&self, data: FontData<'a>) -> Result<MinMax<'a>, ReadError> {
        self.min_max_offset().resolve(data)
    }
}

impl FixedSize for BaseLangSysRecord {
    const RAW_BYTE_LEN: usize = Tag::RAW_BYTE_LEN + Offset16::RAW_BYTE_LEN;
}

impl<'a> MinByteRange<'a> for BaseValues<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.base_coord_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 BaseValues<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for BaseValues<'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 BaseValuesFixedHeader {
    pub default_baseline_index: BigEndian<u16>,
    pub base_coord_count: BigEndian<u16>,
}

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

/// [BaseValues](https://learn.microsoft.com/en-us/typography/opentype/spec/base#basevalues-table) table
#[derive(Clone)]
pub struct BaseValues<'a> {
    data: TableDataRef<'a, BaseValuesFixedHeader>,
}

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

    /// Index number of default baseline for this script — equals
    /// index position of baseline tag in baselineTags array of the
    /// BaseTagList
    pub fn default_baseline_index(&self) -> u16 {
        self.data.header().default_baseline_index.get()
    }

    /// Number of BaseCoord tables defined — should equal
    /// baseTagCount in the BaseTagList
    pub fn base_coord_count(&self) -> u16 {
        self.data.header().base_coord_count.get()
    }

    /// Array of offsets to BaseCoord tables, from beginning of
    /// BaseValues table — order matches baselineTags array in the
    /// BaseTagList
    pub fn base_coord_offsets(&self) -> &'a [BigEndian<Offset16>] {
        let range = self.base_coord_offsets_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

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

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

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

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

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

impl Default for BaseValues<'_> {
    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 MinMax<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.feat_min_max_records_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 MinMax<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for MinMax<'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 MinMaxFixedHeader {
    pub min_coord_offset: BigEndian<Nullable<Offset16>>,
    pub max_coord_offset: BigEndian<Nullable<Offset16>>,
    pub feat_min_max_count: BigEndian<u16>,
}

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

/// [MinMax](https://learn.microsoft.com/en-us/typography/opentype/spec/base#minmax-table) table
#[derive(Clone)]
pub struct MinMax<'a> {
    data: TableDataRef<'a, MinMaxFixedHeader>,
}

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

    /// Offset to BaseCoord table that defines the minimum extent
    /// value, from the beginning of MinMax table (may be NULL)
    pub fn min_coord_offset(&self) -> Nullable<Offset16> {
        self.data.header().min_coord_offset.get()
    }

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

    /// Offset to BaseCoord table that defines maximum extent value,
    /// from the beginning of MinMax table (may be NULL)
    pub fn max_coord_offset(&self) -> Nullable<Offset16> {
        self.data.header().max_coord_offset.get()
    }

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

    /// Number of FeatMinMaxRecords — may be zero (0)
    pub fn feat_min_max_count(&self) -> u16 {
        self.data.header().feat_min_max_count.get()
    }

    /// Array of FeatMinMaxRecords, in alphabetical order by
    /// featureTableTag
    pub fn feat_min_max_records(&self) -> &'a [FeatMinMaxRecord] {
        let range = self.feat_min_max_records_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

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

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

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

    pub fn feat_min_max_records_byte_range(&self) -> Range<usize> {
        let feat_min_max_count = self.feat_min_max_count();
        let start = self.feat_min_max_count_byte_range().end;
        let end = start
            + (transforms::to_usize(feat_min_max_count))
                .saturating_mul(FeatMinMaxRecord::RAW_BYTE_LEN);
        start..end
    }
}

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

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

/// [FeatMinMaxRecord](https://learn.microsoft.com/en-us/typography/opentype/spec/base#baselangsysrecord)
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct FeatMinMaxRecord {
    /// 4-byte feature identification tag — must match feature tag in
    /// FeatureList
    pub feature_table_tag: BigEndian<Tag>,
    /// Offset to BaseCoord table that defines the minimum extent
    /// value, from beginning of MinMax table (may be NULL)
    pub min_coord_offset: BigEndian<Nullable<Offset16>>,
    /// Offset to BaseCoord table that defines the maximum extent
    /// value, from beginning of MinMax table (may be NULL)
    pub max_coord_offset: BigEndian<Nullable<Offset16>>,
}

impl FeatMinMaxRecord {
    /// 4-byte feature identification tag — must match feature tag in
    /// FeatureList
    pub fn feature_table_tag(&self) -> Tag {
        self.feature_table_tag.get()
    }

    /// Offset to BaseCoord table that defines the minimum extent
    /// value, from beginning of MinMax table (may be NULL)
    pub fn min_coord_offset(&self) -> Nullable<Offset16> {
        self.min_coord_offset.get()
    }

    /// Offset to BaseCoord table that defines the minimum extent
    /// value, from beginning of MinMax table (may be NULL)
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn min_coord<'a>(&self, data: FontData<'a>) -> Option<Result<BaseCoord<'a>, ReadError>> {
        self.min_coord_offset().resolve(data)
    }

    /// Offset to BaseCoord table that defines the maximum extent
    /// value, from beginning of MinMax table (may be NULL)
    pub fn max_coord_offset(&self) -> Nullable<Offset16> {
        self.max_coord_offset.get()
    }

    /// Offset to BaseCoord table that defines the maximum extent
    /// value, from beginning of MinMax table (may be NULL)
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn max_coord<'a>(&self, data: FontData<'a>) -> Option<Result<BaseCoord<'a>, ReadError>> {
        self.max_coord_offset().resolve(data)
    }
}

impl FixedSize for FeatMinMaxRecord {
    const RAW_BYTE_LEN: usize = Tag::RAW_BYTE_LEN + Offset16::RAW_BYTE_LEN + Offset16::RAW_BYTE_LEN;
}

#[derive(Clone)]
pub enum BaseCoord<'a> {
    Format1(BaseCoordFormat1<'a>),
    Format2(BaseCoordFormat2<'a>),
    Format3(BaseCoordFormat3<'a>),
}

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

impl<'a> BaseCoord<'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 base_coord_format(&self) -> u16 {
        match self {
            Self::Format1(item) => item.base_coord_format(),
            Self::Format2(item) => item.base_coord_format(),
            Self::Format3(item) => item.base_coord_format(),
        }
    }

    /// X or Y value, in design units
    pub fn coordinate(&self) -> i16 {
        match self {
            Self::Format1(item) => item.coordinate(),
            Self::Format2(item) => item.coordinate(),
            Self::Format3(item) => item.coordinate(),
        }
    }
}

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

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

impl<'a> MinByteRange<'a> for BaseCoord<'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 BaseCoordFormat1<'_> {
    const FORMAT: u16 = 1;
}

impl<'a> MinByteRange<'a> for BaseCoordFormat1<'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 BaseCoordFormat1<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for BaseCoordFormat1<'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 BaseCoordFormat1FixedHeader {
    pub base_coord_format: BigEndian<u16>,
    pub coordinate: BigEndian<i16>,
}

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

/// [BaseCoordFormat1](https://learn.microsoft.com/en-us/typography/opentype/spec/base#basecoord-format-1)
#[derive(Clone)]
pub struct BaseCoordFormat1<'a> {
    data: TableDataRef<'a, BaseCoordFormat1FixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> BaseCoordFormat1<'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 base_coord_format(&self) -> u16 {
        self.data.header().base_coord_format.get()
    }

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

    pub fn base_coord_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.base_coord_format_byte_range().end;
        let end = start + i16::RAW_BYTE_LEN;
        start..end
    }
}

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

impl Default for BaseCoordFormat1<'_> {
    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 BaseCoordFormat2<'_> {
    const FORMAT: u16 = 2;
}

impl<'a> MinByteRange<'a> for BaseCoordFormat2<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.base_coord_point_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 BaseCoordFormat2<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for BaseCoordFormat2<'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 BaseCoordFormat2FixedHeader {
    pub base_coord_format: BigEndian<u16>,
    pub coordinate: BigEndian<i16>,
    pub reference_glyph: BigEndian<u16>,
    pub base_coord_point: BigEndian<u16>,
}

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

/// [BaseCoordFormat2](https://learn.microsoft.com/en-us/typography/opentype/spec/base#basecoord-format-2)
#[derive(Clone)]
pub struct BaseCoordFormat2<'a> {
    data: TableDataRef<'a, BaseCoordFormat2FixedHeader>,
}

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

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

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

    /// Glyph ID of control glyph
    pub fn reference_glyph(&self) -> u16 {
        self.data.header().reference_glyph.get()
    }

    /// Index of contour point on the reference glyph
    pub fn base_coord_point(&self) -> u16 {
        self.data.header().base_coord_point.get()
    }

    pub fn base_coord_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.base_coord_format_byte_range().end;
        let end = start + i16::RAW_BYTE_LEN;
        start..end
    }

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

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

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

impl<'a> MinByteRange<'a> for BaseCoordFormat3<'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 BaseCoordFormat3<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for BaseCoordFormat3<'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 BaseCoordFormat3FixedHeader {
    pub base_coord_format: BigEndian<u16>,
    pub coordinate: BigEndian<i16>,
    pub device_offset: BigEndian<Nullable<Offset16>>,
}

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

/// [BaseCoordFormat3](https://learn.microsoft.com/en-us/typography/opentype/spec/base#basecoord-format-3)
#[derive(Clone)]
pub struct BaseCoordFormat3<'a> {
    data: TableDataRef<'a, BaseCoordFormat3FixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> BaseCoordFormat3<'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 base_coord_format(&self) -> u16 {
        self.data.header().base_coord_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
    /// BaseCoord table (may be NULL).
    pub fn device_offset(&self) -> Nullable<Offset16> {
        self.data.header().device_offset.get()
    }

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

    pub fn base_coord_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.base_coord_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
    }
}

Coverage Report

Created: 2026-10-24 07:19