Struct icu::locid::Locale [−][src]
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
[src]
impl Locale
[src]pub fn from_bytes(v: &[u8]) -> Result<Locale, ParserError>
[src]
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() -> Locale
[src]
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>(input: S) -> Result<String, ParserError> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
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()));
Trait Implementations
impl AsMut<LanguageIdentifier> for Locale
[src]
impl AsMut<LanguageIdentifier> for Locale
[src]pub fn as_mut(&mut self) -> &mut LanguageIdentifier
[src]
impl AsRef<LanguageIdentifier> for Locale
[src]
impl AsRef<LanguageIdentifier> for Locale
[src]pub fn as_ref(&self) -> &LanguageIdentifier
[src]
impl From<LanguageIdentifier> for Locale
[src]
impl From<LanguageIdentifier> for Locale
[src]pub fn from(id: LanguageIdentifier) -> Locale
[src]
impl From<Locale> for LanguageIdentifier
[src]
impl From<Locale> for LanguageIdentifier
[src]pub fn from(loc: Locale) -> LanguageIdentifier
[src]
impl PartialOrd<Locale> for Locale
[src]
impl PartialOrd<Locale> for Locale
[src]impl StructuralEq for Locale
[src]
impl StructuralEq for Locale
[src]impl StructuralPartialEq for Locale
[src]
impl StructuralPartialEq for Locale
[src]Auto Trait Implementations
impl RefUnwindSafe for Locale
impl RefUnwindSafe for Locale
impl UnwindSafe for Locale
impl UnwindSafe for Locale