Struct LanguageIdentifier

pub struct LanguageIdentifier {
    pub language: Language,
    pub script: Option<Script>,
    pub region: Option<Region>,
    pub(crate) variants: Option<Box<[Variant]>>,
}

LanguageIdentifier is a core struct representing a Unicode Language Identifier.

Examples

use unic_langid_impl::LanguageIdentifier;

let li: LanguageIdentifier = "en-US".parse()
    .expect("Failed to parse.");

assert_eq!(li.language, "en");
assert_eq!(li.script, None);
assert_eq!(li.region.as_ref().map(Into::into), Some("US"));
assert_eq!(li.variants().len(), 0);

Parsing

Unicode recognizes three levels of standard conformance for any language identifier:

• well-formed - syntactically correct
• valid - well-formed and only uses registered language subtags, extensions, keywords, types…
• canonical - valid and no deprecated codes or structure.

At the moment parsing normalizes a well-formed language identifier converting _ separators to - and adjusting casing to conform to the Unicode standard.

Any bogus subtags will cause the parsing to fail with an error. No subtag validation is performed.

Examples:

use unic_langid_impl::LanguageIdentifier;

let li: LanguageIdentifier = "eN_latn_Us-Valencia".parse()
    .expect("Failed to parse.");

assert_eq!(li.language, "en");
assert_eq!(li.script.as_ref().map(Into::into), Some("Latn"));
assert_eq!(li.region.as_ref().map(Into::into), Some("US"));
assert_eq!(li.variants().map(|v| v.as_str()).collect::<Vec<_>>(), &["valencia"]);

Fields

language: Language

script: Option<Script>

region: Option<Region>

variants: Option<Box<[Variant]>>

Implementations

impl LanguageIdentifier

pub fn from_bytes( v: &[u8], ) -> Result<LanguageIdentifier, LanguageIdentifierError>

A constructor which takes a utf8 slice, parses it and produces a well-formed LanguageIdentifier.

Examples

use unic_langid_impl::LanguageIdentifier;

let li = LanguageIdentifier::from_bytes("en-US".as_bytes())
    .expect("Parsing failed.");

assert_eq!(li.to_string(), "en-US");

pub fn from_parts( language: Language, script: Option<Script>, region: Option<Region>, variants: &[Variant], ) -> LanguageIdentifier

A constructor which takes optional subtags as AsRef<[u8]>, parses them and produces a well-formed LanguageIdentifier.

Examples

use unic_langid_impl::LanguageIdentifier;

let li = LanguageIdentifier::from_parts(
    "fr".parse().expect("Parsing failed."),
    None,
    Some("CA".parse().expect("Parsing failed.")),
    &[]
);

assert_eq!(li.to_string(), "fr-CA");

pub const fn from_raw_parts_unchecked( language: Language, script: Option<Script>, region: Option<Region>, variants: Option<Box<[Variant]>>, ) -> LanguageIdentifier

Unchecked

This function accepts subtags expecting variants to be deduplicated and ordered.

pub fn into_parts( self, ) -> (Language, Option<Script>, Option<Region>, Vec<Variant>)

Consumes LanguageIdentifier and produces raw internal representations of all subtags in form of u64/u32.

Primarily used for storing internal representation and restoring via from_raw_parts_unchecked.

Examples

use unic_langid_impl::LanguageIdentifier;
use tinystr::{TinyStr8, TinyStr4};

let li: LanguageIdentifier = "en-US".parse()
    .expect("Parsing failed.");

let (lang, script, region, variants) = li.into_parts();

// let li2 = LanguageIdentifier::from_raw_parts_unchecked(
//     lang.map(|l| unsafe { TinyStr8::new_unchecked(l) }),
//    script.map(|s| unsafe { TinyStr4::new_unchecked(s) }),
//    region.map(|r| unsafe { TinyStr4::new_unchecked(r) }),
//    variants.map(|v| v.into_iter().map(|v| unsafe { TinyStr8::new_unchecked(*v) }).collect()),
//);

//assert_eq!(li2.to_string(), "en-US");

pub fn matches<O>( &self, other: &O, self_as_range: bool, other_as_range: bool, ) -> bool

where O: AsRef<LanguageIdentifier>,

Compares a LanguageIdentifier to another AsRef<LanguageIdentifier allowing for either side to use the missing fields as wildcards.

This allows for matching between en (treated as en-*-*-*) and en-US.

Examples

use unic_langid_impl::LanguageIdentifier;

let li1: LanguageIdentifier = "en".parse()
    .expect("Parsing failed.");

let li2: LanguageIdentifier = "en-US".parse()
    .expect("Parsing failed.");

assert_ne!(li1, li2); // "en" != "en-US"
assert_ne!(li1.to_string(), li2.to_string()); // "en" != "en-US"

assert_eq!(li1.matches(&li2, false, false), false); // "en" != "en-US"
assert_eq!(li1.matches(&li2, true, false), true); // "en-*-*-*" == "en-US"
assert_eq!(li1.matches(&li2, false, true), false); // "en" != "en-*-US-*"
assert_eq!(li1.matches(&li2, true, true), true); // "en-*-*-*" == "en-*-US-*"

pub fn variants(&self) -> impl ExactSizeIterator

Returns a vector of variants subtags of the LanguageIdentifier.

Examples

use unic_langid_impl::LanguageIdentifier;

let li1: LanguageIdentifier = "ca-ES-valencia".parse()
    .expect("Parsing failed.");

assert_eq!(li1.variants().map(|v| v.as_str()).collect::<Vec<_>>(), &["valencia"]);

let li2: LanguageIdentifier = "de".parse()
    .expect("Parsing failed.");

assert_eq!(li2.variants().len(), 0);

pub fn set_variants(&mut self, variants: &[Variant])

Sets variant subtags of the LanguageIdentifier.

Examples

use unic_langid_impl::LanguageIdentifier;

let mut li: LanguageIdentifier = "ca-ES".parse()
    .expect("Parsing failed.");

li.set_variants(&["valencia".parse().expect("Parsing failed.")]);

assert_eq!(li.to_string(), "ca-ES-valencia");

pub fn has_variant(&self, variant: Variant) -> bool

Tests if a variant subtag is present in the LanguageIdentifier.

Examples

use unic_langid_impl::LanguageIdentifier;

let mut li: LanguageIdentifier = "ca-ES-macos".parse()
    .expect("Parsing failed.");

assert_eq!(li.has_variant("valencia".parse().unwrap()), false);
assert_eq!(li.has_variant("macos".parse().unwrap()), true);

pub fn clear_variants(&mut self)

Clears variant subtags of the LanguageIdentifier.

Examples

use unic_langid_impl::LanguageIdentifier;

let mut li: LanguageIdentifier = "ca-ES-valencia".parse()
    .expect("Parsing failed.");

li.clear_variants();

assert_eq!(li.to_string(), "ca-ES");

pub fn character_direction(&self) -> CharacterDirection

Returns character direction of the LanguageIdentifier.

Examples

use unic_langid_impl::{LanguageIdentifier, CharacterDirection};

let li1: LanguageIdentifier = "es-AR".parse()
    .expect("Parsing failed.");
let li2: LanguageIdentifier = "fa".parse()
    .expect("Parsing failed.");

assert_eq!(li1.character_direction(), CharacterDirection::LTR);
assert_eq!(li2.character_direction(), CharacterDirection::RTL);

Trait Implementations

impl AsRef<LanguageIdentifier> for LanguageIdentifier

fn as_ref(&self) -> &LanguageIdentifier

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for LanguageIdentifier

fn clone(&self) -> LanguageIdentifier

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LanguageIdentifier

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

Formats the value using the given formatter.

impl Default for LanguageIdentifier

fn default() -> LanguageIdentifier

Returns the “default value” for a type.

impl Display for LanguageIdentifier

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

Formats the value using the given formatter.

impl FromStr for LanguageIdentifier

type Err = LanguageIdentifierError

The associated error which can be returned from parsing.

fn from_str(source: &str) -> Result<LanguageIdentifier, LanguageIdentifierError>

Parses a string s to return a value of this type.

impl Hash for LanguageIdentifier

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

where __H: Hasher,

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 Ord for LanguageIdentifier

fn cmp(&self, other: &LanguageIdentifier) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<&str> for LanguageIdentifier

fn eq(&self, other: &&str) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for LanguageIdentifier

fn eq(&self, other: &LanguageIdentifier) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for LanguageIdentifier

fn partial_cmp(&self, other: &LanguageIdentifier) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for LanguageIdentifier

impl StructuralPartialEq for LanguageIdentifier

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes