Struct sp_consensus::InherentData

pub struct InherentData { /* fields omitted */ }

Inherent data to include in a block.

Implementations

impl InherentData

pub fn new() -> InherentData

Create a new instance.

pub fn put_data<I>(
    &mut self,
    identifier: [u8; 8],
    inherent: &I
) -> Result<(), Error> where
    I: Encode, 

Put data for an inherent into the internal storage.

Return

Returns Ok(()) if the data could be inserted and no data for an inherent with the same identifier existed, otherwise an error is returned.

Inherent identifiers need to be unique, otherwise decoding of these values will not work!

pub fn replace_data<I>(&mut self, identifier: [u8; 8], inherent: &I) where
    I: Encode, 

Replace the data for an inherent.

If it does not exist, the data is just inserted.

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

Returns the data for the requested inherent.

Return

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

pub fn len(&self) -> usize

Get the number of inherents in this instance

Trait Implementations

impl Clone for InherentData

pub fn clone(&self) -> InherentData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Decode for InherentData

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

Attempt to deserialise the value from input.

impl Default for InherentData

pub fn default() -> InherentData

Returns the “default value” for a type.

impl Encode for InherentData

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

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

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

Convert self to an owned vector.

pub 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.

pub fn size_hint(&self) -> usize

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

impl EncodeLike<InherentData> for InherentData