rustyfit 0.10.0

// Code generated by fitgen/main.go. DO NOT EDIT.

// Copyright 2025 The RustyFIT Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

use core::fmt;
#[cfg(feature = "serde")]
use serde::{Deserialize, Deserializer, Serialize, Serializer, de, ser::SerializeStruct};

/// Language type.
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Language(pub u8);

impl Language {
    pub const ENGLISH: Language = Language(0);
    pub const FRENCH: Language = Language(1);
    pub const ITALIAN: Language = Language(2);
    pub const GERMAN: Language = Language(3);
    pub const SPANISH: Language = Language(4);
    pub const CROATIAN: Language = Language(5);
    pub const CZECH: Language = Language(6);
    pub const DANISH: Language = Language(7);
    pub const DUTCH: Language = Language(8);
    pub const FINNISH: Language = Language(9);
    pub const GREEK: Language = Language(10);
    pub const HUNGARIAN: Language = Language(11);
    pub const NORWEGIAN: Language = Language(12);
    pub const POLISH: Language = Language(13);
    pub const PORTUGUESE: Language = Language(14);
    pub const SLOVAKIAN: Language = Language(15);
    pub const SLOVENIAN: Language = Language(16);
    pub const SWEDISH: Language = Language(17);
    pub const RUSSIAN: Language = Language(18);
    pub const TURKISH: Language = Language(19);
    pub const LATVIAN: Language = Language(20);
    pub const UKRAINIAN: Language = Language(21);
    pub const ARABIC: Language = Language(22);
    pub const FARSI: Language = Language(23);
    pub const BULGARIAN: Language = Language(24);
    pub const ROMANIAN: Language = Language(25);
    pub const CHINESE: Language = Language(26);
    pub const JAPANESE: Language = Language(27);
    pub const KOREAN: Language = Language(28);
    pub const TAIWANESE: Language = Language(29);
    pub const THAI: Language = Language(30);
    pub const HEBREW: Language = Language(31);
    pub const BRAZILIAN_PORTUGUESE: Language = Language(32);
    pub const INDONESIAN: Language = Language(33);
    pub const MALAYSIAN: Language = Language(34);
    pub const VIETNAMESE: Language = Language(35);
    pub const BURMESE: Language = Language(36);
    pub const MONGOLIAN: Language = Language(37);
    pub const CUSTOM: Language = Language(254);

    fn as_str(self) -> Option<&'static str> {
        match self.0 {
            0 => Some("english"),
            1 => Some("french"),
            2 => Some("italian"),
            3 => Some("german"),
            4 => Some("spanish"),
            5 => Some("croatian"),
            6 => Some("czech"),
            7 => Some("danish"),
            8 => Some("dutch"),
            9 => Some("finnish"),
            10 => Some("greek"),
            11 => Some("hungarian"),
            12 => Some("norwegian"),
            13 => Some("polish"),
            14 => Some("portuguese"),
            15 => Some("slovakian"),
            16 => Some("slovenian"),
            17 => Some("swedish"),
            18 => Some("russian"),
            19 => Some("turkish"),
            20 => Some("latvian"),
            21 => Some("ukrainian"),
            22 => Some("arabic"),
            23 => Some("farsi"),
            24 => Some("bulgarian"),
            25 => Some("romanian"),
            26 => Some("chinese"),
            27 => Some("japanese"),
            28 => Some("korean"),
            29 => Some("taiwanese"),
            30 => Some("thai"),
            31 => Some("hebrew"),
            32 => Some("brazilian_portuguese"),
            33 => Some("indonesian"),
            34 => Some("malaysian"),
            35 => Some("vietnamese"),
            36 => Some("burmese"),
            37 => Some("mongolian"),
            254 => Some("custom"),
            _ => None,
        }
    }
}

impl Default for Language {
    fn default() -> Self {
        Self(u8::MAX)
    }
}

impl fmt::Display for Language {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.as_str() {
            Some(s) => write!(f, "{}", s),
            None => write!(f, "Language({})", self.0),
        }
    }
}

#[cfg(feature = "serde")]
impl Serialize for Language {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("Language", 2)?;
        if let Some(s) = self.as_str() {
            state.serialize_field("t", s)?;
        }
        state.serialize_field("c", &self.0)?;
        state.end()
    }
}

#[cfg(feature = "serde")]
#[cfg_attr(feature = "serde", derive(Deserialize))]
struct De<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    t: Option<&'a str>,
    c: u8,
}

#[cfg(feature = "serde")]
impl<'de> Deserialize<'de> for Language {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let repr = De::deserialize(deserializer)?;
        let v = Self(repr.c);
        if let Some(t) = repr.t
            && let Some(s) = v.as_str()
            && t != s
        {
            return Err(de::Error::custom("tag and content mismatch"));
        }
        Ok(v)
    }
}