Struct icu_provider_export::DataLocaleFamily

pub struct DataLocaleFamily { /* private fields */ }

A family of locales to export.

Implementations

impl DataLocaleFamily

pub fn with_descendants(locale: DataLocale) -> Self

The family containing all ancestors and descendants of the selected locale.

This is the recommended family type since it reflects regional preferences.

For example, the family ::with_descendants("en-001") contains:

• Self: “en-001”
• Ancestors: “und”, “en”
• Descendants: “en-GB”, “en-ZA”, …

Stylized on the CLI as: “en-US”

The und locale is treated specially and behaves like ::single("und").

pub fn without_descendants(locale: DataLocale) -> Self

The family containing all ancestors of the selected locale.

This family type does not include regional variants unless the selected locale is itself a regional variant.

For example, the family ::without_descendants("en-001") contains:

• Self: “en-001”
• Ancestors: “und”, “en”

Stylized on the CLI as: “^en-US”

The und locale is treated specially and behaves like ::single("und").

pub fn without_ancestors(locale: DataLocale) -> Self

The family containing all descendants of the selected locale.

This family may be useful if the root locale is not desired.

For example, the family ::without_ancestors("en-001") contains:

• Self: “en-001”
• Descendants: “en-GB”, “en-ZA”, …

but it does not contain the ancestors “en” and “und”.

Stylized on the CLI as: “%en-US”

The und locale is treated specially and behaves like ::single("und").

pub const fn single(locale: DataLocale) -> Self

The family containing only the selected locale.

For example, the family ::single("en-001") contains only “en-001”.

Stylized on the CLI as: “@en-US”

pub const FULL: Self = _

The family containing all locales.

Stylized on the CLI as: “full”

impl DataLocaleFamily

pub fn to_string(&self) -> String

Converts the given value to a String.

Under the hood, this uses an efficient [Writeable] implementation. However, in order to avoid allocating a string, it is more efficient to use [Writeable] directly.

impl DataLocaleFamily

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

Parses a DataLocaleFamily from a UTF-8 slice.

pub fn try_from_str(s: &str) -> Result<Self, DataLocaleFamilyParseError>

Parses a DataLocaleFamily.

Trait Implementations

impl Clone for DataLocaleFamily

fn clone(&self) -> DataLocaleFamily

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DataLocaleFamily

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

Formats the value using the given formatter.

impl Display for DataLocaleFamily

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 FromStr for DataLocaleFamily

type Err = DataLocaleFamilyParseError

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 DataLocaleFamily

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 DataLocaleFamily

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

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.

impl Eq for DataLocaleFamily

impl StructuralPartialEq for DataLocaleFamily