Struct sp_inherents::InherentData

pub struct InherentData { /* private fields */ }

Inherent data to include in a block.

Implementations

impl InherentData

pub fn new() -> Self

Create a new instance.

Examples found in repository

src/lib.rs (line 291)

	fn default() -> Self {
		Self { okay: true, errors: InherentData::new(), fatal_error: false }
	}

src/client_side.rs (line 87)

	async fn create_inherent_data(&self) -> Result<InherentData, Error> {
		let mut inherent_data = InherentData::new();
		self.provide_inherent_data(&mut inherent_data).await?;
		Ok(inherent_data)
	}

pub fn put_data<I: Encode>(
    &mut self,
    identifier: InherentIdentifier,
    inherent: &I
) -> Result<(), Error>

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!

Examples found in repository

src/lib.rs (line 324)

	pub fn put_error<E: codec::Encode + IsFatalError>(
		&mut self,
		identifier: InherentIdentifier,
		error: &E,
	) -> Result<(), Error> {
		// Don't accept any other error
		if self.fatal_error {
			return Err(Error::FatalErrorReported)
		}

		if error.is_fatal_error() {
			// remove the other errors.
			self.errors.data.clear();
		}

		self.errors.put_data(identifier, error)?;

		self.okay = false;
		self.fatal_error = error.is_fatal_error();
		Ok(())
	}

pub fn replace_data<I: Encode>(
    &mut self,
    identifier: InherentIdentifier,
    inherent: &I
)

Replace the data for an inherent.

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

pub fn get_data<I: Decode>(
    &self,
    identifier: &InherentIdentifier
) -> Result<Option<I>, Error>

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.

Examples found in repository

src/lib.rs (line 342)

	pub fn get_error<E: codec::Decode>(
		&self,
		identifier: &InherentIdentifier,
	) -> Result<Option<E>, Error> {
		self.errors.get_data(identifier)
	}

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: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

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: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

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

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

Convert self to an owned vector.

fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> 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