Enum Op 

#[non_exhaustive]
pub enum Op<M, D = InMemoryDB>
where
    M: ResultMode<D>,
    D: DB,
{
    Noop {
        n: u32,
    },
    Lt,
    Eq,
    Type,
    Size,
    New,
    And,
    Or,
    Neg,
    Log,
    Root,
    Pop,
    Popeq {
        cached: bool,
        result: <M as ResultMode<D>>::ReadResult,
    },
    Addi {
        immediate: u32,
    },
    Subi {
        immediate: u32,
    },
    Push {
        storage: bool,
        value: StateValue<D>,
    },
    Branch {
        skip: u32,
    },
    Jmp {
        skip: u32,
    },
    Add,
    Sub,
    Concat {
        cached: bool,
        n: u32,
    },
    Member,
    Rem {
        cached: bool,
    },
    Dup {
        n: u8,
    },
    Swap {
        n: u8,
    },
    Idx {
        cached: bool,
        push_path: bool,
        path: Array<Key, D>,
    },
    Ins {
        cached: bool,
        n: u8,
    },
    Ckpt,
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Noop

Fields

n: u32

Lt

Eq

Type

Size

New

And

Or

Neg

Log

Root

Pop

Popeq

Fields

cached: bool

result: <M as ResultMode<D>>::ReadResult

Addi

Fields

immediate: u32

Subi

Fields

immediate: u32

Push

Fields

storage: bool

value: StateValue<D>

Branch

Fields

skip: u32

Jmp

Fields

skip: u32

Add

Sub

Concat

Fields

cached: bool

n: u32

Member

Rem

Fields

cached: bool

Dup

Fields

n: u8

Swap

Fields

n: u8

Idx

Fields

cached: bool

push_path: bool

path: Array<Key, D>

Ins

Fields

cached: bool

n: u8

Ckpt

Implementations

impl<M, D> Op<M, D>

where M: ResultMode<D>, D: DB,

pub fn translate<M2, F>(self, f: F) -> Op<M2, D>

where M2: ResultMode<D>, F: FnOnce(<M as ResultMode<D>>::ReadResult) -> <M2 as ResultMode<D>>::ReadResult,

Trait Implementations

impl<M, D> Clone for Op<M, D>

where M: ResultMode<D> + Clone, D: DB,

fn clone(&self) -> Op<M, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M, D> Debug for Op<M, D>

where M: ResultMode<D>, D: DB,

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

Formats the value using the given formatter.

impl<M, D> Deserializable for Op<M, D>

where M: ResultMode<D>, D: DB,

fn deserialize( __reader: &mut impl Read, recursion_depth: u32, ) -> Result<Op<M, D>, Error>

const LIMIT_RECURSION: bool = true

fn check_rec(depth: &mut u32) -> Result<(), Error>

impl<'de, M, D> Deserialize<'de> for Op<M, D>

where M: ResultMode<D>, D: DB, <M as ResultMode<D>>::ReadResult: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Op<M, D>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<D> FieldRepr for Op<ResultModeVerify, D>

where D: DB,

fn field_repr<W>(&self, writer: &mut W)

where W: MemWrite<Fr>,

Writes out self as a sequence of Fr elements. As a general rule of thumb, this should usually produces a known number of elements.

fn field_size(&self) -> usize

The size of a value when represented as field elements.

fn field_vec(&self) -> Vec<Fr>

Writes the hash repr into a vector

impl<M, D> PartialEq for Op<M, D>

where M: ResultMode<D> + PartialEq, D: DB,

fn eq(&self, __other: &Op<M, D>) -> 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<M, D> Serializable for Op<M, D>

where M: ResultMode<D>, D: DB,

fn serialize(&self, __writer: &mut impl Write) -> Result<(), Error>

fn serialized_size(&self) -> usize

impl<M, D> Serialize for Op<M, D>

where M: ResultMode<D>, D: DB, <M as ResultMode<D>>::ReadResult: Serialize,

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<M, D> Storable<D> for Op<M, D>

where M: ResultMode<D>, D: DB,

fn children(&self) -> Vec<ArenaKey<<D as DB>::Hasher>>

Provides an iterator over hashes of child Sps, if any. These hashes will be passed back into from_binary_repr when deserializing.

fn to_binary_repr<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write,

Serializes self, omitting any children.

fn from_binary_repr<R>( reader: &mut R, child_hashes: &mut impl Iterator<Item = ArenaKey<<D as DB>::Hasher>>, loader: &impl Loader<D>, ) -> Result<Op<M, D>, Error>

where R: Read,

Instantiates self, given hashes of any children, and loader that loads children given their hash.

fn check_invariant(&self) -> Result<(), Error>

An invariant to check on deserialization. Should be invoked from within from_binary_repr.

fn as_child(&self) -> ArenaKey<<D as DB>::Hasher>

Represents self as a ArenaKey

impl<M, D> Tagged for Op<M, D>

where M: ResultMode<D>, D: DB,

fn tag() -> Cow<'static, str>

Retrieves the tag of Self. Returns a [Cow] as type arguments require allocation, but no allocation is preferred.

fn tag_unique_factor() -> String

A decomposition of this tag into primitive types (any type whose representation is not defined through other types), tuples (via (a,b)), and sum types (via [a,b]).

impl<M, D> Eq for Op<M, D>

where M: ResultMode<D> + Eq, D: DB,