Struct icu::locid::extensions::Extensions

#[non_exhaustive]
pub struct Extensions {
    pub unicode: Unicode,
    pub transform: Transform,
    pub private: Private,
    pub other: Vec<Other>,
}

A map of extensions associated with a given Locale.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

unicode: Unicode

A representation of the data for a Unicode extension, when present in the locale identifier.

transform: Transform

A representation of the data for a transform extension, when present in the locale identifier.

private: Private

A representation of the data for a private-use extension, when present in the locale identifier.

other: Vec<Other>

A sequence of any other extensions that are present in the locale identifier but are not formally defined and represented explicitly as Unicode, Transform, and Private are.

Implementations

impl Extensions

pub const fn new() -> Extensions

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

Examples

use icu::locid::extensions::Extensions;

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

pub const fn from_unicode(unicode: Unicode) -> Extensions

Function to create a new map of extensions containing exactly one unicode extension, callable in const context.

pub fn is_empty(&self) -> bool

Returns whether there are no extensions present.

Examples

use icu::locid::Locale;

let loc: Locale = "en-US-u-foo".parse().expect("Parsing failed.");

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

pub fn retain_by_type<F>(&mut self, predicate: F)where F: FnMut(ExtensionType) -> bool,

Retains the specified extension types, clearing all others.

Examples

use icu::locid::extensions::ExtensionType;
use icu::locid::Locale;

let loc: Locale =
    "und-a-hello-t-mul-u-world-z-zzz-x-extra".parse().unwrap();

let mut only_unicode = loc.clone();
only_unicode
    .extensions
    .retain_by_type(|t| t == ExtensionType::Unicode);
assert_eq!(only_unicode, "und-u-world".parse().unwrap());

let mut only_t_z = loc.clone();
only_t_z.extensions.retain_by_type(|t| {
    t == ExtensionType::Transform || t == ExtensionType::Other(b'z')
});
assert_eq!(only_t_z, "und-t-mul-z-zzz".parse().unwrap());

Trait Implementations

impl Clone for Extensions

fn clone(&self) -> Extensions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Extensions

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

Formats the value using the given formatter.

impl Default for Extensions

fn default() -> Extensions

Returns the “default value” for a type.

impl Display for Extensions

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

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 Extensions

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

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 Extensions

impl StructuralEq for Extensions

impl StructuralPartialEq for Extensions