Struct Keywords

pub struct Keywords(/* private fields */);

A list of Key-Value pairs representing functional information about locale’s internationalization 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::locale::extensions::unicode::{key, value, Keywords};

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

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

Access a Keywords object from a Locale:

use icu::locale::{
    extensions::unicode::{key, 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::locale::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 try_from_str(s: &str) -> Result<Keywords, ParseError>

A constructor which takes a str slice, parses it and produces a well-formed Keywords.

pub fn try_from_utf8(code_units: &[u8]) -> Result<Keywords, ParseError>

See Self::try_from_str

pub fn is_empty(&self) -> bool

Returns true if there are no keywords.

Examples

use icu::locale::locale;
use icu::locale::Locale;

let loc1 = Locale::try_from_str("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 Key: Borrow<Q>, Q: Ord,

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

Examples

use icu::locale::extensions::unicode::{key, value, Keywords};

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

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

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

where Key: Borrow<Q>, Q: Ord,

Returns a reference to the Value corresponding to the Key.

Examples

use icu::locale::extensions::unicode::{key, value, Keywords};

let keywords = [(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 Key: Borrow<Q>, Q: Ord,

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::locale::extensions::unicode::{key, value, Keywords};

let mut keywords = [(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::locale::extensions::unicode::{key, value};
use icu::locale::Locale;

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::locale::extensions::unicode::key;
use icu::locale::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.

Examples

use icu::locale::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::locale::extensions::unicode::key;
use icu::locale::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::UNKNOWN);

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::locale::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 iter(&self) -> impl Iterator<Item = (&Key, &Value)>

Produce an ordered iterator over key-value pairs

impl Keywords

pub fn to_string(&self) -> String

Converts the given value to a String.

Under the hood, this uses an efficient [Writeable] implementation. However, in order to avoid allocating a string, it is more efficient to use [Writeable] directly.

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, ShortBoxSlice<(Key, Value)>>> for Keywords

fn from(map: LiteMap<Key, Value, ShortBoxSlice<(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 FromStr for Keywords

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Keywords, <Keywords as FromStr>::Err>

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

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, Self: Sized,

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

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,

Restrict a value to a certain interval.

impl PartialEq for Keywords

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd 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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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 StructuralPartialEq for Keywords