Struct frame_support::inherent::CheckInherentsResult

pub struct CheckInherentsResult { /* fields omitted */ }

The result of checking inherents.

It either returns okay for all checks, stores all occurred errors or just one fatal error.

When a fatal error occurs, all other errors are removed and the implementation needs to abort checking inherents.

Implementations

impl CheckInherentsResult

pub fn new() -> CheckInherentsResult

Create a new instance.

pub fn put_error<E>(
    &mut self,
    identifier: [u8; 8],
    error: &E
) -> Result<(), Error> where
    E: Encode + IsFatalError, 

Put an error into the result.

This makes this result resolve to ok() == false.

Parameters

• identifier - The identifier of the inherent that generated the error.
• error - The error that will be encoded.

pub fn get_error<E>(&self, identifier: &[u8; 8]) -> Result<Option<E>, Error> where
    E: Decode, 

Get an error out of the result.

Return

• Ok(Some(I)) if the error could be found and deserialized.
• Ok(None) if the error could not be found.
• Err(_) if the error could be found, but deserialization did not work.

pub fn into_errors(self) -> IntoIter<[u8; 8], Vec<u8, Global>>

Convert into an iterator over all contained errors.

pub fn ok(&self) -> bool

Is this result ok?

pub fn fatal_error(&self) -> bool

Is this a fatal error?

Trait Implementations

impl Clone for CheckInherentsResult

pub fn clone(&self) -> CheckInherentsResult

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Decode for CheckInherentsResult

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CheckInherentsResult, Error> where
    __CodecInputEdqy: Input, 

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error> where
    I: Input, 

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Default for CheckInherentsResult

pub fn default() -> CheckInherentsResult

Returns the “default value” for a type.

impl Encode for CheckInherentsResult

pub fn encode_to<__CodecOutputEdqy>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
) where
    __CodecOutputEdqy: Output + ?Sized, 

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R where
    F: FnOnce(&[u8]) -> R, 

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl PartialEq<CheckInherentsResult> for CheckInherentsResult

pub fn eq(&self, other: &CheckInherentsResult) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl EncodeLike<CheckInherentsResult> for CheckInherentsResult