pub struct Keywords(LiteMap<Key, Value, ShortBoxSlice<(Key, Value)>>);
Expand description
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::locid::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::locid::{
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");
Tuple Fields§
§0: LiteMap<Key, Value, ShortBoxSlice<(Key, Value)>>
Implementations§
source§impl Keywords
impl Keywords
sourcepub const fn new_single(key: Key, value: Value) -> Self
pub const fn new_single(key: Key, value: Value) -> Self
Create a new list of key-value pairs having exactly one pair, callable in a const
context.
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true
if there are no keywords.
§Examples
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());
sourcepub fn contains_key<Q>(&self, key: &Q) -> bool
pub fn contains_key<Q>(&self, key: &Q) -> bool
sourcepub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut Value>
pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut Value>
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::{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")));
sourcepub fn set(&mut self, key: Key, value: Value) -> Option<Value>
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, value};
use icu::locid::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());
sourcepub fn remove<Q: Borrow<Key>>(&mut self, key: Q) -> Option<Value>
pub fn remove<Q: Borrow<Key>>(&mut self, key: Q) -> Option<Value>
Removes the specified keyword, returning the old value if it existed.
§Examples
use icu::locid::extensions::unicode::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());
sourcepub fn clear(&mut self) -> Self
pub fn clear(&mut self) -> Self
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());
sourcepub fn retain_by_key<F>(&mut self, predicate: F)
pub fn retain_by_key<F>(&mut self, predicate: F)
Retains a subset of keywords as specified by the predicate function.
§Examples
use icu::locid::extensions::unicode::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);
sourcepub fn strict_cmp(&self, other: &[u8]) -> Ordering
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::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);
}
sourcepub fn strict_cmp_iter<'l, I>(&self, subtags: I) -> SubtagOrderingResult<I>
👎Deprecated since 1.5.0: if you need this, please file an issue
pub fn strict_cmp_iter<'l, I>(&self, subtags: I) -> SubtagOrderingResult<I>
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::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()
);
pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
Trait Implementations§
source§impl Display for Keywords
impl Display for Keywords
This trait is implemented for compatibility with fmt!
.
To create a string, Writeable::write_to_string
is usually more efficient.
source§impl Ord for Keywords
impl Ord for Keywords
source§impl PartialEq for Keywords
impl PartialEq for Keywords
source§impl PartialOrd for Keywords
impl PartialOrd for Keywords
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl Writeable for Keywords
impl Writeable for Keywords
source§fn write_to<W: Write + ?Sized>(&self, sink: &mut W) -> Result
fn write_to<W: Write + ?Sized>(&self, sink: &mut W) -> Result
write_to_parts
, and discards any
Part
annotations.source§fn writeable_length_hint(&self) -> LengthHint
fn writeable_length_hint(&self) -> LengthHint
source§fn write_to_parts<S>(&self, sink: &mut S) -> Result<(), Error>where
S: PartsWrite + ?Sized,
fn write_to_parts<S>(&self, sink: &mut S) -> Result<(), Error>where
S: PartsWrite + ?Sized,
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.