Type Alias ResultAndState 

pub type ResultAndState<H = HaltReason> = ExecResultAndState<ExecutionResult<H>>;

Type alias for backwards compatibility.

Aliased Type

pub struct ResultAndState<H = HaltReason> {
    pub result: ExecutionResult<H>,
    pub state: HashMap<Address, Account, RandomState>,
}

Fields

result: ExecutionResult<H>

Execution result

state: HashMap<Address, Account, RandomState>

Output State.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.

Implementations

impl<R, S> ExecResultAndState<R, S>

pub fn new(result: R, state: S) -> ExecResultAndState<R, S>

Creates new ResultAndState.

Trait Implementations

impl<R, S> Clone for ExecResultAndState<R, S>

where R: Clone, S: Clone,

fn clone(&self) -> ExecResultAndState<R, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R, S> Debug for ExecResultAndState<R, S>

where R: Debug, S: Debug,

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

Formats the value using the given formatter.

impl<'de, R, S> Deserialize<'de> for ExecResultAndState<R, S>

where R: Deserialize<'de>, S: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<ExecResultAndState<R, S>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R, S> Hash for ExecResultAndState<R, S>

where R: Hash, S: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<R, S> PartialEq for ExecResultAndState<R, S>

where R: PartialEq, S: PartialEq,

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

where R: Serialize, S: 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<R, S> Eq for ExecResultAndState<R, S>

where R: Eq, S: Eq,

impl<R, S> StructuralPartialEq for ExecResultAndState<R, S>