aws-sdk-lexmodelbuilding 1.99.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/// When writing a match expression against `Locale`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let locale = unimplemented!();
/// match locale {
///     Locale::DeDe => { /* ... */ },
///     Locale::EnAu => { /* ... */ },
///     Locale::EnGb => { /* ... */ },
///     Locale::EnIn => { /* ... */ },
///     Locale::EnUs => { /* ... */ },
///     Locale::Es419 => { /* ... */ },
///     Locale::EsEs => { /* ... */ },
///     Locale::EsUs => { /* ... */ },
///     Locale::FrCa => { /* ... */ },
///     Locale::FrFr => { /* ... */ },
///     Locale::ItIt => { /* ... */ },
///     Locale::JaJp => { /* ... */ },
///     Locale::KoKr => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `locale` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `Locale::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `Locale::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `Locale::NewFeature` is defined.
/// Specifically, when `locale` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `Locale::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
///
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
)]
pub enum Locale {
    #[allow(missing_docs)] // documentation missing in model
    DeDe,
    #[allow(missing_docs)] // documentation missing in model
    EnAu,
    #[allow(missing_docs)] // documentation missing in model
    EnGb,
    #[allow(missing_docs)] // documentation missing in model
    EnIn,
    #[allow(missing_docs)] // documentation missing in model
    EnUs,
    #[allow(missing_docs)] // documentation missing in model
    Es419,
    #[allow(missing_docs)] // documentation missing in model
    EsEs,
    #[allow(missing_docs)] // documentation missing in model
    EsUs,
    #[allow(missing_docs)] // documentation missing in model
    FrCa,
    #[allow(missing_docs)] // documentation missing in model
    FrFr,
    #[allow(missing_docs)] // documentation missing in model
    ItIt,
    #[allow(missing_docs)] // documentation missing in model
    JaJp,
    #[allow(missing_docs)] // documentation missing in model
    KoKr,
    /// `Unknown` contains new variants that have been added since this code was generated.
    #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
    Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
}
impl ::std::convert::From<&str> for Locale {
    fn from(s: &str) -> Self {
        match s {
            "de-DE" => Locale::DeDe,
            "en-AU" => Locale::EnAu,
            "en-GB" => Locale::EnGb,
            "en-IN" => Locale::EnIn,
            "en-US" => Locale::EnUs,
            "es-419" => Locale::Es419,
            "es-ES" => Locale::EsEs,
            "es-US" => Locale::EsUs,
            "fr-CA" => Locale::FrCa,
            "fr-FR" => Locale::FrFr,
            "it-IT" => Locale::ItIt,
            "ja-JP" => Locale::JaJp,
            "ko-KR" => Locale::KoKr,
            other => Locale::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl ::std::str::FromStr for Locale {
    type Err = ::std::convert::Infallible;

    fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
        ::std::result::Result::Ok(Locale::from(s))
    }
}
impl Locale {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            Locale::DeDe => "de-DE",
            Locale::EnAu => "en-AU",
            Locale::EnGb => "en-GB",
            Locale::EnIn => "en-IN",
            Locale::EnUs => "en-US",
            Locale::Es419 => "es-419",
            Locale::EsEs => "es-ES",
            Locale::EsUs => "es-US",
            Locale::FrCa => "fr-CA",
            Locale::FrFr => "fr-FR",
            Locale::ItIt => "it-IT",
            Locale::JaJp => "ja-JP",
            Locale::KoKr => "ko-KR",
            Locale::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &[
            "de-DE", "en-AU", "en-GB", "en-IN", "en-US", "es-419", "es-ES", "es-US", "fr-CA", "fr-FR", "it-IT", "ja-JP", "ko-KR",
        ]
    }
}
impl ::std::convert::AsRef<str> for Locale {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
impl Locale {
    /// Parses the enum value while disallowing unknown variants.
    ///
    /// Unknown variants will result in an error.
    pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
        match Self::from(value) {
            #[allow(deprecated)]
            Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
            known => Ok(known),
        }
    }
}
impl ::std::fmt::Display for Locale {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        match self {
            Locale::DeDe => write!(f, "de-DE"),
            Locale::EnAu => write!(f, "en-AU"),
            Locale::EnGb => write!(f, "en-GB"),
            Locale::EnIn => write!(f, "en-IN"),
            Locale::EnUs => write!(f, "en-US"),
            Locale::Es419 => write!(f, "es-419"),
            Locale::EsEs => write!(f, "es-ES"),
            Locale::EsUs => write!(f, "es-US"),
            Locale::FrCa => write!(f, "fr-CA"),
            Locale::FrFr => write!(f, "fr-FR"),
            Locale::ItIt => write!(f, "it-IT"),
            Locale::JaJp => write!(f, "ja-JP"),
            Locale::KoKr => write!(f, "ko-KR"),
            Locale::Unknown(value) => write!(f, "{value}"),
        }
    }
}