Struct ExecutionResponse 

pub struct ExecutionResponse<R> {
    pub inner: R,
    pub retries: usize,
    pub address: Address,
}

Request execution response.

Fields

inner: R

The response from the request

retries: usize

How many times the request was retried

address: Address

The address of the node that was used for the request

Trait Implementations

impl<R: Clone> Clone for ExecutionResponse<R>

fn clone(&self) -> ExecutionResponse<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for ExecutionResponse<R>

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

Formats the value using the given formatter.

impl<R: Default> Default for ExecutionResponse<R>

Available on crate feature mocks only.

fn default() -> Self

Returns the “default value” for a type.

impl<R, E> From<ExecutionResponse<R>> for ExecutionResult<R, E>

fn from(response: ExecutionResponse<R>) -> Self

Converts to this type from the input type.

impl<R> FromInner<R> for ExecutionResponse<R>

where Self: Default,

fn from_inner(inner: R) -> Self

Create full wrapping object from inner type, using defaults for fields that cannot be derived from the inner type.

impl<F, T> InnerInto<ExecutionResponse<T>> for ExecutionResponse<F>

where F: Into<T>,

fn inner_into(self) -> ExecutionResponse<T>

Convert inner response type without losing retries and address

impl<R, I> IntoInner<I> for ExecutionResponse<R>

where R: Into<I>,

fn into_inner(self) -> I

Unwrap the response

impl<R: Mockable> Mockable for ExecutionResponse<R>

fn mock_serialize(&self) -> Option<Vec<u8>>

Serialize the message to bytes for mocking purposes.

fn mock_deserialize(data: &[u8]) -> Option<Self>

Deserialize the message serialized with [mock_serialize()].

impl<R: PartialEq> PartialEq for ExecutionResponse<R>

fn eq(&self, other: &ExecutionResponse<R>) -> 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, RE, TR, IR, IRE> WrapToExecutionResult<R, RE, ExecutionResponse<TR>> for Result<IR, IRE>

where R: From<IR>, RE: From<IRE>,

fn wrap_to_execution_result( self, result: &ExecutionResponse<TR>, ) -> ExecutionResult<R, RE>

Convert self (eg. some Result) to ExecutionResult, taking context information from W (eg. ExecutionResponse).

impl<R: Eq> Eq for ExecutionResponse<R>

impl<R> StructuralPartialEq for ExecutionResponse<R>