Struct sp_state_machine::OverlayedChanges

pub struct OverlayedChanges { /* fields omitted */ }

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.

#[must_use = "A change was registered, so this value MUST be modified."]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 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 immediatly.

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 children(
    &self
) -> impl Iterator<Item = (impl Iterator<Item = (&StorageKey, &OverlayedValue)>, &ChildInfo)>

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

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

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, &OverlayedValue)>, &ChildInfo)>

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

pub fn into_storage_changes<B: Backend<H>, H: Hasher, N: BlockNumber>(
    mut self: Self,
    backend: &B,
    changes_trie_state: Option<&ChangesTrieState<'_, H, N>>,
    parent_hash: H::Out,
    mut cache: StorageTransactionCache<B::Transaction, H, N>
) -> Result<StorageChanges<B::Transaction, H, N>, 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, N: BlockNumber>(
    &mut self,
    backend: &B,
    #[cfg(feature = "std")] changes_trie_state: Option<&ChangesTrieState<'_, H, N>>,
    parent_hash: H::Out,
    mut cache: &mut StorageTransactionCache<B::Transaction, H, N>
) -> Result<StorageChanges<B::Transaction, H, N>, 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, N: BlockNumber, B: Backend<H>>(
    &self,
    backend: &B,
    cache: &mut StorageTransactionCache<B::Transaction, H, N>
) -> 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 changes_trie_root<'a, H: Hasher, N: BlockNumber, B: Backend<H>>(
    &self,
    backend: &B,
    changes_trie_state: Option<&'a ChangesTrieState<'a, H, N>>,
    parent_hash: H::Out,
    panic_on_storage_error: bool,
    cache: &mut StorageTransactionCache<B::Transaction, H, N>
) -> Result<Option<H::Out>, ()> where
    H::Out: Ord + Encode + 'static, 

Generate the changes trie root.

Returns the changes trie root and caches the storage transaction into the given cache.

Panics

Panics on storage error, when panic_on_storage_error is set.

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

Returns the next (in lexicographic order) storage key in the overlayed alongside its value. If no value is next then None is returned.

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

Returns the next (in lexicographic order) child storage key in the overlayed alongside its value. If no value is next then None is returned.

Trait Implementations

impl Clone for OverlayedChanges

pub fn clone(&self) -> OverlayedChanges

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OverlayedChanges

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

Formats the value using the given formatter.

impl Default for OverlayedChanges

pub fn default() -> OverlayedChanges

Returns the "default value" for a type.