pub struct Keywords(/* private fields */);
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::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§
source§impl Keywords
impl Keywords
sourcepub const fn new_single(key: Key, value: Value) -> Keywords
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.
sourcepub fn try_from_str(s: &str) -> Result<Keywords, ParseError>
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
.
sourcepub fn try_from_utf8(code_units: &[u8]) -> Result<Keywords, ParseError>
pub fn try_from_utf8(code_units: &[u8]) -> Result<Keywords, ParseError>
sourcepub fn is_empty(&self) -> bool
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());
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::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")));
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::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());
sourcepub fn remove<Q>(&mut self, key: Q) -> Option<Value>
pub fn remove<Q>(&mut self, key: Q) -> Option<Value>
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());
sourcepub fn clear(&mut self) -> Keywords
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());
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::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::default());
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::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);
}
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 PartialOrd for Keywords
impl PartialOrd for Keywords
source§impl Writeable for Keywords
impl Writeable for Keywords
source§fn write_to<W>(&self, sink: &mut W) -> Result<(), Error>
fn write_to<W>(&self, sink: &mut W) -> Result<(), Error>
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.impl Eq for Keywords
impl StructuralPartialEq for Keywords
Auto Trait Implementations§
impl Freeze for Keywords
impl RefUnwindSafe for Keywords
impl Send for Keywords
impl Sync for Keywords
impl Unpin for Keywords
impl UnwindSafe for Keywords
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more