Struct icu::experimental::transliterate::provider::VarTable

pub struct VarTable<'a> {
    pub compounds: VarZeroVec<'a, str, Index32>,
    pub quantifiers_opt: VarZeroVec<'a, str, Index32>,
    pub quantifiers_kleene: VarZeroVec<'a, str, Index32>,
    pub quantifiers_kleene_plus: VarZeroVec<'a, str, Index32>,
    pub segments: VarZeroVec<'a, SegmentULE, Index32>,
    pub unicode_sets: VarZeroVec<'a, CodePointInversionListAndStringListULE, Index32>,
    pub function_calls: VarZeroVec<'a, FunctionCallULE, Index32>,
    pub max_left_placeholder_count: u16,
    pub max_right_placeholder_count: u16,
}

The special matchers and replacers used by this transliterator.

Fields

compounds: VarZeroVec<'a, str, Index32>

Variable definitions.

quantifiers_opt: VarZeroVec<'a, str, Index32>

Zero or one quantifiers.

quantifiers_kleene: VarZeroVec<'a, str, Index32>

Zero or more quantifiers.

quantifiers_kleene_plus: VarZeroVec<'a, str, Index32>

One or more quantifiers.

segments: VarZeroVec<'a, SegmentULE, Index32>

Segments.

unicode_sets: VarZeroVec<'a, CodePointInversionListAndStringListULE, Index32>

UnicodeSets. These are represented as a CodePointInversionListAndStringList

function_calls: VarZeroVec<'a, FunctionCallULE, Index32>

Function calls.

max_left_placeholder_count: u16

The maximum number of left placeholders (rest @@@ |) in any rule.

max_right_placeholder_count: u16

The maximum number of right placeholders (| @@@ rest) in any rule.

Implementations

impl VarTable<'_>

pub const BASE: char = '\u{f0000}'

The lowest char used for encoding specials.

pub const MAX_DYNAMIC: char = '\u{ffff0}'

The highest char used for encoding dynamic (i.e., growing, non-reserved) specials.

pub const RESERVED_PURE_CURSOR: char = '\u{ffffb}'

The char that encodes a pure cursor, | without @.

pub const RESERVED_ANCHOR_START: char = '\u{ffffc}'

The char that encodes a start anchor, ^.

pub const RESERVED_ANCHOR_END: char = '\u{ffffd}'

The char that encodes an end anchor, $.

pub const ENCODE_RANGE: RangeInclusive<char> = _

The range used for encoded specials.

pub const NUM_DYNAMIC: usize = 65_521usize

The number of chars available for encoding dynamic (i.e., growing, non-reserved) specials.

Trait Implementations

impl<'a> Bake for VarTable<'a>

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

Returns a TokenStream that would evaluate to self.

impl<'a> BakeSize for VarTable<'a>

fn borrows_size(&self) -> usize

Returns the size

impl<'a> Clone for VarTable<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for VarTable<'a>

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

Formats the value using the given formatter.

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

where 'de: 'a,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> PartialEq for VarTable<'a>

fn eq(&self, other: &VarTable<'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 VarTable<'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<'zf, 'zf_inner> ZeroFrom<'zf, VarTable<'zf_inner>> for VarTable<'zf>

fn zero_from(this: &'zf VarTable<'zf_inner>) -> VarTable<'zf>

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

impl<'a> Eq for VarTable<'a>

impl<'a> StructuralPartialEq for VarTable<'a>