Struct icu::plurals::provider::PluralElementsPackedCow

pub struct PluralElementsPackedCow<'data, V>
where
    V: VarULE + ?Sized,
{
    pub elements: Cow<'data, PluralElementsPackedULE<V>>,
}

A sized packed PluralElements suitable for use in data structs.

This type has the following limitations:

1. It only supports str
2. It does not implement VarULE so it can’t be used in a VarZeroSlice
3. It always serializes the FourBitMetadata as 0

Use PluralElementsPackedULE directly if you need these additional features.

Fields

elements: Cow<'data, PluralElementsPackedULE<V>>

The encoded elements.

Implementations

impl<V> PluralElementsPackedCow<'_, V>

where V: VarULE + ?Sized,

pub fn get<'a>(&'a self, op: PluralOperands, rules: &PluralRules) -> &'a V

Returns the value for the given PluralOperands and PluralRules.

Trait Implementations

impl<'data, V> Bake for PluralElementsPackedCow<'data, V>

where V: VarULE + ?Sized, Cow<'data, PluralElementsPackedULE<V>>: Bake,

fn bake(&self, env: &CrateEnv) -> TokenStream

Returns a TokenStream that would evaluate to self.

impl<'data, V> BakeSize for PluralElementsPackedCow<'data, V>

where V: VarULE + ?Sized, Cow<'data, PluralElementsPackedULE<V>>: BakeSize,

fn borrows_size(&self) -> usize

Returns the size

impl<V> Clone for PluralElementsPackedCow<'_, V>

where V: VarULE + ?Sized,

fn clone(&self) -> PluralElementsPackedCow<'_, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'data, V> Debug for PluralElementsPackedCow<'data, V>

where V: Debug + VarULE + ?Sized,

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

Formats the value using the given formatter.

impl<'de, 'data, V> Deserialize<'de> for PluralElementsPackedCow<'data, V>

where 'de: 'data, V: VarULE + ?Sized, Box<PluralElementsPackedULE<V>>: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<PluralElementsPackedCow<'data, V>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, V> From<PluralElements<T>> for PluralElementsPackedCow<'static, V>

where V: VarULE + ?Sized, T: PartialEq + Debug, &'a T: for<'a> EncodeAsVarULE<V>,

fn from(value: PluralElements<T>) -> PluralElementsPackedCow<'static, V>

Converts to this type from the input type.

impl<'data, V> PartialEq for PluralElementsPackedCow<'data, V>

where V: PartialEq + VarULE + ?Sized,

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

where V: VarULE + Serialize + PartialEq + ?Sized,

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, V> Yokeable<'a> for PluralElementsPackedCow<'static, V>

where V: VarULE + 'static + ?Sized,

type Output = PluralElementsPackedCow<'a, V>

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>

fn transform( &'a self, ) -> &'a <PluralElementsPackedCow<'static, V> as Yokeable<'a>>::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>.

fn transform_owned( self, ) -> <PluralElementsPackedCow<'static, V> as Yokeable<'a>>::Output

This method must cast self between Self<'static> and Self<'a>.

unsafe fn make( this: <PluralElementsPackedCow<'static, V> as Yokeable<'a>>::Output, ) -> PluralElementsPackedCow<'static, V>

This method can be used to cast away Self<'a>’s lifetime.

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <PluralElementsPackedCow<'static, V> as Yokeable<'a>>::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>, and pass it to f.

impl<'zf, 'zf_inner, V> ZeroFrom<'zf, PluralElementsPackedCow<'zf_inner, V>> for PluralElementsPackedCow<'zf, V>

where V: VarULE + ?Sized, Cow<'zf, PluralElementsPackedULE<V>>: ZeroFrom<'zf, Cow<'zf_inner, PluralElementsPackedULE<V>>>,

fn zero_from( this: &'zf PluralElementsPackedCow<'zf_inner, V>, ) -> PluralElementsPackedCow<'zf, V>

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

impl<'data, V> StructuralPartialEq for PluralElementsPackedCow<'data, V>

where V: VarULE + ?Sized,