Struct Fields

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

A list of Key-Value pairs representing functional information about content transformations.

Here are examples of fields used in Unicode:

• s0, d0 - Transform source/destination
• t0 - Machine Translation
• h0 - Hybrid Locale Identifiers

You can find the full list in Unicode BCP 47 T Extension section of LDML.

Examples

use icu::locid::extensions::transform::{key, Fields, Value};

let value = "hybrid".parse::<Value>().expect("Failed to parse a Value.");
let fields = [(key!("h0"), value)].into_iter().collect::<Fields>();

assert_eq!(&fields.to_string(), "h0-hybrid");

Implementations

impl Fields

pub const fn new() -> Self

Returns a new empty list of key-value pairs. Same as default(), but is const.

Examples

use icu::locid::extensions::transform::Fields;

assert_eq!(Fields::new(), Fields::default());

pub fn is_empty(&self) -> bool

Returns true if there are no fields.

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.transform.fields.is_empty());
assert!(loc2.extensions.transform.fields.is_empty());

pub fn clear(&mut self) -> Self

Empties the Fields list.

Returns the old list.

Examples

use icu::locid::extensions::transform::{key, Fields, Value};

let value = "hybrid".parse::<Value>().expect("Failed to parse a Value.");
let mut fields = [(key!("h0"), value)].into_iter().collect::<Fields>();

assert_eq!(&fields.to_string(), "h0-hybrid");

fields.clear();

assert_eq!(fields, Fields::new());

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::locid::extensions::transform::{Fields, Key, Value};

let key: Key = "h0".parse().expect("Failed to parse a Key.");
let value: Value = "hybrid".parse().expect("Failed to parse a Value.");
let mut fields = [(key, value)].into_iter().collect::<Fields>();

let key: Key = "h0".parse().expect("Failed to parse a Key.");
assert!(&fields.contains_key(&key));

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::locid::extensions::transform::{key, Fields, Value};

let value = "hybrid".parse::<Value>().unwrap();
let fields = [(key!("h0"), value.clone())]
    .into_iter()
    .collect::<Fields>();

assert_eq!(fields.get(&key!("h0")), Some(&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::transform::{key, Value};
use icu::locid::Locale;

let lower = "lower".parse::<Value>().expect("valid extension subtag");
let casefold = "casefold".parse::<Value>().expect("valid extension subtag");

let mut loc: Locale = "en-t-hi-d0-casefold"
    .parse()
    .expect("valid BCP-47 identifier");
let old_value = loc.extensions.transform.fields.set(key!("d0"), lower);

assert_eq!(old_value, Some(casefold));
assert_eq!(loc, "en-t-hi-d0-lower".parse().unwrap());

pub fn retain_by_key<F>(&mut self, predicate: F)

where F: FnMut(&Key) -> bool,

Retains a subset of fields as specified by the predicate function.

Examples

use icu::locid::extensions::transform::key;
use icu::locid::Locale;

let mut loc: Locale = "und-t-h0-hybrid-d0-hex-m0-xml".parse().unwrap();

loc.extensions
    .transform
    .fields
    .retain_by_key(|&k| k == key!("h0"));
assert_eq!(loc, "und-t-h0-hybrid".parse().unwrap());

loc.extensions
    .transform
    .fields
    .retain_by_key(|&k| k == key!("d0"));
assert_eq!(loc, Locale::UND);

Trait Implementations

impl Clone for Fields

fn clone(&self) -> Fields

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Fields

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

Formats the value using the given formatter.

impl Default for Fields

fn default() -> Fields

Returns the “default value” for a type.

impl Display for Fields

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<LiteMap<Key, Value>> for Fields

fn from(map: LiteMap<Key, Value>) -> Self

Converts to this type from the input type.

impl FromIterator<(Key, Value)> for Fields

fn from_iter<I: IntoIterator<Item = (Key, Value)>>(iter: I) -> Self

Creates a value from an iterator.

impl Hash for Fields

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 Ord for Fields

fn cmp(&self, other: &Fields) -> 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 Fields

fn eq(&self, other: &Fields) -> 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 Fields

fn partial_cmp(&self, other: &Fields) -> 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 Fields

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_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.

fn writeable_cmp_bytes(&self, other: &[u8]) -> Ordering

Compares the contents of this Writeable to the given bytes without allocating a String to hold the Writeable contents.

impl Eq for Fields

impl StructuralPartialEq for Fields