Struct pallet_roles::InherentData

pub struct InherentData { /* private fields */ }

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

fn clone(&self) -> InherentData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Decode for InherentData

fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<InherentData, 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 InherentData

fn default() -> InherentData

Returns the “default value” for a type.

impl Encode for InherentData

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 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 size_hint(&self) -> usize

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

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl EncodeLike<InherentData> for InherentData