Struct icu::locale::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::locale::extensions::transform::{Key, Value};
use icu::locale::{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() -> Transform

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

Examples

use icu::locale::extensions::transform::Transform;

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

pub fn try_from_str(s: &str) -> Result<Transform, ParseError>

A constructor which takes a str slice, parses it and produces a well-formed Transform.

pub fn try_from_utf8(code_units: &[u8]) -> Result<Transform, ParseError>

See Self::try_from_str

pub fn is_empty(&self) -> bool

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

Examples

use icu::locale::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::locale::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: &Transform) -> 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<(), Error>

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<(), Error>

Formats the value using the given formatter.

impl FromStr for Transform

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Transform, <Transform as FromStr>::Err>

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

impl Hash for Transform

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

where __H: Hasher,

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

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

fn write_to<W>(&self, sink: &mut W) -> Result<(), Error>

where W: Write + ?Sized,

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.

impl Eq for Transform

impl StructuralPartialEq for Transform