Struct icu::casemap::provider::exceptions::Exception

pub struct Exception<'a> {
    pub bits: ExceptionBits,
    pub slot_presence: SlotPresence,
    pub data: Cow<'a, str>,
}

A type representing the wire format of Exception. The data contained is equivalently represented by DecodedException.

This type is itself not used that much, most of its relevant methods live on ExceptionULE.

The bits contain supplementary data, whereas slot_presence marks te presence of various extra data in the data field.

The data field is not validated to contain all of this data, this type will have GIGO behavior when constructed with invalid data.

The format of data is documented on the field

🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways, including in SemVer minor releases. While the serde representation of data structs is guaranteed to be stable, their Rust representation might not be. Use with caution.

Fields

bits: ExceptionBits

The various bit based exception data associated with this.

Format: Just a u8 of bitflags, some flags unused. See ExceptionBits and its ULE type for more.

slot_presence: SlotPresence

Which slots are present in data.

Format: a u8 of bitflags

data: Cow<'a, str>

Format : [char slots] [optional closure length] [ closure slot ] [ full mappings data ]

For each set SlotPresence bit, except for the two stringy slots (Closure/FullMapping), this will have one entry in the string, packed together.

Note that the simple_case delta is stored as a u32 normalized to a char, where u32s which are from or beyond the surrogate range 0xD800-0xDFFF are stored as chars starting from 0xE000. The sign is stored in bits.negative_delta.

If both Closure/FullMapping are present, the next char will be the length of the closure slot, bisecting the rest of the data. If only one is present, the rest of the data represents that slot.

The closure slot simply represents one string. The full-mappings slot represents four strings, packed in a way similar to VarZeroVec, in the following format: i1 i2 i3 [ str0 ] [ str1 ] [ str2 ] [ str3 ]

where i1 i2 i3 are the indices of the relevant mappings string. The strings are stored in the order corresponding to the MappingKind enum.

Trait Implementations

impl<'a> Clone for Exception<'a>

fn clone(&self) -> Exception<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Exception<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Exception<'a>

fn default() -> Exception<'a>

Returns the “default value” for a type.

impl<'de, 'a> Deserialize<'de> for Exception<'a>

fn deserialize<__D>( __deserializer: __D, ) -> Result<Exception<'a>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> EncodeAsVarULE<ExceptionULE> for &Exception<'a>

fn encode_var_ule_as_slices<R>(&self, cb: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated produce the memory pattern of the corresponding instance of T.

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding VarULE type

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding VarULE type to the dst buffer. dst should be the size of Self::encode_var_ule_len()

impl<'a> EncodeAsVarULE<ExceptionULE> for Exception<'a>

fn encode_var_ule_as_slices<R>(&self, cb: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated produce the memory pattern of the corresponding instance of T.

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding VarULE type

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding VarULE type to the dst buffer. dst should be the size of Self::encode_var_ule_len()

impl<'a> PartialEq for Exception<'a>

fn eq(&self, other: &Exception<'a>) -> 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<'a> Serialize for Exception<'a>

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> ZeroFrom<'a, ExceptionULE> for Exception<'a>

fn zero_from(other: &'a ExceptionULE) -> Exception<'a>

Clone the other C into a struct that may retain references into C.

impl<'a> Eq for Exception<'a>

impl<'a> StructuralPartialEq for Exception<'a>