Struct frame_support::inherent::CheckInherentsResult

pub struct CheckInherentsResult { /* private fields */ }

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>, 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

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

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

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

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

fn default() -> CheckInherentsResult

Returns the “default value” for a type.

impl Encode for CheckInherentsResult

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) -> Rwhere 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

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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TypeInfo for CheckInherentsResult

type Identity = CheckInherentsResult

The type identifying for which type info is provided.

fn type_info() -> Type<MetaForm>

Returns the static type identifier for Self.

impl EncodeLike<CheckInherentsResult> for CheckInherentsResult