Struct icu::locid::extensions::unicode::Keywords

pub struct Keywords(_);

A list of Key-Value pairs representing functional information about locale’s internationnalization preferences.

Here are examples of fields used in Unicode:

• hc - Hour Cycle (h11, h12, h23, h24)
• ca - Calendar (buddhist, gregory, …)
• fw - First Day Of the Week (sun, mon, sat, …)

You can find the full list in Unicode BCP 47 U Extension section of LDML.

Examples

Manually build up a Keywords object:

use icu::locid::{
    extensions::unicode::Keywords, extensions_unicode_key as key,
    extensions_unicode_value as value, locale,
};

let keywords = vec![(key!("hc"), value!("h23"))]
    .into_iter()
    .collect::<Keywords>();

assert_eq!(&keywords.to_string(), "hc-h23");

Access a Keywords object from a Locale:

use icu::locid::{
    extensions_unicode_key as key, extensions_unicode_value as value,
    Locale,
};

let loc: Locale = "und-u-hc-h23-kc-true".parse().expect("Valid BCP-47");

assert_eq!(loc.extensions.unicode.keywords.get(&key!("ca")), None);
assert_eq!(
    loc.extensions.unicode.keywords.get(&key!("hc")),
    Some(&value!("h23"))
);
assert_eq!(
    loc.extensions.unicode.keywords.get(&key!("kc")),
    Some(&value!("true"))
);

assert_eq!(loc.extensions.unicode.keywords.to_string(), "hc-h23-kc");

Implementations

impl Keywords

pub const fn new() -> Keywords

Returns a new empty list of key-value pairs. Same as default(), but is const.

Examples

use icu::locid::extensions::unicode::Keywords;

assert_eq!(Keywords::new(), Keywords::default());

pub const fn new_single(key: Key, value: Value) -> Keywords

Create a new list of key-value pairs having exactly one pair, callable in a const context.

pub fn is_empty(&self) -> bool

Returns true if there are no keywords.

Examples

use icu::locid::extensions::unicode::Keywords;
use icu::locid::locale;
use icu::locid::Locale;

let loc1 = Locale::try_from_bytes(b"und-t-h0-hybrid").unwrap();
let loc2 = locale!("und-u-ca-buddhist");

assert!(loc1.extensions.unicode.keywords.is_empty());
assert!(!loc2.extensions.unicode.keywords.is_empty());

pub fn contains_key<Q>(&self, key: &Q) -> bool where
    Q: Ord,
    Key: Borrow<Q>, 

Returns true if the list contains a Value for the specified Key.

Examples

use icu::locid::{
    extensions::unicode::Keywords, extensions_unicode_key as key,
    extensions_unicode_value as value,
};

let keywords = vec![(key!("ca"), value!("gregory"))]
    .into_iter()
    .collect::<Keywords>();

assert!(&keywords.contains_key(&key!("ca")));

pub fn get<Q>(&self, key: &Q) -> Option<&Value> where
    Q: Ord,
    Key: Borrow<Q>, 

Returns a reference to the Value corresponding to the Key.

Examples

use icu::locid::{
    extensions::unicode::Keywords, extensions_unicode_key as key,
    extensions_unicode_value as value,
};

let keywords = vec![(key!("ca"), value!("buddhist"))]
    .into_iter()
    .collect::<Keywords>();

assert_eq!(keywords.get(&key!("ca")), Some(&value!("buddhist")));

pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut Value> where
    Q: Ord,
    Key: Borrow<Q>, 

Returns a mutable reference to the Value corresponding to the Key.

Returns None if the key doesn’t exist or if the key has no value.

Examples

use icu::locid::{
    extensions::unicode::Keywords, extensions_unicode_key as key,
    extensions_unicode_value as value,
};

let mut keywords = vec![(key!("ca"), value!("buddhist"))]
    .into_iter()
    .collect::<Keywords>();

if let Some(value) = keywords.get_mut(&key!("ca")) {
    *value = value!("gregory");
}
assert_eq!(keywords.get(&key!("ca")), Some(&value!("gregory")));

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

Sets the specified keyword, returning the old value if it already existed.

Examples

use icu::locid::extensions::unicode::Key;
use icu::locid::extensions::unicode::Value;
use icu::locid::Locale;
use icu::locid::{
    extensions_unicode_key as key, extensions_unicode_value as value,
};

let mut loc: Locale = "und-u-hello-ca-buddhist-hc-h12"
    .parse()
    .expect("valid BCP-47 identifier");
let old_value = loc
    .extensions
    .unicode
    .keywords
    .set(key!("ca"), value!("japanese"));

assert_eq!(old_value, Some(value!("buddhist")));
assert_eq!(loc, "und-u-hello-ca-japanese-hc-h12".parse().unwrap());

pub fn remove<Q>(&mut self, key: Q) -> Option<Value> where
    Q: Borrow<Key>, 

Removes the specified keyword, returning the old value if it existed.

Examples

use icu::locid::extensions::unicode::Key;
use icu::locid::extensions_unicode_key as key;
use icu::locid::Locale;

let mut loc: Locale = "und-u-hello-ca-buddhist-hc-h12"
    .parse()
    .expect("valid BCP-47 identifier");
loc.extensions.unicode.keywords.remove(key!("ca"));
assert_eq!(loc, "und-u-hello-hc-h12".parse().unwrap());

pub fn clear(&mut self) -> Keywords

Clears all Unicode extension keywords, leaving Unicode attributes.

Returns the old Unicode extension keywords.

Example

use icu::locid::Locale;

let mut loc: Locale = "und-u-hello-ca-buddhist-hc-h12".parse().unwrap();
loc.extensions.unicode.keywords.clear();
assert_eq!(loc, "und-u-hello".parse().unwrap());

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

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

Examples

use icu::locid::extensions_unicode_key as key;
use icu::locid::Locale;

let mut loc: Locale = "und-u-ca-buddhist-hc-h12-ms-metric".parse().unwrap();

loc.extensions
    .unicode
    .keywords
    .retain_by_key(|&k| k == key!("hc"));
assert_eq!(loc, "und-u-hc-h12".parse().unwrap());

loc.extensions
    .unicode
    .keywords
    .retain_by_key(|&k| k == key!("ms"));
assert_eq!(loc, Locale::UND);

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

Compare this Keywords with BCP-47 bytes.

The return value is equivalent to what would happen if you first converted this Keywords 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::locid::extensions::unicode::Keywords;
use icu::locid::Locale;
use std::cmp::Ordering;

let bcp47_strings: &[&str] =
    &["ca-hebrew", "ca-japanese", "ca-japanese-nu-latn", "nu-latn"];

for ab in bcp47_strings.windows(2) {
    let a = ab[0];
    let b = ab[1];
    assert!(a.cmp(b) == Ordering::Less);
    let a_kwds = format!("und-u-{}", a)
        .parse::<Locale>()
        .unwrap()
        .extensions
        .unicode
        .keywords;
    assert!(a_kwds.strict_cmp(a.as_bytes()) == Ordering::Equal);
    assert!(a_kwds.strict_cmp(b.as_bytes()) == Ordering::Less);
}

pub fn strict_cmp_iter<'l, I>(&self, subtags: I) -> SubtagOrderingResult<I> where
    I: Iterator<Item = &'l [u8]>, 

Compare this Keywords with an iterator of BCP-47 subtags.

This function has the same equality semantics as Keywords::strict_cmp. It is intended as a more modular version that allows multiple subtag iterators to be chained together.

For an additional example, see SubtagOrderingResult.

Examples

use icu::locid::extensions::unicode::Keywords;
use icu::locid::locale;
use std::cmp::Ordering;

let subtags: &[&[u8]] = &[b"ca", b"buddhist"];

let kwds = locale!("und-u-ca-buddhist").extensions.unicode.keywords;
assert_eq!(
    Ordering::Equal,
    kwds.strict_cmp_iter(subtags.iter().copied()).end()
);

let kwds = locale!("und").extensions.unicode.keywords;
assert_eq!(
    Ordering::Less,
    kwds.strict_cmp_iter(subtags.iter().copied()).end()
);

let kwds = locale!("und-u-nu-latn").extensions.unicode.keywords;
assert_eq!(
    Ordering::Greater,
    kwds.strict_cmp_iter(subtags.iter().copied()).end()
);

Trait Implementations

impl Clone for Keywords

fn clone(&self) -> Keywords

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Keywords

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

Formats the value using the given formatter.

impl Default for Keywords

fn default() -> Keywords

Returns the “default value” for a type.

impl Display for Keywords

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

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

Formats the value using the given formatter.

impl From<LiteMap<Key, Value, ShortVec<(Key, Value)>>> for Keywords

fn from(map: LiteMap<Key, Value, ShortVec<(Key, Value)>>) -> Keywords

Converts to this type from the input type.

impl FromIterator<(Key, Value)> for Keywords

fn from_iter<I>(iter: I) -> Keywords where
    I: IntoIterator<Item = (Key, Value)>, 

Creates a value from an iterator.

impl Hash for Keywords

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, 

Feeds a slice of this type into the given Hasher.

impl Ord for Keywords

fn cmp(&self, other: &Keywords) -> 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<Keywords> for Keywords

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

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

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

This method tests for !=.

impl PartialOrd<Keywords> for Keywords

fn partial_cmp(&self, other: &Keywords) -> 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 Keywords

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

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.

fn writeable_length_hint(&self) -> LengthHint

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

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.

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

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

impl Eq for Keywords

impl StructuralEq for Keywords

impl StructuralPartialEq for Keywords