Enum TransformKindV2

pub enum TransformKindV2 {
    Identity,
    Write(StoredValue),
    AddInt32(i32),
    AddUInt64(u64),
    AddUInt128(U128),
    AddUInt256(U256),
    AddUInt512(U512),
    AddKeys(NamedKeys),
    Prune(Key),
    Failure(TransformError),
}

Representation of a single transformation occurring during execution.

Note that all arithmetic variants of TransformKindV2 are commutative which means that a given collection of them can be executed in any order to produce the same end result.

Variants

Identity

An identity transformation that does not modify a value in the global state.

Created as a result of reading from the global state.

Write(StoredValue)

Writes a new value in the global state.

AddInt32(i32)

A wrapping addition of an i32 to an existing numeric value (not necessarily an i32) in the global state.

AddUInt64(u64)

A wrapping addition of a u64 to an existing numeric value (not necessarily an u64) in the global state.

AddUInt128(U128)

A wrapping addition of a U128 to an existing numeric value (not necessarily an U128) in the global state.

AddUInt256(U256)

A wrapping addition of a U256 to an existing numeric value (not necessarily an U256) in the global state.

AddUInt512(U512)

A wrapping addition of a U512 to an existing numeric value (not necessarily an U512) in the global state.

AddKeys(NamedKeys)

Adds new named keys to an existing entry in the global state.

This transform assumes that the existing stored value is either an Account or a Contract.

Prune(Key)

Removes the pathing to the global state entry of the specified key. The pruned element remains reachable from previously generated global state root hashes, but will not be included in the next generated global state root hash and subsequent state accumulated from it.

Failure(TransformError)

Represents the case where applying a transform would cause an error.

Implementations

impl TransformKindV2

pub fn apply( self, stored_value: StoredValue, ) -> Result<TransformInstruction, TransformError>

Applies the transformation on a specified stored value instance.

This method produces a new StoredValue instance based on the TransformKind variant.

pub fn random<R: Rng + ?Sized>(rng: &mut R) -> Self

Available on crate feature testing only.

Returns a random TransformKind.

Trait Implementations

impl Clone for TransformKindV2

fn clone(&self) -> TransformKindV2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DataSize for TransformKindV2

where StoredValue: DataSize, i32: DataSize, u64: DataSize, U128: DataSize, U256: DataSize, U512: DataSize, NamedKeys: DataSize, Key: DataSize, TransformError: DataSize,

const IS_DYNAMIC: bool = true

If true, the type has a heap size that can vary at runtime, depending on the actual value.

const STATIC_HEAP_SIZE: usize = 0usize

The amount of space a value of the type always occupies. If IS_DYNAMIC is false, this is the total amount of heap memory occupied by the value. Otherwise this is a lower bound.

fn estimate_heap_size(&self) -> usize

Estimates the size of heap memory taken up by this value.

impl Debug for TransformKindV2

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

Formats the value using the given formatter.

impl Default for TransformKindV2

fn default() -> TransformKindV2

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TransformKindV2

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromBytes for TransformKindV2

fn from_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error>

Deserializes the slice into Self.

fn from_vec(bytes: Vec<u8>) -> Result<(Self, Vec<u8>), Error>

Deserializes the Vec<u8> into Self.

impl JsonSchema for TransformKindV2

fn schema_name() -> String

The name of the generated JSON Schema.

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

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for TransformKindV2

fn eq(&self, other: &TransformKindV2) -> 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 Serialize for TransformKindV2

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToBytes for TransformKindV2

fn to_bytes(&self) -> Result<Vec<u8>, Error>

Serializes &self to a Vec<u8>.

fn serialized_length(&self) -> usize

Returns the length of the Vec<u8> which would be returned from a successful call to to_bytes() or into_bytes(). The data is not actually serialized, so this call is relatively cheap.

fn write_bytes(&self, writer: &mut Vec<u8>) -> Result<(), Error>

Writes &self into a mutable writer.

fn into_bytes(self) -> Result<Vec<u8>, Error>

where Self: Sized,

Consumes self and serializes to a Vec<u8>.

impl Eq for TransformKindV2

impl StructuralPartialEq for TransformKindV2