Enum DynToken

pub enum DynToken<'a> {
    Word(Word),
    FixedSeq(Cow<'a, [DynToken<'a>]>, usize),
    DynSeq {
        contents: Cow<'a, [DynToken<'a>]>,
        /* private fields */
    },
    PackedSeq(&'a [u8]),
}

A dynamic token.

Equivalent to an enum over all types implementing Token.

Variants

Word(Word)

A single word.

FixedSeq(Cow<'a, [DynToken<'a>]>, usize)

A Fixed Sequence.

DynSeq

A dynamic-length sequence.

Fields

contents: Cow<'a, [DynToken<'a>]>

The contents of the dynamic sequence.

PackedSeq(&'a [u8])

A packed sequence (string or bytes).

Implementations

impl<'a> DynToken<'a>

pub fn minimum_words(&self) -> usize

Calculate the minimum number of words required to encode this token.

pub fn from_fixed_seq(seq: &'a [DynSolValue]) -> Self

Instantiate a DynToken from a fixed sequence of values.

pub fn from_dyn_seq(seq: &'a [DynSolValue]) -> Self

Instantiate a DynToken from a dynamic sequence of values.

pub const fn as_word(&self) -> Option<Word>

Attempt to cast to a word.

pub fn as_fixed_seq(&self) -> Option<(&[Self], usize)>

Fallible cast into a fixed sequence.

pub fn as_dynamic_seq(&self) -> Option<&[Self]>

Fallible cast into a dynamic sequence.

pub fn as_token_seq(&self) -> Option<&[Self]>

Fallible cast into a sequence, dynamic or fixed-size

pub const fn as_packed_seq(&self) -> Option<&[u8]>

Fallible cast into a packed sequence.

pub fn is_dynamic(&self) -> bool

True if the type is dynamic, else false.

Trait Implementations

impl<'a> Clone for DynToken<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for DynToken<'a>

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

Formats the value using the given formatter.

impl<T: Into<Word>> From<T> for DynToken<'_>

fn from(value: T) -> Self

Converts to this type from the input type.

impl PartialEq<DynToken<'_>> for DynToken<'_>

fn eq(&self, other: &DynToken<'_>) -> 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 Eq for DynToken<'_>

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: 36 bytes

Size for each variant:

• Word: 32 bytes
• FixedSeq: 19 bytes
• DynSeq: 19 bytes
• PackedSeq: 11 bytes