Struct icu_provider::DataLocale

source ·
pub struct DataLocale {
    langid: LanguageIdentifier,
    keywords: Keywords,
    aux: Option<AuxiliaryKeys>,
}
Expand description

A locale type optimized for use in fallbacking and the ICU4X data pipeline.

DataLocale contains less functionality than Locale but more than LanguageIdentifier for better size and performance while still meeting the needs of the ICU4X data pipeline.

§Examples

Convert a Locale to a DataLocale and back:

use icu_locid::locale;
use icu_provider::DataLocale;

let locale = locale!("en-u-ca-buddhist");
let data_locale = DataLocale::from(locale);
let locale = data_locale.into_locale();

assert_eq!(locale, locale!("en-u-ca-buddhist"));

You can alternatively create a DataLocale from a borrowed Locale, which is more efficient than cloning the Locale, but less efficient than converting an owned Locale:

use icu_locid::locale;
use icu_provider::DataLocale;

let locale1 = locale!("en-u-ca-buddhist");
let data_locale = DataLocale::from(&locale1);
let locale2 = data_locale.into_locale();

assert_eq!(locale1, locale2);

If you are sure that you have no Unicode keywords, start with LanguageIdentifier:

use icu_locid::langid;
use icu_provider::DataLocale;

let langid = langid!("es-CA-valencia");
let data_locale = DataLocale::from(langid);
let langid = data_locale.get_langid();

assert_eq!(langid, langid!("es-CA-valencia"));

DataLocale only supports -u keywords, to reflect the current state of CLDR data lookup and fallback. This may change in the future.

use icu_locid::{locale, Locale};
use icu_provider::DataLocale;

let locale = "hi-t-en-h0-hybrid-u-attr-ca-buddhist"
    .parse::<Locale>()
    .unwrap();
let data_locale = DataLocale::from(locale);

assert_eq!(data_locale.into_locale(), locale!("hi-u-ca-buddhist"));

Fields§

§langid: LanguageIdentifier§keywords: Keywords§aux: Option<AuxiliaryKeys>

Implementations§

source§

impl DataLocale

source

pub fn strict_cmp(&self, other: &[u8]) -> Ordering

Compare this DataLocale with BCP-47 bytes.

The return value is equivalent to what would happen if you first converted this DataLocale to a BCP-47 string and then performed a byte comparison.

This function is case-sensitive and results in a total order, so it is appropriate for binary search. The only argument producing Ordering::Equal is self.to_string().

§Examples
use icu_provider::DataLocale;
use std::cmp::Ordering;

let bcp47_strings: &[&str] = &[
    "ca",
    "ca-ES",
    "ca-ES-u-ca-buddhist",
    "ca-ES-valencia",
    "ca-ES-x-gbp",
    "ca-ES-x-gbp-short",
    "ca-ES-x-usd",
    "ca-ES-xyzabc",
    "ca-x-eur",
    "cat",
    "pl-Latn-PL",
    "und",
    "und-fonipa",
    "und-u-ca-hebrew",
    "und-u-ca-japanese",
    "und-x-mxn",
    "zh",
];

for ab in bcp47_strings.windows(2) {
    let a = ab[0];
    let b = ab[1];
    assert_eq!(a.cmp(b), Ordering::Less, "strings: {} < {}", a, b);
    let a_loc: DataLocale = a.parse().unwrap();
    assert_eq!(
        a_loc.strict_cmp(a.as_bytes()),
        Ordering::Equal,
        "strict_cmp: {} == {}",
        a_loc,
        a
    );
    assert_eq!(
        a_loc.strict_cmp(b.as_bytes()),
        Ordering::Less,
        "strict_cmp: {} < {}",
        a_loc,
        b
    );
    let b_loc: DataLocale = b.parse().unwrap();
    assert_eq!(
        b_loc.strict_cmp(b.as_bytes()),
        Ordering::Equal,
        "strict_cmp: {} == {}",
        b_loc,
        b
    );
    assert_eq!(
        b_loc.strict_cmp(a.as_bytes()),
        Ordering::Greater,
        "strict_cmp: {} > {}",
        b_loc,
        a
    );
}

Comparison against invalid strings:

use icu_provider::DataLocale;

let invalid_strings: &[&str] = &[
    // Less than "ca-ES"
    "CA",
    "ar-x-gbp-FOO",
    // Greater than "ca-ES-x-gbp"
    "ca_ES",
    "ca-ES-x-gbp-FOO",
];

let data_locale = "ca-ES-x-gbp".parse::<DataLocale>().unwrap();

for s in invalid_strings.iter() {
    let expected_ordering = "ca-ES-x-gbp".cmp(s);
    let actual_ordering = data_locale.strict_cmp(s.as_bytes());
    assert_eq!(expected_ordering, actual_ordering, "{}", s);
}
source§

impl DataLocale

source

pub fn is_empty(&self) -> bool

Returns whether this DataLocale has all empty fields (no components).

See also:

§Examples
use icu_provider::DataLocale;

assert!("und".parse::<DataLocale>().unwrap().is_empty());
assert!(!"und-u-ca-buddhist"
    .parse::<DataLocale>()
    .unwrap()
    .is_empty());
assert!(!"und-x-aux".parse::<DataLocale>().unwrap().is_empty());
assert!(!"ca-ES".parse::<DataLocale>().unwrap().is_empty());
source

pub fn total_cmp(&self, other: &Self) -> Ordering

Returns an ordering suitable for use in BTreeSet.

The ordering may or may not be equivalent to string ordering, and it may or may not be stable across ICU4X releases.

source

pub fn is_und(&self) -> bool

Returns whether this DataLocale is und in the locale and extensions portion.

This ignores auxiliary keys.

See also:

§Examples
use icu_provider::DataLocale;

assert!("und".parse::<DataLocale>().unwrap().is_und());
assert!(!"und-u-ca-buddhist".parse::<DataLocale>().unwrap().is_und());
assert!("und-x-aux".parse::<DataLocale>().unwrap().is_und());
assert!(!"ca-ES".parse::<DataLocale>().unwrap().is_und());
source

pub fn is_langid_und(&self) -> bool

Returns whether the LanguageIdentifier associated with this request is und.

This ignores extension keywords and auxiliary keys.

See also:

§Examples
use icu_provider::DataLocale;

assert!("und".parse::<DataLocale>().unwrap().is_langid_und());
assert!("und-u-ca-buddhist"
    .parse::<DataLocale>()
    .unwrap()
    .is_langid_und());
assert!("und-x-aux".parse::<DataLocale>().unwrap().is_langid_und());
assert!(!"ca-ES".parse::<DataLocale>().unwrap().is_langid_und());
source

pub fn get_langid(&self) -> LanguageIdentifier

Gets the LanguageIdentifier for this DataLocale.

This may allocate memory if there are variant subtags. If you need only the language, script, and/or region subtag, use the specific getters for those subtags:

If you have ownership over the DataLocale, use DataLocale::into_locale() and then access the id field.

§Examples
use icu_locid::langid;
use icu_provider::prelude::*;

const FOO_BAR: DataKey = icu_provider::data_key!("foo/bar@1");

let req_no_langid = DataRequest {
    locale: &Default::default(),
    metadata: Default::default(),
};

let req_with_langid = DataRequest {
    locale: &langid!("ar-EG").into(),
    metadata: Default::default(),
};

assert_eq!(req_no_langid.locale.get_langid(), langid!("und"));
assert_eq!(req_with_langid.locale.get_langid(), langid!("ar-EG"));
source

pub fn set_langid(&mut self, lid: LanguageIdentifier)

Overrides the entire LanguageIdentifier portion of this DataLocale.

source

pub fn into_locale(self) -> Locale

Converts this DataLocale into a Locale.

See also DataLocale::get_langid().

§Examples
use icu_locid::{
    langid, locale,
    subtags::{language, region},
};
use icu_provider::prelude::*;

let locale: DataLocale = locale!("it-IT-u-ca-coptic").into();

assert_eq!(locale.get_langid(), langid!("it-IT"));
assert_eq!(locale.language(), language!("it"));
assert_eq!(locale.script(), None);
assert_eq!(locale.region(), Some(region!("IT")));

let locale = locale.into_locale();
assert_eq!(locale, locale!("it-IT-u-ca-coptic"));

Auxiliary keys are retained:

use icu_provider::prelude::*;
use writeable::assert_writeable_eq;

let data_locale: DataLocale = "und-u-nu-arab-x-gbp".parse().unwrap();
assert_writeable_eq!(data_locale, "und-u-nu-arab-x-gbp");

let recovered_locale = data_locale.into_locale();
assert_writeable_eq!(recovered_locale, "und-u-nu-arab-x-gbp");
source

pub fn language(&self) -> Language

Returns the Language for this DataLocale.

source

pub fn set_language(&mut self, language: Language)

Returns the Language for this DataLocale.

source

pub fn script(&self) -> Option<Script>

Returns the Script for this DataLocale.

source

pub fn set_script(&mut self, script: Option<Script>)

Sets the Script for this DataLocale.

source

pub fn region(&self) -> Option<Region>

Returns the Region for this DataLocale.

source

pub fn set_region(&mut self, region: Option<Region>)

Sets the Region for this DataLocale.

source

pub fn has_variants(&self) -> bool

Returns whether there are any Variant subtags in this DataLocale.

source

pub fn set_variants(&mut self, variants: Variants)

Sets all Variants on this DataLocale, overwriting any that were there previously.

source

pub fn clear_variants(&mut self) -> Variants

Removes all Variant subtags in this DataLocale.

source

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

Gets the value of the specified Unicode extension keyword for this DataLocale.

source

pub fn has_unicode_ext(&self) -> bool

Returns whether there are any Unicode extension keywords in this DataLocale.

source

pub fn contains_unicode_ext(&self, key: &Key) -> bool

Returns whether a specific Unicode extension keyword is present in this DataLocale.

source

pub fn matches_unicode_ext(&self, key: &Key, value: &Value) -> bool

Returns whether this DataLocale contains a Unicode extension keyword with the specified key and value.

§Examples
use icu_locid::extensions::unicode::{key, value};
use icu_provider::prelude::*;

let locale: DataLocale = "it-IT-u-ca-coptic".parse().expect("Valid BCP-47");

assert_eq!(locale.get_unicode_ext(&key!("hc")), None);
assert_eq!(locale.get_unicode_ext(&key!("ca")), Some(value!("coptic")));
assert!(locale.matches_unicode_ext(&key!("ca"), &value!("coptic"),));
source

pub fn set_unicode_ext(&mut self, key: Key, value: Value) -> Option<Value>

Sets the value for a specific Unicode extension keyword on this DataLocale.

source

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

Removes a specific Unicode extension keyword from this DataLocale, returning the value if it was present.

source

pub fn retain_unicode_ext<F>(&mut self, predicate: F)
where F: FnMut(&Key) -> bool,

Retains a subset of keywords as specified by the predicate function.

source

pub fn get_aux(&self) -> Option<&AuxiliaryKeys>

Gets the auxiliary key for this DataLocale.

For more information and examples, see AuxiliaryKeys.

source

pub fn has_aux(&self) -> bool

Returns whether this DataLocale has an auxiliary key.

For more information and examples, see AuxiliaryKeys.

source

pub fn set_aux(&mut self, value: AuxiliaryKeys) -> Option<AuxiliaryKeys>

Sets an auxiliary key on this DataLocale.

Returns the previous auxiliary key if present.

For more information and examples, see AuxiliaryKeys.

source

pub fn remove_aux(&mut self) -> Option<AuxiliaryKeys>

Remove an auxiliary key, if present. Returns the removed auxiliary key.

§Examples
use icu_locid::langid;
use icu_provider::prelude::*;
use writeable::assert_writeable_eq;

let mut data_locale: DataLocale = langid!("ar-EG").into();
let aux = "gbp"
    .parse::<AuxiliaryKeys>()
    .expect("contains valid characters");
data_locale.set_aux(aux);
assert_writeable_eq!(data_locale, "ar-EG-x-gbp");

let maybe_aux = data_locale.remove_aux();
assert_writeable_eq!(data_locale, "ar-EG");
assert_writeable_eq!(maybe_aux.unwrap(), "gbp");

Trait Implementations§

source§

impl Clone for DataLocale

source§

fn clone(&self) -> DataLocale

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for DataLocale

source§

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

Formats the value using the given formatter. Read more
source§

impl<'a> Default for &'a DataLocale

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl Default for DataLocale

source§

fn default() -> DataLocale

Returns the “default value” for a type. Read more
source§

impl Display for DataLocale

This trait is implemented for compatibility with fmt!. To create a string, Writeable::write_to_string is usually more efficient.

source§

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

Formats the value using the given formatter. Read more
source§

impl From<&LanguageIdentifier> for DataLocale

source§

fn from(langid: &LanguageIdentifier) -> Self

Converts to this type from the input type.
source§

impl From<&Locale> for DataLocale

source§

fn from(locale: &Locale) -> Self

Converts to this type from the input type.
source§

impl From<LanguageIdentifier> for DataLocale

source§

fn from(langid: LanguageIdentifier) -> Self

Converts to this type from the input type.
source§

impl From<Locale> for DataLocale

source§

fn from(locale: Locale) -> Self

Converts to this type from the input type.
source§

impl FromStr for DataLocale

§

type Err = DataError

The associated error which can be returned from parsing.
source§

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

Parses a string s to return a value of this type. Read more
source§

impl Hash for DataLocale

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more
source§

impl PartialEq for DataLocale

source§

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

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

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.
source§

impl Writeable for DataLocale

source§

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

Writes a string to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to_parts, and discards any Part annotations.
source§

fn writeable_length_hint(&self) -> LengthHint

Returns a hint for the number of UTF-8 bytes that will be written to the sink. Read more
source§

fn write_to_string(&self) -> Cow<'_, str>

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

fn write_to_parts<S>(&self, sink: &mut S) -> Result<(), Error>
where S: PartsWrite + ?Sized,

Write bytes and Part annotations to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to, and doesn’t produce any Part annotations.
source§

fn writeable_cmp_bytes(&self, other: &[u8]) -> Ordering

Compares the contents of this Writeable to the given bytes without allocating a String to hold the Writeable contents. Read more
source§

impl Eq for DataLocale

source§

impl StructuralPartialEq for DataLocale

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> ErasedDestructor for T
where T: 'static,

source§

impl<T> MaybeSendSync for T