use core::{convert::Infallible, fmt, str::FromStr};
use smol_bytes::Utf8Bytes;
use crate::name::{folded, folds_to};
#[cfg(test)]
mod tests;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum WritingSystem {
Arab,
Armn,
Beng,
Bopo,
Cans,
Ethi,
Geor,
Gujr,
Guru,
Khmr,
Knda,
Laoo,
Mlym,
Mong,
Mymr,
Orya,
Sinh,
Syrc,
Taml,
Telu,
Thaa,
Tibt,
Cyrl,
Deva,
Grek,
Hang,
Hani,
Hebr,
Hira,
Kana,
Latn,
Thai,
Zinh,
Zyyy,
Zzzz,
Other(Utf8Bytes),
}
impl WritingSystem {
pub const VARIANTS: &'static [Self] = &[
Self::Arab,
Self::Armn,
Self::Beng,
Self::Bopo,
Self::Cans,
Self::Cyrl,
Self::Deva,
Self::Ethi,
Self::Geor,
Self::Grek,
Self::Gujr,
Self::Guru,
Self::Hang,
Self::Hani,
Self::Hebr,
Self::Hira,
Self::Kana,
Self::Khmr,
Self::Knda,
Self::Laoo,
Self::Latn,
Self::Mlym,
Self::Mong,
Self::Mymr,
Self::Orya,
Self::Sinh,
Self::Syrc,
Self::Taml,
Self::Telu,
Self::Thaa,
Self::Thai,
Self::Tibt,
Self::Zinh,
Self::Zyyy,
Self::Zzzz,
];
#[must_use]
pub fn new(word: &str) -> Self {
for member in Self::VARIANTS {
if folds_to(word, member.as_str()) {
return member.clone();
}
}
Self::Other(Utf8Bytes::from(folded(word)))
}
#[must_use]
pub fn of(character: char) -> Self {
super::table::of(character)
}
#[must_use]
pub fn as_str(&self) -> &str {
match self {
Self::Arab => "arab",
Self::Armn => "armn",
Self::Beng => "beng",
Self::Bopo => "bopo",
Self::Cans => "cans",
Self::Cyrl => "cyrl",
Self::Deva => "deva",
Self::Ethi => "ethi",
Self::Geor => "geor",
Self::Grek => "grek",
Self::Gujr => "gujr",
Self::Guru => "guru",
Self::Hang => "hang",
Self::Hani => "hani",
Self::Hebr => "hebr",
Self::Hira => "hira",
Self::Kana => "kana",
Self::Khmr => "khmr",
Self::Knda => "knda",
Self::Laoo => "laoo",
Self::Latn => "latn",
Self::Mlym => "mlym",
Self::Mong => "mong",
Self::Mymr => "mymr",
Self::Orya => "orya",
Self::Sinh => "sinh",
Self::Syrc => "syrc",
Self::Taml => "taml",
Self::Telu => "telu",
Self::Thaa => "thaa",
Self::Thai => "thai",
Self::Tibt => "tibt",
Self::Zinh => "zinh",
Self::Zyyy => "zyyy",
Self::Zzzz => "zzzz",
Self::Other(word) => word.as_str(),
}
}
#[must_use]
pub const fn is_contextual(&self) -> bool {
matches!(self, Self::Zyyy | Self::Zinh)
}
#[must_use]
pub const fn is_other(&self) -> bool {
matches!(self, Self::Other(_))
}
}
impl fmt::Display for WritingSystem {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl FromStr for WritingSystem {
type Err = Infallible;
#[inline]
fn from_str(word: &str) -> Result<Self, Self::Err> {
Ok(Self::new(word))
}
}
impl From<&str> for WritingSystem {
#[inline]
fn from(word: &str) -> Self {
Self::new(word)
}
}
impl AsRef<str> for WritingSystem {
#[inline]
fn as_ref(&self) -> &str {
self.as_str()
}
}