Struct DataLocaleFamily 

pub struct DataLocaleFamily { /* private fields */ }

A family of locales to export.

Implementations

impl DataLocaleFamily

pub const FULL: Self

The family containing all locales.

Stylized on the CLI as: “full”

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”

impl DataLocaleFamily

pub fn to_string(&self) -> String

Converts the given value to a String.

Under the hood, this uses an efficient Writeable implementation.

If you don’t need an allocated String, but e.g. need to write this to some sink, 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 duplicate 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 Eq for DataLocaleFamily

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DataLocaleFamily

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 writeable_borrow(&self) -> Option<&str>

Returns a &str that matches the output of write_to, if possible.

fn write_to_string(&self) -> Cow<'_, str>

Creates a new string with the data from this Writeable.