/// A number of constants to give a name to all characters in this block.
mod constants {
    /// \u{10b00}: '𐬀'
    pub const LETTER_A: char = '𐬀';
    /// \u{10b01}: '𐬁'
    pub const LETTER_AA: char = '𐬁';
    /// \u{10b02}: '𐬂'
    pub const LETTER_AO: char = '𐬂';
    /// \u{10b03}: '𐬃'
    pub const LETTER_AAO: char = '𐬃';
    /// \u{10b04}: '𐬄'
    pub const LETTER_AN: char = '𐬄';
    /// \u{10b05}: '𐬅'
    pub const LETTER_AAN: char = '𐬅';
    /// \u{10b06}: '𐬆'
    pub const LETTER_AE: char = '𐬆';
    /// \u{10b07}: '𐬇'
    pub const LETTER_AEE: char = '𐬇';
    /// \u{10b08}: '𐬈'
    pub const LETTER_E: char = '𐬈';
    /// \u{10b09}: '𐬉'
    pub const LETTER_EE: char = '𐬉';
    /// \u{10b0a}: '𐬊'
    pub const LETTER_O: char = '𐬊';
    /// \u{10b0b}: '𐬋'
    pub const LETTER_OO: char = '𐬋';
    /// \u{10b0c}: '𐬌'
    pub const LETTER_I: char = '𐬌';
    /// \u{10b0d}: '𐬍'
    pub const LETTER_II: char = '𐬍';
    /// \u{10b0e}: '𐬎'
    pub const LETTER_U: char = '𐬎';
    /// \u{10b0f}: '𐬏'
    pub const LETTER_UU: char = '𐬏';
    /// \u{10b10}: '𐬐'
    pub const LETTER_KE: char = '𐬐';
    /// \u{10b11}: '𐬑'
    pub const LETTER_XE: char = '𐬑';
    /// \u{10b12}: '𐬒'
    pub const LETTER_XYE: char = '𐬒';
    /// \u{10b13}: '𐬓'
    pub const LETTER_XVE: char = '𐬓';
    /// \u{10b14}: '𐬔'
    pub const LETTER_GE: char = '𐬔';
    /// \u{10b15}: '𐬕'
    pub const LETTER_GGE: char = '𐬕';
    /// \u{10b16}: '𐬖'
    pub const LETTER_GHE: char = '𐬖';
    /// \u{10b17}: '𐬗'
    pub const LETTER_CE: char = '𐬗';
    /// \u{10b18}: '𐬘'
    pub const LETTER_JE: char = '𐬘';
    /// \u{10b19}: '𐬙'
    pub const LETTER_TE: char = '𐬙';
    /// \u{10b1a}: '𐬚'
    pub const LETTER_THE: char = '𐬚';
    /// \u{10b1b}: '𐬛'
    pub const LETTER_DE: char = '𐬛';
    /// \u{10b1c}: '𐬜'
    pub const LETTER_DHE: char = '𐬜';
    /// \u{10b1d}: '𐬝'
    pub const LETTER_TTE: char = '𐬝';
    /// \u{10b1e}: '𐬞'
    pub const LETTER_PE: char = '𐬞';
    /// \u{10b1f}: '𐬟'
    pub const LETTER_FE: char = '𐬟';
    /// \u{10b20}: '𐬠'
    pub const LETTER_BE: char = '𐬠';
    /// \u{10b21}: '𐬡'
    pub const LETTER_BHE: char = '𐬡';
    /// \u{10b22}: '𐬢'
    pub const LETTER_NGE: char = '𐬢';
    /// \u{10b23}: '𐬣'
    pub const LETTER_NGYE: char = '𐬣';
    /// \u{10b24}: '𐬤'
    pub const LETTER_NGVE: char = '𐬤';
    /// \u{10b25}: '𐬥'
    pub const LETTER_NE: char = '𐬥';
    /// \u{10b26}: '𐬦'
    pub const LETTER_NYE: char = '𐬦';
    /// \u{10b27}: '𐬧'
    pub const LETTER_NNE: char = '𐬧';
    /// \u{10b28}: '𐬨'
    pub const LETTER_ME: char = '𐬨';
    /// \u{10b29}: '𐬩'
    pub const LETTER_HME: char = '𐬩';
    /// \u{10b2a}: '𐬪'
    pub const LETTER_YYE: char = '𐬪';
    /// \u{10b2b}: '𐬫'
    pub const LETTER_YE: char = '𐬫';
    /// \u{10b2c}: '𐬬'
    pub const LETTER_VE: char = '𐬬';
    /// \u{10b2d}: '𐬭'
    pub const LETTER_RE: char = '𐬭';
    /// \u{10b2e}: '𐬮'
    pub const LETTER_LE: char = '𐬮';
    /// \u{10b2f}: '𐬯'
    pub const LETTER_SE: char = '𐬯';
    /// \u{10b30}: '𐬰'
    pub const LETTER_ZE: char = '𐬰';
    /// \u{10b31}: '𐬱'
    pub const LETTER_SHE: char = '𐬱';
    /// \u{10b32}: '𐬲'
    pub const LETTER_ZHE: char = '𐬲';
    /// \u{10b33}: '𐬳'
    pub const LETTER_SHYE: char = '𐬳';
    /// \u{10b34}: '𐬴'
    pub const LETTER_SSHE: char = '𐬴';
    /// \u{10b35}: '𐬵'
    pub const LETTER_HE: char = '𐬵';
    /// \u{10b39}: '𐬹'
    pub const ABBREVIATION_MARK: char = '𐬹';
    /// \u{10b3a}: '𐬺'
    pub const TINY_TWO_DOTS_OVER_ONE_DOT_PUNCTUATION: char = '𐬺';
    /// \u{10b3b}: '𐬻'
    pub const SMALL_TWO_DOTS_OVER_ONE_DOT_PUNCTUATION: char = '𐬻';
    /// \u{10b3c}: '𐬼'
    pub const LARGE_TWO_DOTS_OVER_ONE_DOT_PUNCTUATION: char = '𐬼';
    /// \u{10b3d}: '𐬽'
    pub const LARGE_ONE_DOT_OVER_TWO_DOTS_PUNCTUATION: char = '𐬽';
    /// \u{10b3e}: '𐬾'
    pub const LARGE_TWO_RINGS_OVER_ONE_RING_PUNCTUATION: char = '𐬾';
}

/// An enum to represent all characters in the Avestan block.
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub enum Avestan {
    /// \u{10b00}: '𐬀'
    LetterA,
    /// \u{10b01}: '𐬁'
    LetterAa,
    /// \u{10b02}: '𐬂'
    LetterAo,
    /// \u{10b03}: '𐬃'
    LetterAao,
    /// \u{10b04}: '𐬄'
    LetterAn,
    /// \u{10b05}: '𐬅'
    LetterAan,
    /// \u{10b06}: '𐬆'
    LetterAe,
    /// \u{10b07}: '𐬇'
    LetterAee,
    /// \u{10b08}: '𐬈'
    LetterE,
    /// \u{10b09}: '𐬉'
    LetterEe,
    /// \u{10b0a}: '𐬊'
    LetterO,
    /// \u{10b0b}: '𐬋'
    LetterOo,
    /// \u{10b0c}: '𐬌'
    LetterI,
    /// \u{10b0d}: '𐬍'
    LetterIi,
    /// \u{10b0e}: '𐬎'
    LetterU,
    /// \u{10b0f}: '𐬏'
    LetterUu,
    /// \u{10b10}: '𐬐'
    LetterKe,
    /// \u{10b11}: '𐬑'
    LetterXe,
    /// \u{10b12}: '𐬒'
    LetterXye,
    /// \u{10b13}: '𐬓'
    LetterXve,
    /// \u{10b14}: '𐬔'
    LetterGe,
    /// \u{10b15}: '𐬕'
    LetterGge,
    /// \u{10b16}: '𐬖'
    LetterGhe,
    /// \u{10b17}: '𐬗'
    LetterCe,
    /// \u{10b18}: '𐬘'
    LetterJe,
    /// \u{10b19}: '𐬙'
    LetterTe,
    /// \u{10b1a}: '𐬚'
    LetterThe,
    /// \u{10b1b}: '𐬛'
    LetterDe,
    /// \u{10b1c}: '𐬜'
    LetterDhe,
    /// \u{10b1d}: '𐬝'
    LetterTte,
    /// \u{10b1e}: '𐬞'
    LetterPe,
    /// \u{10b1f}: '𐬟'
    LetterFe,
    /// \u{10b20}: '𐬠'
    LetterBe,
    /// \u{10b21}: '𐬡'
    LetterBhe,
    /// \u{10b22}: '𐬢'
    LetterNge,
    /// \u{10b23}: '𐬣'
    LetterNgye,
    /// \u{10b24}: '𐬤'
    LetterNgve,
    /// \u{10b25}: '𐬥'
    LetterNe,
    /// \u{10b26}: '𐬦'
    LetterNye,
    /// \u{10b27}: '𐬧'
    LetterNne,
    /// \u{10b28}: '𐬨'
    LetterMe,
    /// \u{10b29}: '𐬩'
    LetterHme,
    /// \u{10b2a}: '𐬪'
    LetterYye,
    /// \u{10b2b}: '𐬫'
    LetterYe,
    /// \u{10b2c}: '𐬬'
    LetterVe,
    /// \u{10b2d}: '𐬭'
    LetterRe,
    /// \u{10b2e}: '𐬮'
    LetterLe,
    /// \u{10b2f}: '𐬯'
    LetterSe,
    /// \u{10b30}: '𐬰'
    LetterZe,
    /// \u{10b31}: '𐬱'
    LetterShe,
    /// \u{10b32}: '𐬲'
    LetterZhe,
    /// \u{10b33}: '𐬳'
    LetterShye,
    /// \u{10b34}: '𐬴'
    LetterSshe,
    /// \u{10b35}: '𐬵'
    LetterHe,
    /// \u{10b39}: '𐬹'
    AbbreviationMark,
    /// \u{10b3a}: '𐬺'
    TinyTwoDotsOverOneDotPunctuation,
    /// \u{10b3b}: '𐬻'
    SmallTwoDotsOverOneDotPunctuation,
    /// \u{10b3c}: '𐬼'
    LargeTwoDotsOverOneDotPunctuation,
    /// \u{10b3d}: '𐬽'
    LargeOneDotOverTwoDotsPunctuation,
    /// \u{10b3e}: '𐬾'
    LargeTwoRingsOverOneRingPunctuation,
}

impl Into<char> for Avestan {
    fn into(self) -> char {
        use constants::*;
        match self {
            Avestan::LetterA => LETTER_A,
            Avestan::LetterAa => LETTER_AA,
            Avestan::LetterAo => LETTER_AO,
            Avestan::LetterAao => LETTER_AAO,
            Avestan::LetterAn => LETTER_AN,
            Avestan::LetterAan => LETTER_AAN,
            Avestan::LetterAe => LETTER_AE,
            Avestan::LetterAee => LETTER_AEE,
            Avestan::LetterE => LETTER_E,
            Avestan::LetterEe => LETTER_EE,
            Avestan::LetterO => LETTER_O,
            Avestan::LetterOo => LETTER_OO,
            Avestan::LetterI => LETTER_I,
            Avestan::LetterIi => LETTER_II,
            Avestan::LetterU => LETTER_U,
            Avestan::LetterUu => LETTER_UU,
            Avestan::LetterKe => LETTER_KE,
            Avestan::LetterXe => LETTER_XE,
            Avestan::LetterXye => LETTER_XYE,
            Avestan::LetterXve => LETTER_XVE,
            Avestan::LetterGe => LETTER_GE,
            Avestan::LetterGge => LETTER_GGE,
            Avestan::LetterGhe => LETTER_GHE,
            Avestan::LetterCe => LETTER_CE,
            Avestan::LetterJe => LETTER_JE,
            Avestan::LetterTe => LETTER_TE,
            Avestan::LetterThe => LETTER_THE,
            Avestan::LetterDe => LETTER_DE,
            Avestan::LetterDhe => LETTER_DHE,
            Avestan::LetterTte => LETTER_TTE,
            Avestan::LetterPe => LETTER_PE,
            Avestan::LetterFe => LETTER_FE,
            Avestan::LetterBe => LETTER_BE,
            Avestan::LetterBhe => LETTER_BHE,
            Avestan::LetterNge => LETTER_NGE,
            Avestan::LetterNgye => LETTER_NGYE,
            Avestan::LetterNgve => LETTER_NGVE,
            Avestan::LetterNe => LETTER_NE,
            Avestan::LetterNye => LETTER_NYE,
            Avestan::LetterNne => LETTER_NNE,
            Avestan::LetterMe => LETTER_ME,
            Avestan::LetterHme => LETTER_HME,
            Avestan::LetterYye => LETTER_YYE,
            Avestan::LetterYe => LETTER_YE,
            Avestan::LetterVe => LETTER_VE,
            Avestan::LetterRe => LETTER_RE,
            Avestan::LetterLe => LETTER_LE,
            Avestan::LetterSe => LETTER_SE,
            Avestan::LetterZe => LETTER_ZE,
            Avestan::LetterShe => LETTER_SHE,
            Avestan::LetterZhe => LETTER_ZHE,
            Avestan::LetterShye => LETTER_SHYE,
            Avestan::LetterSshe => LETTER_SSHE,
            Avestan::LetterHe => LETTER_HE,
            Avestan::AbbreviationMark => ABBREVIATION_MARK,
            Avestan::TinyTwoDotsOverOneDotPunctuation => TINY_TWO_DOTS_OVER_ONE_DOT_PUNCTUATION,
            Avestan::SmallTwoDotsOverOneDotPunctuation => SMALL_TWO_DOTS_OVER_ONE_DOT_PUNCTUATION,
            Avestan::LargeTwoDotsOverOneDotPunctuation => LARGE_TWO_DOTS_OVER_ONE_DOT_PUNCTUATION,
            Avestan::LargeOneDotOverTwoDotsPunctuation => LARGE_ONE_DOT_OVER_TWO_DOTS_PUNCTUATION,
            Avestan::LargeTwoRingsOverOneRingPunctuation => LARGE_TWO_RINGS_OVER_ONE_RING_PUNCTUATION,
        }
    }
}

impl std::convert::TryFrom<char> for Avestan {
    type Error = ();
    fn try_from(c: char) -> Result<Self, Self::Error> {
        use constants::*;
        match c {
            LETTER_A => Ok(Avestan::LetterA),
            LETTER_AA => Ok(Avestan::LetterAa),
            LETTER_AO => Ok(Avestan::LetterAo),
            LETTER_AAO => Ok(Avestan::LetterAao),
            LETTER_AN => Ok(Avestan::LetterAn),
            LETTER_AAN => Ok(Avestan::LetterAan),
            LETTER_AE => Ok(Avestan::LetterAe),
            LETTER_AEE => Ok(Avestan::LetterAee),
            LETTER_E => Ok(Avestan::LetterE),
            LETTER_EE => Ok(Avestan::LetterEe),
            LETTER_O => Ok(Avestan::LetterO),
            LETTER_OO => Ok(Avestan::LetterOo),
            LETTER_I => Ok(Avestan::LetterI),
            LETTER_II => Ok(Avestan::LetterIi),
            LETTER_U => Ok(Avestan::LetterU),
            LETTER_UU => Ok(Avestan::LetterUu),
            LETTER_KE => Ok(Avestan::LetterKe),
            LETTER_XE => Ok(Avestan::LetterXe),
            LETTER_XYE => Ok(Avestan::LetterXye),
            LETTER_XVE => Ok(Avestan::LetterXve),
            LETTER_GE => Ok(Avestan::LetterGe),
            LETTER_GGE => Ok(Avestan::LetterGge),
            LETTER_GHE => Ok(Avestan::LetterGhe),
            LETTER_CE => Ok(Avestan::LetterCe),
            LETTER_JE => Ok(Avestan::LetterJe),
            LETTER_TE => Ok(Avestan::LetterTe),
            LETTER_THE => Ok(Avestan::LetterThe),
            LETTER_DE => Ok(Avestan::LetterDe),
            LETTER_DHE => Ok(Avestan::LetterDhe),
            LETTER_TTE => Ok(Avestan::LetterTte),
            LETTER_PE => Ok(Avestan::LetterPe),
            LETTER_FE => Ok(Avestan::LetterFe),
            LETTER_BE => Ok(Avestan::LetterBe),
            LETTER_BHE => Ok(Avestan::LetterBhe),
            LETTER_NGE => Ok(Avestan::LetterNge),
            LETTER_NGYE => Ok(Avestan::LetterNgye),
            LETTER_NGVE => Ok(Avestan::LetterNgve),
            LETTER_NE => Ok(Avestan::LetterNe),
            LETTER_NYE => Ok(Avestan::LetterNye),
            LETTER_NNE => Ok(Avestan::LetterNne),
            LETTER_ME => Ok(Avestan::LetterMe),
            LETTER_HME => Ok(Avestan::LetterHme),
            LETTER_YYE => Ok(Avestan::LetterYye),
            LETTER_YE => Ok(Avestan::LetterYe),
            LETTER_VE => Ok(Avestan::LetterVe),
            LETTER_RE => Ok(Avestan::LetterRe),
            LETTER_LE => Ok(Avestan::LetterLe),
            LETTER_SE => Ok(Avestan::LetterSe),
            LETTER_ZE => Ok(Avestan::LetterZe),
            LETTER_SHE => Ok(Avestan::LetterShe),
            LETTER_ZHE => Ok(Avestan::LetterZhe),
            LETTER_SHYE => Ok(Avestan::LetterShye),
            LETTER_SSHE => Ok(Avestan::LetterSshe),
            LETTER_HE => Ok(Avestan::LetterHe),
            ABBREVIATION_MARK => Ok(Avestan::AbbreviationMark),
            TINY_TWO_DOTS_OVER_ONE_DOT_PUNCTUATION => Ok(Avestan::TinyTwoDotsOverOneDotPunctuation),
            SMALL_TWO_DOTS_OVER_ONE_DOT_PUNCTUATION => Ok(Avestan::SmallTwoDotsOverOneDotPunctuation),
            LARGE_TWO_DOTS_OVER_ONE_DOT_PUNCTUATION => Ok(Avestan::LargeTwoDotsOverOneDotPunctuation),
            LARGE_ONE_DOT_OVER_TWO_DOTS_PUNCTUATION => Ok(Avestan::LargeOneDotOverTwoDotsPunctuation),
            LARGE_TWO_RINGS_OVER_ONE_RING_PUNCTUATION => Ok(Avestan::LargeTwoRingsOverOneRingPunctuation),
            _ => Err(()),
        }
    }
}

impl Into<u32> for Avestan {
    fn into(self) -> u32 {
        let c: char = self.into();
        let hex = c
            .escape_unicode()
            .to_string()
            .replace("\\u{", "")
            .replace("}", "");
        u32::from_str_radix(&hex, 16).unwrap()
    }
}

impl std::convert::TryFrom<u32> for Avestan {
    type Error = ();
    fn try_from(u: u32) -> Result<Self, Self::Error> {
        if let Ok(c) = char::try_from(u) {
            Self::try_from(c)
        } else {
            Err(())
        }
    }
}

impl Iterator for Avestan {
    type Item = Self;
    fn next(&mut self) -> Option<Self> {
        let index: u32 = (*self).into();
        use std::convert::TryFrom;
        Self::try_from(index + 1).ok()
    }
}

impl Avestan {
    /// The character with the lowest index in this unicode block
    pub fn new() -> Self {
        Avestan::LetterA
    }

    /// The character's name, all lowercase and space-separated
    pub fn name(&self) -> &str {
        match self {
            Avestan::LetterA => "avestan letter a",
            Avestan::LetterAa => "avestan letter aa",
            Avestan::LetterAo => "avestan letter ao",
            Avestan::LetterAao => "avestan letter aao",
            Avestan::LetterAn => "avestan letter an",
            Avestan::LetterAan => "avestan letter aan",
            Avestan::LetterAe => "avestan letter ae",
            Avestan::LetterAee => "avestan letter aee",
            Avestan::LetterE => "avestan letter e",
            Avestan::LetterEe => "avestan letter ee",
            Avestan::LetterO => "avestan letter o",
            Avestan::LetterOo => "avestan letter oo",
            Avestan::LetterI => "avestan letter i",
            Avestan::LetterIi => "avestan letter ii",
            Avestan::LetterU => "avestan letter u",
            Avestan::LetterUu => "avestan letter uu",
            Avestan::LetterKe => "avestan letter ke",
            Avestan::LetterXe => "avestan letter xe",
            Avestan::LetterXye => "avestan letter xye",
            Avestan::LetterXve => "avestan letter xve",
            Avestan::LetterGe => "avestan letter ge",
            Avestan::LetterGge => "avestan letter gge",
            Avestan::LetterGhe => "avestan letter ghe",
            Avestan::LetterCe => "avestan letter ce",
            Avestan::LetterJe => "avestan letter je",
            Avestan::LetterTe => "avestan letter te",
            Avestan::LetterThe => "avestan letter the",
            Avestan::LetterDe => "avestan letter de",
            Avestan::LetterDhe => "avestan letter dhe",
            Avestan::LetterTte => "avestan letter tte",
            Avestan::LetterPe => "avestan letter pe",
            Avestan::LetterFe => "avestan letter fe",
            Avestan::LetterBe => "avestan letter be",
            Avestan::LetterBhe => "avestan letter bhe",
            Avestan::LetterNge => "avestan letter nge",
            Avestan::LetterNgye => "avestan letter ngye",
            Avestan::LetterNgve => "avestan letter ngve",
            Avestan::LetterNe => "avestan letter ne",
            Avestan::LetterNye => "avestan letter nye",
            Avestan::LetterNne => "avestan letter nne",
            Avestan::LetterMe => "avestan letter me",
            Avestan::LetterHme => "avestan letter hme",
            Avestan::LetterYye => "avestan letter yye",
            Avestan::LetterYe => "avestan letter ye",
            Avestan::LetterVe => "avestan letter ve",
            Avestan::LetterRe => "avestan letter re",
            Avestan::LetterLe => "avestan letter le",
            Avestan::LetterSe => "avestan letter se",
            Avestan::LetterZe => "avestan letter ze",
            Avestan::LetterShe => "avestan letter she",
            Avestan::LetterZhe => "avestan letter zhe",
            Avestan::LetterShye => "avestan letter shye",
            Avestan::LetterSshe => "avestan letter sshe",
            Avestan::LetterHe => "avestan letter he",
            Avestan::AbbreviationMark => "avestan abbreviation mark",
            Avestan::TinyTwoDotsOverOneDotPunctuation => "tiny two dots over one dot punctuation",
            Avestan::SmallTwoDotsOverOneDotPunctuation => "small two dots over one dot punctuation",
            Avestan::LargeTwoDotsOverOneDotPunctuation => "large two dots over one dot punctuation",
            Avestan::LargeOneDotOverTwoDotsPunctuation => "large one dot over two dots punctuation",
            Avestan::LargeTwoRingsOverOneRingPunctuation => "large two rings over one ring punctuation",
        }
    }
}