use serde::{Deserialize, Serialize};
#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
pub enum Lang {
AB,
AA,
AF,
AK,
SQ,
AM,
AR,
AN,
HY,
AS,
AV,
AE,
AY,
AZ,
BM,
BA,
EU,
BE,
BN,
BI,
BS,
BR,
BG,
MY,
CA,
CH,
CE,
NY,
ZH,
CU,
CV,
KW,
CO,
CR,
HR,
CS,
DA,
DV,
NL,
DZ,
EN,
EO,
ET,
EE,
FO,
FJ,
FI,
FR,
FY,
FF,
GD,
GL,
LG,
KA,
DE,
EL,
KL,
GN,
GU,
HT,
HA,
HE,
HZ,
HI,
HO,
HU,
IS,
IO,
IG,
ID,
IA,
IE,
IU,
IK,
GA,
IT,
JA,
JV,
KN,
KR,
KS,
KK,
KM,
KI,
RW,
KY,
KV,
KG,
KO,
KJ,
KU,
LO,
LA,
LV,
LI,
LN,
LT,
LU,
LB,
MK,
MG,
MS,
ML,
MT,
GV,
MI,
MR,
MH,
MN,
NA,
NV,
ND,
NR,
NG,
NE,
NO,
NB,
NN,
II,
OC,
OJ,
OR,
OM,
OS,
PI,
PS,
FA,
PL,
PT,
PA,
QU,
RO,
RM,
RN,
RU,
SE,
SM,
SG,
SA,
SC,
SR,
SN,
SD,
SI,
SK,
SL,
SO,
ST,
ES,
SU,
SW,
SS,
SV,
TL,
TY,
TG,
TA,
TT,
TE,
TH,
BO,
TI,
TO,
TS,
TN,
TR,
TK,
TW,
UG,
UK,
UR,
UZ,
VE,
VI,
VO,
WA,
CY,
WO,
XH,
YI,
YO,
ZA,
ZU,
}
impl Lang {
pub fn string(&self) -> &str {
match self {
Self::AB => "ab",
Self::AA => "aa",
Self::AF => "af",
Self::AK => "ak",
Self::SQ => "sq",
Self::AM => "am",
Self::AR => "ar",
Self::AN => "an",
Self::HY => "hy",
Self::AS => "as",
Self::AV => "av",
Self::AE => "ae",
Self::AY => "ay",
Self::AZ => "az",
Self::BM => "bm",
Self::BA => "ba",
Self::EU => "eu",
Self::BE => "be",
Self::BN => "bn",
Self::BI => "bi",
Self::BS => "bs",
Self::BR => "br",
Self::BG => "bg",
Self::MY => "my",
Self::CA => "ca",
Self::CH => "ch",
Self::CE => "ce",
Self::NY => "ny",
Self::ZH => "zh",
Self::CU => "cu",
Self::CV => "cv",
Self::KW => "kw",
Self::CO => "co",
Self::CR => "cr",
Self::HR => "hr",
Self::CS => "cs",
Self::DA => "da",
Self::DV => "dv",
Self::NL => "nl",
Self::DZ => "dz",
Self::EN => "en",
Self::EO => "eo",
Self::ET => "et",
Self::EE => "ee",
Self::FO => "fo",
Self::FJ => "fj",
Self::FI => "fi",
Self::FR => "fr",
Self::FY => "fy",
Self::FF => "ff",
Self::GD => "gd",
Self::GL => "gl",
Self::LG => "lg",
Self::KA => "ka",
Self::DE => "de",
Self::EL => "el",
Self::KL => "kl",
Self::GN => "gn",
Self::GU => "gu",
Self::HT => "ht",
Self::HA => "ha",
Self::HE => "he",
Self::HZ => "hz",
Self::HI => "hi",
Self::HO => "ho",
Self::HU => "hu",
Self::IS => "is",
Self::IO => "io",
Self::IG => "ig",
Self::ID => "id",
Self::IA => "ia",
Self::IE => "ie",
Self::IU => "iu",
Self::IK => "ik",
Self::GA => "ga",
Self::IT => "it",
Self::JA => "ja",
Self::JV => "jv",
Self::KN => "kn",
Self::KR => "kr",
Self::KS => "ks",
Self::KK => "kk",
Self::KM => "km",
Self::KI => "ki",
Self::RW => "rw",
Self::KY => "ky",
Self::KV => "kv",
Self::KG => "kg",
Self::KO => "ko",
Self::KJ => "kj",
Self::KU => "ku",
Self::LO => "lo",
Self::LA => "la",
Self::LV => "lv",
Self::LI => "li",
Self::LN => "ln",
Self::LT => "lt",
Self::LU => "lu",
Self::LB => "lb",
Self::MK => "mk",
Self::MG => "mg",
Self::MS => "ms",
Self::ML => "ml",
Self::MT => "mt",
Self::GV => "gv",
Self::MI => "mi",
Self::MR => "mr",
Self::MH => "mh",
Self::MN => "mn",
Self::NA => "na",
Self::NV => "nv",
Self::ND => "nd",
Self::NR => "nr",
Self::NG => "ng",
Self::NE => "ne",
Self::NO => "no",
Self::NB => "nb",
Self::NN => "nn",
Self::II => "ii",
Self::OC => "oc",
Self::OJ => "oj",
Self::OR => "or",
Self::OM => "om",
Self::OS => "os",
Self::PI => "pi",
Self::PS => "ps",
Self::FA => "fa",
Self::PL => "pl",
Self::PT => "pt",
Self::PA => "pa",
Self::QU => "qu",
Self::RO => "ro",
Self::RM => "rm",
Self::RN => "rn",
Self::RU => "ru",
Self::SE => "se",
Self::SM => "sm",
Self::SG => "sg",
Self::SA => "sa",
Self::SC => "sc",
Self::SR => "sr",
Self::SN => "sn",
Self::SD => "sd",
Self::SI => "si",
Self::SK => "sk",
Self::SL => "sl",
Self::SO => "so",
Self::ST => "st",
Self::ES => "es",
Self::SU => "su",
Self::SW => "sw",
Self::SS => "ss",
Self::SV => "sv",
Self::TL => "tl",
Self::TY => "ty",
Self::TG => "tg",
Self::TA => "ta",
Self::TT => "tt",
Self::TE => "te",
Self::TH => "th",
Self::BO => "bo",
Self::TI => "ti",
Self::TO => "to",
Self::TS => "ts",
Self::TN => "tn",
Self::TR => "tr",
Self::TK => "tk",
Self::TW => "tw",
Self::UG => "ug",
Self::UK => "uk",
Self::UR => "ur",
Self::UZ => "uz",
Self::VE => "ve",
Self::VI => "vi",
Self::VO => "vo",
Self::WA => "wa",
Self::CY => "cy",
Self::WO => "wo",
Self::XH => "xh",
Self::YI => "yi",
Self::YO => "yo",
Self::ZA => "za",
Self::ZU => "zu",
}
}
}
impl TryFrom<&str> for Lang {
type Error = ();
fn try_from(value: &str) -> Result<Self, Self::Error> {
match value {
"ab" => Ok(Self::AB),
"aa" => Ok(Self::AA),
"af" => Ok(Self::AF),
"ak" => Ok(Self::AK),
"sq" => Ok(Self::SQ),
"am" => Ok(Self::AM),
"ar" => Ok(Self::AR),
"an" => Ok(Self::AN),
"hy" => Ok(Self::HY),
"as" => Ok(Self::AS),
"av" => Ok(Self::AV),
"ae" => Ok(Self::AE),
"ay" => Ok(Self::AY),
"az" => Ok(Self::AZ),
"bm" => Ok(Self::BM),
"ba" => Ok(Self::BA),
"eu" => Ok(Self::EU),
"be" => Ok(Self::BE),
"bn" => Ok(Self::BN),
"bi" => Ok(Self::BI),
"bs" => Ok(Self::BS),
"br" => Ok(Self::BR),
"bg" => Ok(Self::BG),
"my" => Ok(Self::MY),
"ca" => Ok(Self::CA),
"ch" => Ok(Self::CH),
"ce" => Ok(Self::CE),
"ny" => Ok(Self::NY),
"zh" => Ok(Self::ZH),
"cu" => Ok(Self::CU),
"cv" => Ok(Self::CV),
"kw" => Ok(Self::KW),
"co" => Ok(Self::CO),
"cr" => Ok(Self::CR),
"hr" => Ok(Self::HR),
"cs" => Ok(Self::CS),
"da" => Ok(Self::DA),
"dv" => Ok(Self::DV),
"nl" => Ok(Self::NL),
"dz" => Ok(Self::DZ),
"en" => Ok(Self::EN),
"eo" => Ok(Self::EO),
"et" => Ok(Self::ET),
"ee" => Ok(Self::EE),
"fo" => Ok(Self::FO),
"fj" => Ok(Self::FJ),
"fi" => Ok(Self::FI),
"fr" => Ok(Self::FR),
"fy" => Ok(Self::FY),
"ff" => Ok(Self::FF),
"gd" => Ok(Self::GD),
"gl" => Ok(Self::GL),
"lg" => Ok(Self::LG),
"ka" => Ok(Self::KA),
"de" => Ok(Self::DE),
"el" => Ok(Self::EL),
"kl" => Ok(Self::KL),
"gn" => Ok(Self::GN),
"gu" => Ok(Self::GU),
"ht" => Ok(Self::HT),
"ha" => Ok(Self::HA),
"he" => Ok(Self::HE),
"hz" => Ok(Self::HZ),
"hi" => Ok(Self::HI),
"ho" => Ok(Self::HO),
"hu" => Ok(Self::HU),
"is" => Ok(Self::IS),
"io" => Ok(Self::IO),
"ig" => Ok(Self::IG),
"id" => Ok(Self::ID),
"ia" => Ok(Self::IA),
"ie" => Ok(Self::IE),
"iu" => Ok(Self::IU),
"ik" => Ok(Self::IK),
"ga" => Ok(Self::GA),
"it" => Ok(Self::IT),
"ja" => Ok(Self::JA),
"jv" => Ok(Self::JV),
"kn" => Ok(Self::KN),
"kr" => Ok(Self::KR),
"ks" => Ok(Self::KS),
"kk" => Ok(Self::KK),
"km" => Ok(Self::KM),
"ki" => Ok(Self::KI),
"rw" => Ok(Self::RW),
"ky" => Ok(Self::KY),
"kv" => Ok(Self::KV),
"kg" => Ok(Self::KG),
"ko" => Ok(Self::KO),
"kj" => Ok(Self::KJ),
"ku" => Ok(Self::KU),
"lo" => Ok(Self::LO),
"la" => Ok(Self::LA),
"lv" => Ok(Self::LV),
"li" => Ok(Self::LI),
"ln" => Ok(Self::LN),
"lt" => Ok(Self::LT),
"lu" => Ok(Self::LU),
"lb" => Ok(Self::LB),
"mk" => Ok(Self::MK),
"mg" => Ok(Self::MG),
"ms" => Ok(Self::MS),
"ml" => Ok(Self::ML),
"mt" => Ok(Self::MT),
"gv" => Ok(Self::GV),
"mi" => Ok(Self::MI),
"mr" => Ok(Self::MR),
"mh" => Ok(Self::MH),
"mn" => Ok(Self::MN),
"na" => Ok(Self::NA),
"nv" => Ok(Self::NV),
"nd" => Ok(Self::ND),
"nr" => Ok(Self::NR),
"ng" => Ok(Self::NG),
"ne" => Ok(Self::NE),
"no" => Ok(Self::NO),
"nb" => Ok(Self::NB),
"nn" => Ok(Self::NN),
"ii" => Ok(Self::II),
"oc" => Ok(Self::OC),
"oj" => Ok(Self::OJ),
"or" => Ok(Self::OR),
"om" => Ok(Self::OM),
"os" => Ok(Self::OS),
"pi" => Ok(Self::PI),
"ps" => Ok(Self::PS),
"fa" => Ok(Self::FA),
"pl" => Ok(Self::PL),
"pt" => Ok(Self::PT),
"pa" => Ok(Self::PA),
"qu" => Ok(Self::QU),
"ro" => Ok(Self::RO),
"rm" => Ok(Self::RM),
"rn" => Ok(Self::RN),
"ru" => Ok(Self::RU),
"se" => Ok(Self::SE),
"sm" => Ok(Self::SM),
"sg" => Ok(Self::SG),
"sa" => Ok(Self::SA),
"sc" => Ok(Self::SC),
"sr" => Ok(Self::SR),
"sn" => Ok(Self::SN),
"sd" => Ok(Self::SD),
"si" => Ok(Self::SI),
"sk" => Ok(Self::SK),
"sl" => Ok(Self::SL),
"so" => Ok(Self::SO),
"st" => Ok(Self::ST),
"es" => Ok(Self::ES),
"su" => Ok(Self::SU),
"sw" => Ok(Self::SW),
"ss" => Ok(Self::SS),
"sv" => Ok(Self::SV),
"tl" => Ok(Self::TL),
"ty" => Ok(Self::TY),
"tg" => Ok(Self::TG),
"ta" => Ok(Self::TA),
"tt" => Ok(Self::TT),
"te" => Ok(Self::TE),
"th" => Ok(Self::TH),
"bo" => Ok(Self::BO),
"ti" => Ok(Self::TI),
"to" => Ok(Self::TO),
"ts" => Ok(Self::TS),
"tn" => Ok(Self::TN),
"tr" => Ok(Self::TR),
"tk" => Ok(Self::TK),
"tw" => Ok(Self::TW),
"ug" => Ok(Self::UG),
"uk" => Ok(Self::UK),
"ur" => Ok(Self::UR),
"uz" => Ok(Self::UZ),
"ve" => Ok(Self::VE),
"vi" => Ok(Self::VI),
"vo" => Ok(Self::VO),
"wa" => Ok(Self::WA),
"cy" => Ok(Self::CY),
"wo" => Ok(Self::WO),
"xh" => Ok(Self::XH),
"yi" => Ok(Self::YI),
"yo" => Ok(Self::YO),
"za" => Ok(Self::ZA),
"zu" => Ok(Self::ZU),
_ => Err(()),
}
}
}
impl std::fmt::Display for Lang {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.string())
}
}