mongol-norm 0.3.1

// @generated by python/scripts/gen_rust_tables.py -- DO NOT EDIT.
// Source: python/mongol_norm/data/MNG.json (sha256 5e99d2f2b0abe022)

use std::fmt;
use std::str::FromStr;

use crate::Error;

/// A written unit: an opaque glyph-form identifier produced by shaping (see `docs/data-format.md`). The structural tokens `Mvs`, `Nirugu` and `Zwj` are members too: they appear verbatim in [`Shaper::shape`](crate::Shaper::shape) output, exactly as the Python implementation emits them.
#[non_exhaustive]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[rustfmt::skip]
pub enum WrittenUnit {
    /// Written unit `A`.
    A,
    /// Written unit `Aa`.
    Aa,
    /// Written unit `B`.
    B,
    /// Written unit `B2`.
    B2,
    /// Written unit `C`.
    C,
    /// Written unit `Ch`.
    Ch,
    /// Written unit `Cr`.
    Cr,
    /// Written unit `D`.
    D,
    /// Written unit `Dd`.
    Dd,
    /// Written unit `F`.
    F,
    /// Written unit `G`.
    G,
    /// Written unit `Gx`.
    Gx,
    /// Written unit `H`.
    H,
    /// Written unit `Hr`.
    Hr,
    /// Written unit `Hx`.
    Hx,
    /// Written unit `I`.
    I,
    /// Written unit `Ix`.
    Ix,
    /// Written unit `J`.
    J,
    /// Written unit `K`.
    K,
    /// Written unit `K2`.
    K2,
    /// Written unit `L`.
    L,
    /// Written unit `M`.
    M,
    /// Structural token: Mongolian vowel separator U+180E (NNBSP U+202F is folded into it).
    Mvs,
    /// Written unit `N`.
    N,
    /// Structural token: nirugu U+180A, the visible stem extender.
    Nirugu,
    /// Written unit `O`.
    O,
    /// Written unit `P`.
    P,
    /// Written unit `R`.
    R,
    /// Written unit `Rh`.
    Rh,
    /// Written unit `S`.
    S,
    /// Written unit `Sh`.
    Sh,
    /// Written unit `Sz`.
    Sz,
    /// Written unit `T`.
    T,
    /// Written unit `U`.
    U,
    /// Written unit `Ue`.
    Ue,
    /// Written unit `Ux`.
    Ux,
    /// Written unit `W`.
    W,
    /// Written unit `Y`.
    Y,
    /// Written unit `Z`.
    Z,
    /// Written unit `Zr`.
    Zr,
    /// Structural token: zero width joiner U+200D.
    Zwj,
}

#[rustfmt::skip]
impl WrittenUnit {
    /// Every variant, in declaration (sorted contract-name) order.
    pub const ALL: [WrittenUnit; 41] = [
        WrittenUnit::A,
        WrittenUnit::Aa,
        WrittenUnit::B,
        WrittenUnit::B2,
        WrittenUnit::C,
        WrittenUnit::Ch,
        WrittenUnit::Cr,
        WrittenUnit::D,
        WrittenUnit::Dd,
        WrittenUnit::F,
        WrittenUnit::G,
        WrittenUnit::Gx,
        WrittenUnit::H,
        WrittenUnit::Hr,
        WrittenUnit::Hx,
        WrittenUnit::I,
        WrittenUnit::Ix,
        WrittenUnit::J,
        WrittenUnit::K,
        WrittenUnit::K2,
        WrittenUnit::L,
        WrittenUnit::M,
        WrittenUnit::Mvs,
        WrittenUnit::N,
        WrittenUnit::Nirugu,
        WrittenUnit::O,
        WrittenUnit::P,
        WrittenUnit::R,
        WrittenUnit::Rh,
        WrittenUnit::S,
        WrittenUnit::Sh,
        WrittenUnit::Sz,
        WrittenUnit::T,
        WrittenUnit::U,
        WrittenUnit::Ue,
        WrittenUnit::Ux,
        WrittenUnit::W,
        WrittenUnit::Y,
        WrittenUnit::Z,
        WrittenUnit::Zr,
        WrittenUnit::Zwj,
    ];

    /// The contract name used by the Python API, the CLI and the data files.
    pub const fn as_str(self) -> &'static str {
        match self {
            WrittenUnit::A => "A",
            WrittenUnit::Aa => "Aa",
            WrittenUnit::B => "B",
            WrittenUnit::B2 => "B2",
            WrittenUnit::C => "C",
            WrittenUnit::Ch => "Ch",
            WrittenUnit::Cr => "Cr",
            WrittenUnit::D => "D",
            WrittenUnit::Dd => "Dd",
            WrittenUnit::F => "F",
            WrittenUnit::G => "G",
            WrittenUnit::Gx => "Gx",
            WrittenUnit::H => "H",
            WrittenUnit::Hr => "Hr",
            WrittenUnit::Hx => "Hx",
            WrittenUnit::I => "I",
            WrittenUnit::Ix => "Ix",
            WrittenUnit::J => "J",
            WrittenUnit::K => "K",
            WrittenUnit::K2 => "K2",
            WrittenUnit::L => "L",
            WrittenUnit::M => "M",
            WrittenUnit::Mvs => "Mvs",
            WrittenUnit::N => "N",
            WrittenUnit::Nirugu => "Nirugu",
            WrittenUnit::O => "O",
            WrittenUnit::P => "P",
            WrittenUnit::R => "R",
            WrittenUnit::Rh => "Rh",
            WrittenUnit::S => "S",
            WrittenUnit::Sh => "Sh",
            WrittenUnit::Sz => "Sz",
            WrittenUnit::T => "T",
            WrittenUnit::U => "U",
            WrittenUnit::Ue => "Ue",
            WrittenUnit::Ux => "Ux",
            WrittenUnit::W => "W",
            WrittenUnit::Y => "Y",
            WrittenUnit::Z => "Z",
            WrittenUnit::Zr => "Zr",
            WrittenUnit::Zwj => "Zwj",
        }
    }

    /// `true` for the structural tokens `Mvs`, `Nirugu` and `Zwj`.
    pub const fn is_structural(self) -> bool {
        matches!(self, WrittenUnit::Mvs | WrittenUnit::Nirugu | WrittenUnit::Zwj)
    }
}

#[rustfmt::skip]
impl FromStr for WrittenUnit {
    type Err = Error;

    fn from_str(name: &str) -> Result<WrittenUnit, Error> {
        match name {
            "A" => Ok(WrittenUnit::A),
            "Aa" => Ok(WrittenUnit::Aa),
            "B" => Ok(WrittenUnit::B),
            "B2" => Ok(WrittenUnit::B2),
            "C" => Ok(WrittenUnit::C),
            "Ch" => Ok(WrittenUnit::Ch),
            "Cr" => Ok(WrittenUnit::Cr),
            "D" => Ok(WrittenUnit::D),
            "Dd" => Ok(WrittenUnit::Dd),
            "F" => Ok(WrittenUnit::F),
            "G" => Ok(WrittenUnit::G),
            "Gx" => Ok(WrittenUnit::Gx),
            "H" => Ok(WrittenUnit::H),
            "Hr" => Ok(WrittenUnit::Hr),
            "Hx" => Ok(WrittenUnit::Hx),
            "I" => Ok(WrittenUnit::I),
            "Ix" => Ok(WrittenUnit::Ix),
            "J" => Ok(WrittenUnit::J),
            "K" => Ok(WrittenUnit::K),
            "K2" => Ok(WrittenUnit::K2),
            "L" => Ok(WrittenUnit::L),
            "M" => Ok(WrittenUnit::M),
            "Mvs" => Ok(WrittenUnit::Mvs),
            "N" => Ok(WrittenUnit::N),
            "Nirugu" => Ok(WrittenUnit::Nirugu),
            "O" => Ok(WrittenUnit::O),
            "P" => Ok(WrittenUnit::P),
            "R" => Ok(WrittenUnit::R),
            "Rh" => Ok(WrittenUnit::Rh),
            "S" => Ok(WrittenUnit::S),
            "Sh" => Ok(WrittenUnit::Sh),
            "Sz" => Ok(WrittenUnit::Sz),
            "T" => Ok(WrittenUnit::T),
            "U" => Ok(WrittenUnit::U),
            "Ue" => Ok(WrittenUnit::Ue),
            "Ux" => Ok(WrittenUnit::Ux),
            "W" => Ok(WrittenUnit::W),
            "Y" => Ok(WrittenUnit::Y),
            "Z" => Ok(WrittenUnit::Z),
            "Zr" => Ok(WrittenUnit::Zr),
            "Zwj" => Ok(WrittenUnit::Zwj),
            _ => Err(Error::UnknownName { kind: "written unit", name: name.to_owned() }),
        }
    }
}

#[rustfmt::skip]
impl fmt::Display for WrittenUnit {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

/// A shaping condition assigned by the rule pipeline; `as_str()` is the data-file name (`chachlag_onset`, ...).
#[non_exhaustive]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[rustfmt::skip]
pub enum Condition {
    /// Shaping condition `chachlag`.
    Chachlag,
    /// Shaping condition `chachlag_onset`.
    ChachlagOnset,
    /// Shaping condition `chachlag_onset_gb`.
    ChachlagOnsetGb,
    /// Shaping condition `devsger`.
    Devsger,
    /// Shaping condition `dotless`.
    Dotless,
    /// Shaping condition `feminine`.
    Feminine,
    /// Shaping condition `marked`.
    Marked,
    /// Shaping condition `masculine_devsger`.
    MasculineDevsger,
    /// Shaping condition `masculine_onset`.
    MasculineOnset,
    /// Shaping condition `onset`.
    Onset,
    /// Shaping condition `particle`.
    Particle,
    /// Shaping condition `post_bowed`.
    PostBowed,
    /// Shaping condition `vowel_devsger`.
    VowelDevsger,
}

#[rustfmt::skip]
impl Condition {
    /// Every variant, in declaration (sorted contract-name) order.
    pub const ALL: [Condition; 13] = [
        Condition::Chachlag,
        Condition::ChachlagOnset,
        Condition::ChachlagOnsetGb,
        Condition::Devsger,
        Condition::Dotless,
        Condition::Feminine,
        Condition::Marked,
        Condition::MasculineDevsger,
        Condition::MasculineOnset,
        Condition::Onset,
        Condition::Particle,
        Condition::PostBowed,
        Condition::VowelDevsger,
    ];

    /// The contract name used by the Python API, the CLI and the data files.
    pub const fn as_str(self) -> &'static str {
        match self {
            Condition::Chachlag => "chachlag",
            Condition::ChachlagOnset => "chachlag_onset",
            Condition::ChachlagOnsetGb => "chachlag_onset_gb",
            Condition::Devsger => "devsger",
            Condition::Dotless => "dotless",
            Condition::Feminine => "feminine",
            Condition::Marked => "marked",
            Condition::MasculineDevsger => "masculine_devsger",
            Condition::MasculineOnset => "masculine_onset",
            Condition::Onset => "onset",
            Condition::Particle => "particle",
            Condition::PostBowed => "post_bowed",
            Condition::VowelDevsger => "vowel_devsger",
        }
    }
}

#[rustfmt::skip]
impl FromStr for Condition {
    type Err = Error;

    fn from_str(name: &str) -> Result<Condition, Error> {
        match name {
            "chachlag" => Ok(Condition::Chachlag),
            "chachlag_onset" => Ok(Condition::ChachlagOnset),
            "chachlag_onset_gb" => Ok(Condition::ChachlagOnsetGb),
            "devsger" => Ok(Condition::Devsger),
            "dotless" => Ok(Condition::Dotless),
            "feminine" => Ok(Condition::Feminine),
            "marked" => Ok(Condition::Marked),
            "masculine_devsger" => Ok(Condition::MasculineDevsger),
            "masculine_onset" => Ok(Condition::MasculineOnset),
            "onset" => Ok(Condition::Onset),
            "particle" => Ok(Condition::Particle),
            "post_bowed" => Ok(Condition::PostBowed),
            "vowel_devsger" => Ok(Condition::VowelDevsger),
            _ => Err(Error::UnknownName { kind: "condition", name: name.to_owned() }),
        }
    }
}

#[rustfmt::skip]
impl fmt::Display for Condition {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

/// A letter alias (phonemic short name, locale-relative); `as_str()` is the data-file name (`a`, `oe`, `k2`, ...).
#[non_exhaustive]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[rustfmt::skip]
pub enum Alias {
    /// Letter alias `a`.
    A,
    /// Letter alias `b`.
    B,
    /// Letter alias `c`.
    C,
    /// Letter alias `ch`.
    Ch,
    /// Letter alias `cr`.
    Cr,
    /// Letter alias `d`.
    D,
    /// Letter alias `e`.
    E,
    /// Letter alias `ee`.
    Ee,
    /// Letter alias `f`.
    F,
    /// Letter alias `g`.
    G,
    /// Letter alias `h`.
    H,
    /// Letter alias `hh`.
    Hh,
    /// Letter alias `i`.
    I,
    /// Letter alias `j`.
    J,
    /// Letter alias `k`.
    K,
    /// Letter alias `k2`.
    K2,
    /// Letter alias `l`.
    L,
    /// Letter alias `lh`.
    Lh,
    /// Letter alias `m`.
    M,
    /// Letter alias `n`.
    N,
    /// Letter alias `ng`.
    Ng,
    /// Letter alias `o`.
    O,
    /// Letter alias `oe`.
    Oe,
    /// Letter alias `p`.
    P,
    /// Letter alias `r`.
    R,
    /// Letter alias `rh`.
    Rh,
    /// Letter alias `s`.
    S,
    /// Letter alias `sh`.
    Sh,
    /// Letter alias `t`.
    T,
    /// Letter alias `u`.
    U,
    /// Letter alias `ue`.
    Ue,
    /// Letter alias `w`.
    W,
    /// Letter alias `y`.
    Y,
    /// Letter alias `z`.
    Z,
    /// Letter alias `zr`.
    Zr,
}

#[rustfmt::skip]
impl Alias {
    /// Every variant, in declaration (sorted contract-name) order.
    pub const ALL: [Alias; 35] = [
        Alias::A,
        Alias::B,
        Alias::C,
        Alias::Ch,
        Alias::Cr,
        Alias::D,
        Alias::E,
        Alias::Ee,
        Alias::F,
        Alias::G,
        Alias::H,
        Alias::Hh,
        Alias::I,
        Alias::J,
        Alias::K,
        Alias::K2,
        Alias::L,
        Alias::Lh,
        Alias::M,
        Alias::N,
        Alias::Ng,
        Alias::O,
        Alias::Oe,
        Alias::P,
        Alias::R,
        Alias::Rh,
        Alias::S,
        Alias::Sh,
        Alias::T,
        Alias::U,
        Alias::Ue,
        Alias::W,
        Alias::Y,
        Alias::Z,
        Alias::Zr,
    ];

    /// The contract name used by the Python API, the CLI and the data files.
    pub const fn as_str(self) -> &'static str {
        match self {
            Alias::A => "a",
            Alias::B => "b",
            Alias::C => "c",
            Alias::Ch => "ch",
            Alias::Cr => "cr",
            Alias::D => "d",
            Alias::E => "e",
            Alias::Ee => "ee",
            Alias::F => "f",
            Alias::G => "g",
            Alias::H => "h",
            Alias::Hh => "hh",
            Alias::I => "i",
            Alias::J => "j",
            Alias::K => "k",
            Alias::K2 => "k2",
            Alias::L => "l",
            Alias::Lh => "lh",
            Alias::M => "m",
            Alias::N => "n",
            Alias::Ng => "ng",
            Alias::O => "o",
            Alias::Oe => "oe",
            Alias::P => "p",
            Alias::R => "r",
            Alias::Rh => "rh",
            Alias::S => "s",
            Alias::Sh => "sh",
            Alias::T => "t",
            Alias::U => "u",
            Alias::Ue => "ue",
            Alias::W => "w",
            Alias::Y => "y",
            Alias::Z => "z",
            Alias::Zr => "zr",
        }
    }
}

#[rustfmt::skip]
impl FromStr for Alias {
    type Err = Error;

    fn from_str(name: &str) -> Result<Alias, Error> {
        match name {
            "a" => Ok(Alias::A),
            "b" => Ok(Alias::B),
            "c" => Ok(Alias::C),
            "ch" => Ok(Alias::Ch),
            "cr" => Ok(Alias::Cr),
            "d" => Ok(Alias::D),
            "e" => Ok(Alias::E),
            "ee" => Ok(Alias::Ee),
            "f" => Ok(Alias::F),
            "g" => Ok(Alias::G),
            "h" => Ok(Alias::H),
            "hh" => Ok(Alias::Hh),
            "i" => Ok(Alias::I),
            "j" => Ok(Alias::J),
            "k" => Ok(Alias::K),
            "k2" => Ok(Alias::K2),
            "l" => Ok(Alias::L),
            "lh" => Ok(Alias::Lh),
            "m" => Ok(Alias::M),
            "n" => Ok(Alias::N),
            "ng" => Ok(Alias::Ng),
            "o" => Ok(Alias::O),
            "oe" => Ok(Alias::Oe),
            "p" => Ok(Alias::P),
            "r" => Ok(Alias::R),
            "rh" => Ok(Alias::Rh),
            "s" => Ok(Alias::S),
            "sh" => Ok(Alias::Sh),
            "t" => Ok(Alias::T),
            "u" => Ok(Alias::U),
            "ue" => Ok(Alias::Ue),
            "w" => Ok(Alias::W),
            "y" => Ok(Alias::Y),
            "z" => Ok(Alias::Z),
            "zr" => Ok(Alias::Zr),
            _ => Err(Error::UnknownName { kind: "alias", name: name.to_owned() }),
        }
    }
}

#[rustfmt::skip]
impl fmt::Display for Alias {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}