Struct icu_provider::AuxiliaryKeys

pub struct AuxiliaryKeys { /* private fields */ }

The “auxiliary key” is an annotation on DataLocale that can contain an arbitrary information that does not fit into the LanguageIdentifier or Keywords.

A DataLocale can have multiple auxiliary keys, represented by this struct. The auxiliary keys are stored as private use subtags following -x-.

An auxiliary key currently allows 1-8 lowercase alphanumerics.

🚧 This code is experimental; it may change at any time, in breaking or non-breaking ways, including in SemVer minor releases. It can be enabled with the "experimental" Cargo feature of the `icu_provider` crate. Use with caution. #3632

Examples

use icu_locid::locale;
use icu_provider::prelude::*;
use writeable::assert_writeable_eq;

let mut data_locale: DataLocale = locale!("ar-EG").into();
assert_writeable_eq!(data_locale, "ar-EG");
assert!(!data_locale.has_aux());
assert_eq!(data_locale.get_aux(), None);

let aux = "gbp"
    .parse::<AuxiliaryKeys>()
    .expect("contains valid characters");

data_locale.set_aux(aux);
assert_writeable_eq!(data_locale, "ar-EG-x-gbp");
assert!(data_locale.has_aux());
assert_eq!(data_locale.get_aux(), Some(&"gbp".parse().unwrap()));

Multiple auxiliary keys are allowed:

use icu_locid::locale;
use icu_provider::prelude::*;
use writeable::assert_writeable_eq;

let data_locale = "ar-EG-x-gbp-long".parse::<DataLocale>().unwrap();
assert_writeable_eq!(data_locale, "ar-EG-x-gbp-long");
assert_eq!(data_locale.get_aux().unwrap().iter().count(), 2);

Not all strings are valid auxiliary keys. The string must be well-formed and case-normalized:

use icu_provider::prelude::*;

assert!("abcdefg".parse::<AuxiliaryKeys>().is_ok());
assert!("abc-xyz".parse::<AuxiliaryKeys>().is_ok());

assert!("".parse::<AuxiliaryKeys>().is_err());
assert!("!@#$%".parse::<AuxiliaryKeys>().is_err());
assert!("abc_xyz".parse::<AuxiliaryKeys>().is_err());
assert!("ABC123".parse::<AuxiliaryKeys>().is_err());

Implementations

impl AuxiliaryKeys

pub fn try_from_iter( iter: impl IntoIterator<Item = Subtag> ) -> Result<Self, DataError>

Creates an AuxiliaryKeys from an iterator of individual keys.

Examples

use icu_locid::extensions::private::subtag;
use icu_provider::prelude::*;

// Single auxiliary key:
let a = AuxiliaryKeys::try_from_iter([subtag!("abc")]).unwrap();
let b = "abc".parse::<AuxiliaryKeys>().unwrap();
assert_eq!(a, b);

// Multiple auxiliary keys:
let a = AuxiliaryKeys::try_from_iter([subtag!("abc"), subtag!("defg")])
    .unwrap();
let b = "abc-defg".parse::<AuxiliaryKeys>().unwrap();
assert_eq!(a, b);

The iterator can’t be empty:

use icu_provider::prelude::*;

assert!(AuxiliaryKeys::try_from_iter([]).is_err());

pub const fn from_subtag(input: Subtag) -> Self

Creates an AuxiliaryKeys from a single subtag.

Examples

use icu_locid::extensions::private::subtag;
use icu_provider::prelude::*;

// Single auxiliary key:
let a = AuxiliaryKeys::from_subtag(subtag!("abc"));
let b = "abc".parse::<AuxiliaryKeys>().unwrap();
assert_eq!(a, b);

pub fn iter(&self) -> impl Iterator<Item = Subtag> + '_

Iterates over the components of the auxiliary key.

Example

use icu_locid::extensions::private::subtag;
use icu_provider::AuxiliaryKeys;

let aux: AuxiliaryKeys = "abc-defg".parse().unwrap();
assert_eq!(
    aux.iter().collect::<Vec<_>>(),
    vec![subtag!("abc"), subtag!("defg")]
);

Trait Implementations

impl Clone for AuxiliaryKeys

fn clone(&self) -> AuxiliaryKeys

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AuxiliaryKeys

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

Formats the value using the given formatter.

impl Display for AuxiliaryKeys

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

Formats the value using the given formatter.

impl From<Subtag> for AuxiliaryKeys

fn from(subtag: Subtag) -> Self

Converts to this type from the input type.

impl FromStr for AuxiliaryKeys

type Err = DataError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl Hash for AuxiliaryKeys

fn hash<__H: Hasher>(&self, state: &mut __H)

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 PartialEq for AuxiliaryKeys

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

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

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

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

impl Writeable for AuxiliaryKeys

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

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_string(&self) -> Cow<'_, str>

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

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.

impl Eq for AuxiliaryKeys

impl StructuralEq for AuxiliaryKeys

impl StructuralPartialEq for AuxiliaryKeys