Struct sp_state_machine::OverlayedChanges

pub struct OverlayedChanges { /* private fields */ }

The set of changes that are overlaid onto the backend.

It allows changes to be modified using nestable transactions.

Implementations

impl OverlayedChanges

pub fn is_empty(&self) -> bool

Whether no changes are contained in the top nor in any of the child changes.

pub fn set_collect_extrinsics(&mut self, collect_extrinsics: bool)

Ask to collect/not to collect extrinsics indices where key(s) has been changed.

pub fn storage(&self, key: &[u8]) -> Option<Option<&[u8]>>

Returns a double-Option: None if the key is unknown (i.e. and the query should be referred to the backend); Some(None) if the key has been deleted. Some(Some(…)) for a key whose value has been set.

pub fn value_mut_or_insert_with(
    &mut self,
    key: &[u8],
    init: impl Fn() -> StorageValue
) -> &mut StorageValue

Returns mutable reference to current value. If there is no value in the overlay, the given callback is used to initiate the value. Warning this function registers a change, so the mutable reference MUST be modified.

Can be rolled back or committed when called inside a transaction.

pub fn child_storage(
    &self,
    child_info: &ChildInfo,
    key: &[u8]
) -> Option<Option<&[u8]>>

Returns a double-Option: None if the key is unknown (i.e. and the query should be referred to the backend); Some(None) if the key has been deleted. Some(Some(…)) for a key whose value has been set.

pub fn set_storage(&mut self, key: StorageKey, val: Option<StorageValue>)

Set a new value for the specified key.

Can be rolled back or committed when called inside a transaction.

pub fn transaction_depth(&self) -> usize

Returns the current nesting depth of the transaction stack.

A value of zero means that no transaction is open and changes are committed on write.

pub fn start_transaction(&mut self)

Start a new nested transaction.

This allows to either commit or roll back all changes that where made while this transaction was open. Any transaction must be closed by either rollback_transaction or commit_transaction before this overlay can be converted into storage changes.

Changes made without any open transaction are committed immediately.

pub fn rollback_transaction(&mut self) -> Result<(), NoOpenTransaction>

Rollback the last transaction started by start_transaction.

Any changes made during that transaction are discarded. Returns an error if there is no open transaction that can be rolled back.

pub fn commit_transaction(&mut self) -> Result<(), NoOpenTransaction>

Commit the last transaction started by start_transaction.

Any changes made during that transaction are committed. Returns an error if there is no open transaction that can be committed.

pub fn enter_runtime(&mut self) -> Result<(), AlreadyInRuntime>

Call this before transfering control to the runtime.

This protects all existing transactions from being removed by the runtime. Calling this while already inside the runtime will return an error.

pub fn exit_runtime(&mut self) -> Result<(), NotInRuntime>

Call this when control returns from the runtime.

This commits all dangling transaction left open by the runtime. Calling this while outside the runtime will return an error.

pub fn offchain_drain_committed(
    &mut self
) -> impl Iterator<Item = ((StorageKey, StorageKey), OffchainOverlayedChange)>

Consume all changes (top + children) and return them.

After calling this function no more changes are contained in this changeset.

Panics: Panics if transaction_depth() > 0

pub fn children(
    &self
) -> impl Iterator<Item = (impl Iterator<Item = (&StorageKey, &OverlayedEntry<Option<StorageValue>>)>, &ChildInfo)>

Get an iterator over all child changes as seen by the current transaction.

pub fn changes(
    &self
) -> impl Iterator<Item = (&StorageKey, &OverlayedEntry<Option<StorageValue>>)>

Get an iterator over all top changes as been by the current transaction.

pub fn child_changes(
    &self,
    key: &[u8]
) -> Option<(impl Iterator<Item = (&StorageKey, &OverlayedEntry<Option<StorageValue>>)>, &ChildInfo)>

Get an optional iterator over all child changes stored under the supplied key.

pub fn transaction_index_ops(&self) -> &[IndexOperation]

Get an list of all index operations.

pub fn into_storage_changes<B: Backend<H>, H: Hasher>(
    self,
    backend: &B,
    parent_hash: H::Out,
    cache: StorageTransactionCache<B::Transaction, H>
) -> Result<StorageChanges<B::Transaction, H>, DefaultError> where
    H::Out: Ord + Encode + 'static, 

Convert this instance with all changes into a StorageChanges instance.

pub fn drain_storage_changes<B: Backend<H>, H: Hasher>(
    &mut self,
    backend: &B,
    _parent_hash: H::Out,
    cache: &mut StorageTransactionCache<B::Transaction, H>
) -> Result<StorageChanges<B::Transaction, H>, DefaultError> where
    H::Out: Ord + Encode + 'static, 

Drain all changes into a StorageChanges instance. Leave empty overlay in place.

pub fn storage_root<H: Hasher, B: Backend<H>>(
    &self,
    backend: &B,
    cache: &mut StorageTransactionCache<B::Transaction, H>
) -> H::Out where
    H::Out: Ord + Encode, 

Generate the storage root using backend and all changes as seen by the current transaction.

Returns the storage root and caches storage transaction in the given cache.

pub fn iter_after(
    &self,
    key: &[u8]
) -> impl Iterator<Item = (&[u8], &OverlayedEntry<Option<StorageValue>>)>

Returns an iterator over the keys (in lexicographic order) following key (excluding key) alongside its value.

pub fn child_iter_after(
    &self,
    storage_key: &[u8],
    key: &[u8]
) -> impl Iterator<Item = (&[u8], &OverlayedEntry<Option<StorageValue>>)>

Returns an iterator over the keys (in lexicographic order) following key (excluding key) alongside its value for the given storage_key child.

pub fn offchain(&self) -> &OffchainOverlayedChanges

Read only access ot offchain overlay.

pub fn set_offchain_storage(&mut self, key: &[u8], value: Option<&[u8]>)

Write a key value pair to the offchain storage overlay.

pub fn add_transaction_index(&mut self, op: IndexOperation)

Add transaction index operation.

Trait Implementations

impl Clone for OverlayedChanges

fn clone(&self) -> OverlayedChanges

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OverlayedChanges

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for OverlayedChanges

fn default() -> OverlayedChanges

Returns the “default value” for a type.