read-fonts 0.44.0

// 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 Morx<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.chains_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

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

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

impl<'a> FontRead<'a> for Morx<'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);
        }
        Ok(Self { data })
    }
}

/// The [morx (Extended Glyph Metamorphosis)](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6morx.html) table.
#[derive(Clone)]
pub struct Morx<'a> {
    data: FontData<'a>,
}

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

    /// Version number of the extended glyph metamorphosis table (either 2 or 3).
    pub fn version(&self) -> u16 {
        let range = self.version_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Number of metamorphosis chains contained in this table.
    pub fn n_chains(&self) -> u32 {
        let range = self.n_chains_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    pub fn chains(&self) -> VarLenArray<'a, Chain<'a>> {
        let range = self.chains_byte_range();
        self.data
            .split_off(range.start)
            .and_then(|d| VarLenArray::read(d).ok())
            .unwrap_or_default()
    }

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

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

    pub fn n_chains_byte_range(&self) -> Range<usize> {
        let start = self.unused_byte_range().end;
        let end = start + u32::RAW_BYTE_LEN;
        start..end
    }

    pub fn chains_byte_range(&self) -> Range<usize> {
        let n_chains = self.n_chains();
        let start = self.n_chains_byte_range().end;
        let end = start + {
            let data = self.data.split_off(start).unwrap_or_default();
            <Chain as VarSize>::total_len_for_count(data, transforms::to_usize(n_chains))
                .unwrap_or(0)
        };
        start..end
    }
}

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

impl Default for Morx<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

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

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

impl<'a> FontRead<'a> for Chain<'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);
        }
        Ok(Self { data })
    }
}

/// A chain in a `morx` table.
#[derive(Clone)]
pub struct Chain<'a> {
    data: FontData<'a>,
}

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

    /// The default specification for subtables.
    pub fn default_flags(&self) -> u32 {
        let range = self.default_flags_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Total byte count, including this header; must be a multiple of 4.
    pub fn chain_length(&self) -> u32 {
        let range = self.chain_length_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Number of feature subtable entries.
    pub fn n_feature_entries(&self) -> u32 {
        let range = self.n_feature_entries_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// The number of subtables in the chain.
    pub fn n_subtables(&self) -> u32 {
        let range = self.n_subtables_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Feature entries for this chain.
    pub fn features(&self) -> &'a [Feature] {
        let range = self.features_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

    /// Array of chain subtables.
    pub fn subtables(&self) -> VarLenArray<'a, Subtable<'a>> {
        let range = self.subtables_byte_range();
        self.data
            .split_off(range.start)
            .and_then(|d| VarLenArray::read(d).ok())
            .unwrap_or_default()
    }

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

    pub fn chain_length_byte_range(&self) -> Range<usize> {
        let start = self.default_flags_byte_range().end;
        let end = start + u32::RAW_BYTE_LEN;
        start..end
    }

    pub fn n_feature_entries_byte_range(&self) -> Range<usize> {
        let start = self.chain_length_byte_range().end;
        let end = start + u32::RAW_BYTE_LEN;
        start..end
    }

    pub fn n_subtables_byte_range(&self) -> Range<usize> {
        let start = self.n_feature_entries_byte_range().end;
        let end = start + u32::RAW_BYTE_LEN;
        start..end
    }

    pub fn features_byte_range(&self) -> Range<usize> {
        let n_feature_entries = self.n_feature_entries();
        let start = self.n_subtables_byte_range().end;
        let end =
            start + (transforms::to_usize(n_feature_entries)).saturating_mul(Feature::RAW_BYTE_LEN);
        start..end
    }

    pub fn subtables_byte_range(&self) -> Range<usize> {
        let n_subtables = self.n_subtables();
        let start = self.features_byte_range().end;
        let end = start + {
            let data = self.data.split_off(start).unwrap_or_default();
            <Subtable as VarSize>::total_len_for_count(data, transforms::to_usize(n_subtables))
                .unwrap_or(0)
        };
        start..end
    }
}

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

impl Default for Chain<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

/// Used to compute the sub-feature flags for a list of requested features and settings.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct Feature {
    /// The type of feature.
    pub feature_type: BigEndian<u16>,
    /// The feature's setting (aka selector).
    pub feature_settings: BigEndian<u16>,
    /// Flags for the settings that this feature and setting enables.
    pub enable_flags: BigEndian<u32>,
    /// Complement of flags for the settings that this feature and setting disable.
    pub disable_flags: BigEndian<u32>,
}

impl Feature {
    /// The type of feature.
    pub fn feature_type(&self) -> u16 {
        self.feature_type.get()
    }

    /// The feature's setting (aka selector).
    pub fn feature_settings(&self) -> u16 {
        self.feature_settings.get()
    }

    /// Flags for the settings that this feature and setting enables.
    pub fn enable_flags(&self) -> u32 {
        self.enable_flags.get()
    }

    /// Complement of flags for the settings that this feature and setting disable.
    pub fn disable_flags(&self) -> u32 {
        self.disable_flags.get()
    }
}

impl FixedSize for Feature {
    const RAW_BYTE_LEN: usize =
        u16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN + u32::RAW_BYTE_LEN + u32::RAW_BYTE_LEN;
}

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

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

impl<'a> FontRead<'a> for Subtable<'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);
        }
        Ok(Self { data })
    }
}

/// A subtable in a `morx` chain.
#[derive(Clone)]
pub struct Subtable<'a> {
    data: FontData<'a>,
}

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

    /// Total subtable length, including this header.
    pub fn length(&self) -> u32 {
        let range = self.length_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Coverage flags and subtable type.
    pub fn coverage(&self) -> u32 {
        let range = self.coverage_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// The 32-bit mask identifying which subtable this is (the subtable being executed if the AND of this value and the processed defaultFlags is nonzero).
    pub fn sub_feature_flags(&self) -> u32 {
        let range = self.sub_feature_flags_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Data for specific subtable.
    pub fn data(&self) -> &'a [u8] {
        let range = self.data_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

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

    pub fn coverage_byte_range(&self) -> Range<usize> {
        let start = self.length_byte_range().end;
        let end = start + u32::RAW_BYTE_LEN;
        start..end
    }

    pub fn sub_feature_flags_byte_range(&self) -> Range<usize> {
        let start = self.coverage_byte_range().end;
        let end = start + u32::RAW_BYTE_LEN;
        start..end
    }

    pub fn data_byte_range(&self) -> Range<usize> {
        let start = self.sub_feature_flags_byte_range().end;
        let end =
            start + self.data.len().saturating_sub(start) / u8::RAW_BYTE_LEN * u8::RAW_BYTE_LEN;
        start..end
    }
}

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

impl Default for Subtable<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

/// Entry payload in a contextual subtable state machine.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct ContextualEntryData {
    /// Index of the substitution table for the marked glyph (use 0xFFFF for
    /// none).
    pub mark_index: BigEndian<u16>,
    /// Index of the substitution table for the current glyph (use 0xFFFF for
    /// none)
    pub current_index: BigEndian<u16>,
}

impl ContextualEntryData {
    /// Index of the substitution table for the marked glyph (use 0xFFFF for
    /// none).
    pub fn mark_index(&self) -> u16 {
        self.mark_index.get()
    }

    /// Index of the substitution table for the current glyph (use 0xFFFF for
    /// none)
    pub fn current_index(&self) -> u16 {
        self.current_index.get()
    }
}

impl FixedSize for ContextualEntryData {
    const RAW_BYTE_LEN: usize = u16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN;
}

/// Entry payload in an insertion subtable state machine.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct InsertionEntryData {
    /// Zero-based index into the insertion glyph table. The number of glyphs
    /// to be inserted is contained in the currentInsertCount field in the
    /// flags (see below). A value of 0xFFFF indicates no insertion is to be done.
    pub current_insert_index: BigEndian<u16>,
    /// Zero-based index into the insertion glyph table. The number of glyphs
    /// to be inserted is contained in the markedInsertCount field in the
    /// flags (see below). A value of 0xFFFF indicates no insertion is to be
    /// done.
    pub marked_insert_index: BigEndian<u16>,
}

impl InsertionEntryData {
    /// Zero-based index into the insertion glyph table. The number of glyphs
    /// to be inserted is contained in the currentInsertCount field in the
    /// flags (see below). A value of 0xFFFF indicates no insertion is to be done.
    pub fn current_insert_index(&self) -> u16 {
        self.current_insert_index.get()
    }

    /// Zero-based index into the insertion glyph table. The number of glyphs
    /// to be inserted is contained in the markedInsertCount field in the
    /// flags (see below). A value of 0xFFFF indicates no insertion is to be
    /// done.
    pub fn marked_insert_index(&self) -> u16 {
        self.marked_insert_index.get()
    }
}

impl FixedSize for InsertionEntryData {
    const RAW_BYTE_LEN: usize = u16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN;
}