Struct icu_locid::extensions::transform::Transform

pub struct Transform {
    pub lang: Option<LanguageIdentifier>,
    pub fields: Fields,
}

A list of Unicode BCP47 T Extensions as defined in Unicode Locale Identifier specification.

Transform extension carries information about source language or script of transformed content, including content that has been transliterated, transcribed, or translated, or in some other way influenced by the source (See RFC 6497 for details).

Examples

use icu::locid::extensions::transform::{Key, Value};
use icu::locid::{LanguageIdentifier, Locale};

let mut loc: Locale =
    "de-t-en-us-h0-hybrid".parse().expect("Parsing failed.");

let en_us: LanguageIdentifier = "en-US".parse().expect("Parsing failed.");

assert_eq!(loc.extensions.transform.lang, Some(en_us));
let key: Key = "h0".parse().expect("Parsing key failed.");
let value: Value = "hybrid".parse().expect("Parsing value failed.");
assert_eq!(loc.extensions.transform.fields.get(&key), Some(&value));

Fields

lang: Option<LanguageIdentifier>

The LanguageIdentifier specified with this locale extension, or None if not present.

fields: Fields

The key-value pairs present in this locale extension, with each extension key subtag associated to its provided value subtag.

Implementations

impl Transform

pub const fn new() -> Self

Returns a new empty map of Transform extensions. Same as default(), but is const.

Examples

use icu::locid::extensions::transform::Transform;

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

pub fn is_empty(&self) -> bool

Returns true if there are no tfields and no tlang in the TransformExtensionList.

Examples

use icu::locid::Locale;

let mut loc: Locale = "en-US-t-es-ar".parse().expect("Parsing failed.");

assert!(!loc.extensions.transform.is_empty());

pub fn clear(&mut self)

Clears the transform extension, effectively removing it from the locale.

Examples

use icu::locid::Locale;

let mut loc: Locale = "en-US-t-es-ar".parse().unwrap();
loc.extensions.transform.clear();
assert_eq!(loc, "en-US".parse().unwrap());

pub fn total_cmp(&self, other: &Self) -> Ordering

Returns an ordering suitable for use in BTreeSet.

The ordering may or may not be equivalent to string ordering, and it may or may not be stable across ICU4X releases.

Trait Implementations

impl Clone for Transform

fn clone(&self) -> Transform

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transform

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

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Transform

Returns the “default value” for a type.

impl Display for Transform

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 Hash for Transform

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 Transform

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

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 Transform

impl StructuralPartialEq for Transform