Struct icu_locid::extensions::unicode::Keywords
source · 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::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");
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()
);
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: 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.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
)