Struct Key 

pub struct Key(/* private fields */);

A key used in a list of Fields.

The key has to be a two ASCII characters long, with the first character being alphabetic, and the second being a number.

Examples

use icu::locale::extensions::transform::Key;

let key1: Key = "k0".parse().expect("Failed to parse a Key.");

assert_eq!(key1.as_str(), "k0");

Implementations

impl Key

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

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

Examples

use icu_locale_core::extensions :: transform ::Key;

assert!(Key::try_from_str("k0").is_ok());
assert!(Key::try_from_str("").is_err());

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

See Self::try_from_str

pub const fn try_from_raw(raw: [u8; 2]) -> Result<Self, ParseError>

Safely creates a Key from its raw format as returned by Self::into_raw. Unlike Self::try_from_utf8, this constructor only takes normalized values.

pub const unsafe fn from_raw_unchecked(v: [u8; 2]) -> Self

Unsafely creates a Key from its raw format as returned by Self::into_raw. Unlike Self::try_from_utf8, this constructor only takes normalized values.

Safety

This function is safe iff Self::try_from_raw returns an Ok. This is the case for inputs that are correctly normalized.

pub const fn into_raw(self) -> [u8; 2]

Deconstructs into a raw format to be consumed by from_raw_unchecked or try_from_raw.

pub const fn as_str(&self) -> &str

A helper function for displaying as a &str.

pub fn strict_cmp(self, other: &[u8]) -> Ordering

Compare with BCP-47 bytes.

The return value is equivalent to what would happen if you first converted self to a BCP-47 string and then performed a byte comparison.

This function is case-sensitive and results in a total order, so it is appropriate for binary search. The only argument producing Ordering::Equal is self.as_str().as_bytes().

pub fn normalizing_eq(self, other: &str) -> bool

Compare with a potentially unnormalized BCP-47 string.

The return value is equivalent to what would happen if you first parsed the BCP-47 string and then performed a structural comparison.

impl Key

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.

Trait Implementations

impl AsULE for Key

type ULE = Key

The ULE type corresponding to Self.

fn to_unaligned(self) -> Self::ULE

Converts from Self to Self::ULE.

fn from_unaligned(unaligned: Self::ULE) -> Self

Converts from Self::ULE to Self.

impl Clone for Key

fn clone(&self) -> Key

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Key

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

Formats the value using the given formatter.

impl Display for Key

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<'l> From<&'l Key> for &'l str

fn from(input: &'l Key) -> Self

Converts to this type from the input type.

impl From<Key> for TinyAsciiStr<2>

fn from(input: Key) -> Self

Converts to this type from the input type.

impl FromStr for Key

type Err = ParseError

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 Key

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 NicheBytes<2> for Key

const NICHE_BIT_PATTERN: [u8; 2] = tinystr::TinyAsciiStr<2>::NICHE_BIT_PATTERN

impl Ord for Key

fn cmp(&self, other: &Key) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Key

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

fn partial_cmp(&self, other: &Key) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl ULE for Key

fn validate_bytes(bytes: &[u8]) -> Result<(), UleError>

Validates a byte slice, &[u8].

fn parse_bytes_to_slice(bytes: &[u8]) -> Result<&[Self], UleError>

Parses a byte slice, &[u8], and return it as &[Self] with the same lifetime.

unsafe fn slice_from_bytes_unchecked(bytes: &[u8]) -> &[Self]

Takes a byte slice, &[u8], and return it as &[Self] with the same lifetime, assuming that this byte slice has previously been run through Self::parse_bytes_to_slice() with success.

fn slice_as_bytes(slice: &[Self]) -> &[u8]

Given &[Self], returns a &[u8] with the same lifetime.

impl Writeable for Key

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<'a> ZeroMapKV<'a> for Key

type Container = ZeroVec<'a, Key>

The container that can be used with this type: ZeroVec or VarZeroVec.

type Slice = ZeroSlice<Key>

type GetType = Key

The type produced by Container::get()

type OwnedType = Key

The type produced by Container::replace() and Container::remove(), also used during deserialization. If Self is human readable serialized, deserializing to Self::OwnedType should produce the same value once passed through Self::owned_as_self()

impl Copy for Key

impl Eq for Key

impl StructuralPartialEq for Key

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 2 bytes