Struct rosetta_i18n::LanguageId

pub struct LanguageId<'a>(_);

ISO 639-1 language identifier.

This type holds a string representing a language in the ISO 693-1 format (two-letter code). The inner value is stored in a Cow to avoid allocation when possible.

Validation

The type inner value is not validated unless the validate method is used to initialize the instance. Generally, you should use this method to initialize this type.

The performed validation only checks that the provided looks like an ISO 693-1language identifier (2 character alphanumeric ascii string).

Serde support

This type implements the Serialize and Deserialize traits if the serde feature is enabled. Deserialization will fail if the value is not an ISO 639-1 language identifier.

Example

use rosetta_i18n::LanguageId;

let language_id = LanguageId::new("fr");
assert_eq!(language_id.value(), "fr");

let language_id = LanguageId::validate("fr");
assert!(language_id.is_some());

Implementations

impl<'a> LanguageId<'a>

pub fn validate(value: &str) -> Option<Self>

Initialize a new valid LanguageId.

Unlike new, this method ensures that the provided value is a valid ISO 693-1 encoded language id.

assert!(LanguageId::validate("fr").is_some());
assert!(LanguageId::validate("invalid").is_none());

pub fn new(value: impl Into<Cow<'a, str>>) -> Self

Initialize a new LanguageId from a string.

The provided value must be an ISO 693-1 encoded language id. If you want to validate the value, use validate instead.

let language_id = LanguageId::new("en");
assert_eq!(language_id.value(), "en");

pub fn value(&self) -> &str

Return a reference of the inner value.

pub fn into_inner(self) -> String

Convert the type into a String.

Trait Implementations

impl<'a> Clone for LanguageId<'a>

fn clone(&self) -> LanguageId<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for LanguageId<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LanguageId<'de>

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Hash for LanguageId<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq<LanguageId<'a>> for LanguageId<'a>

fn eq(&self, other: &LanguageId<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for LanguageId<'_>

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for LanguageId<'a>

impl<'a> StructuralEq for LanguageId<'a>

impl<'a> StructuralPartialEq for LanguageId<'a>