Struct icu_locid::Locale

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

A core struct representing a Unicode Locale Identifier.

A locale is made of two parts:

• Unicode Language Identifier
• A set of Unicode Extensions

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

Examples

use icu::locid::Locale;
use icu::locid::extensions::unicode::{Key, Value};

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, "en-US-u-ca-buddhist");

let key: Key = "ca".parse().expect("Parsing key failed.");
let value: Value = "buddhist".parse().expect("Parsing value failed.");
assert_eq!(loc.extensions.unicode.keywords.get(key),
    Some(&value));

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 locale 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 icu::locid::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.get(0).unwrap(), "valencia");

Fields

id: LanguageIdentifier

extensions: Extensions

Implementations

impl Locale

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

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

Examples

use icu::locid::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 const fn und() -> Self

Returns the default undefined locale “und”. Same as default(), but is const.

Examples

use icu::locid::Locale;

const loc: Locale = Locale::und();
assert_eq!(Locale::default(), loc);
assert_eq!("und", loc.to_string());

pub fn canonicalize<S: AsRef<[u8]>>(input: S) -> Result<String, ParserError>

This is a best-effort operation that performs all available levels of canonicalization.

At the moment the operation will normalize casing and the separator, but in the future it may also validate and update from deprecated subtags to canonical ones.

Examples

use icu::locid::Locale;

assert_eq!(Locale::canonicalize("pL_latn_pl-U-HC-H12"), Ok("pl-Latn-PL-u-hc-h12".to_string()));

pub fn get_unicode_extension(&self, key: &Key) -> Option<&Value>

Accessor method for unicode extensions.

Examples

use icu::locid::{extensions::unicode::Key, Locale};

let loc = Locale::from_bytes("en-US-u-hc-h12".as_bytes())
    .expect("Parsing failed.");
let key = "hc".parse::<Key>()
    .expect("Invalid key.");
let ext = loc.get_unicode_extension(&key)
    .expect("Extension not defined");
assert_eq!(ext.to_string(), "h12");

Trait Implementations

impl AsMut<LanguageIdentifier> for Locale

fn as_mut(&mut self) -> &mut LanguageIdentifier

Performs the conversion.

impl AsRef<LanguageIdentifier> for Locale

fn as_ref(&self) -> &LanguageIdentifier

Performs the conversion.

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

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

Formats the value using the given formatter.

impl From<LanguageIdentifier> for Locale

fn from(id: LanguageIdentifier) -> Self

Performs the conversion.

impl From<Locale> for LanguageIdentifier

fn from(loc: Locale) -> Self

Performs the conversion.

impl FromStr for Locale

type Err = ParserError

The associated error which can be returned from parsing.

fn from_str(source: &str) -> Result<Self, Self::Err>

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

impl Hash for Locale

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, 

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl PartialEq<&'_ str> for Locale

fn eq(&self, other: &&str) -> 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 !=.

impl PartialEq<Locale> 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: &Locale) -> bool

This method tests for !=.

impl PartialEq<str> for Locale

fn eq(&self, other: &str) -> 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 !=.

impl PartialOrd<Locale> 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 Writeable for Locale

fn write_to<W: Write + ?Sized>(&self, sink: &mut W) -> Result

Writes bytes to the given sink. Errors from the sink are bubbled up.

fn write_len(&self) -> LengthHint

Returns a hint for the number of bytes that will be written to the sink.

fn writeable_to_string(&self) -> String

Creates a new String with the data from this Writeable. Like ToString, but smaller and faster.

impl Eq for Locale

impl StructuralEq for Locale

impl StructuralPartialEq for Locale