Struct unic_locale::Locale

pub struct Locale {
    pub id: LanguageIdentifier,
    pub extensions: ExtensionsMap,
}

Locale is a core struct representing a Unicode Locale Identifier.

A locale is made of two parts:

• id - Unicode Language Identifier
• extensions - A set of Unicode Extensions

Locale exposes all of the same methods as LanguageIdentifier, and on top of that is able to parse, manipulate and serialize unicode extension fields.

Examples

use unic_locale_impl::Locale;

let loc: Locale = "en-US-u-ca-buddhist".parse()
    .expect("Failed to parse.");

assert_eq!(loc.id.language, "en");
assert_eq!(loc.id.script, None);
assert_eq!(loc.id.region, Some("US".parse().unwrap()));
assert_eq!(loc.id.variants().len(), 0);
assert_eq!(loc.extensions.unicode.keyword("ca")
    .expect("Getting keyword failed.")
    .collect::<Vec<_>>(),
    &["buddhist"]);

Parsing

Unicode recognizes three levels of standard conformance for a locale:

• 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_locale_impl::Locale;

let loc: Locale = "eN_latn_Us-Valencia_u-hC-H12".parse()
    .expect("Failed to parse.");

assert_eq!(loc.id.language, "en");
assert_eq!(loc.id.script, Some("Latn".parse().unwrap()));
assert_eq!(loc.id.region, Some("US".parse().unwrap()));
assert_eq!(loc.id.variants().collect::<Vec<_>>(), &["valencia"]);

Fields

id: LanguageIdentifier

extensions: ExtensionsMap

Implementations

impl Locale

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

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

Examples

use unic_locale_impl::Locale;

let loc = Locale::from_bytes("en-US-u-hc-h12".as_bytes())
    .expect("Parsing failed.");

assert_eq!(loc.to_string(), "en-US-u-hc-h12");

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

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

Examples

use unic_locale_impl::Locale;

let loc = Locale::from_parts("fr".parse().unwrap(), None, Some("CA".parse().unwrap()), &[], None);

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

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

Safety

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

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

Consumes Locale 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_locale_impl::Locale;
use tinystr::{TinyStr8, TinyStr4};

let loc: Locale = "en-US".parse()
    .expect("Parsing failed.");

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

let loc2 = Locale::from_parts(
    lang,
    script,
    region,
    &variants,
    Some(extensions.parse().unwrap())
);

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

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

where O: AsRef<Locale>,

Compares a Locale to another AsRef<Locale 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_locale_impl::Locale;

let loc1: Locale = "en".parse()
    .expect("Parsing failed.");

let loc2: Locale = "en-US".parse()
    .expect("Parsing failed.");

assert_ne!(loc1, loc2); // "en" != "en-US"
assert_ne!(loc1.to_string(), loc2.to_string()); // "en" != "en-US"

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

Trait Implementations

impl AsRef<LanguageIdentifier> for Locale

fn as_ref(&self) -> &LanguageIdentifier

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

impl AsRef<Locale> for Locale

fn as_ref(&self) -> &Locale

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

impl Clone for Locale

fn clone(&self) -> Locale

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Locale

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

Formats the value using the given formatter.

impl Default for Locale

fn default() -> Locale

Returns the “default value” for a type.

impl Display for Locale

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

Formats the value using the given formatter.

impl From<LanguageIdentifier> for Locale

fn from(id: LanguageIdentifier) -> Locale

Converts to this type from the input type.

impl From<Locale> for LanguageIdentifier

fn from(value: Locale) -> LanguageIdentifier

Converts to this type from the input type.

impl FromStr for Locale

type Err = LocaleError

The associated error which can be returned from parsing.

fn from_str(source: &str) -> Result<Locale, <Locale as FromStr>::Err>

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

impl Hash for Locale

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 Locale

fn cmp(&self, other: &Locale) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Locale

fn eq(&self, other: &Locale) -> 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 PartialOrd for Locale

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for Locale

impl StructuralPartialEq for Locale