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<'_>