Trait Backend 

pub trait Backend<H: Hasher>: Debug {
    type Error: Error;
    type Transaction: Consolidate + Default + Send;
    type TrieBackendStorage: TrieBackendStorage<H>;

    // Required methods
    fn storage(&self, key: &[u8]) -> Result<Option<StorageValue>, Self::Error>;
    fn child_storage(
        &self,
        child_info: &ChildInfo,
        key: &[u8],
    ) -> Result<Option<StorageValue>, Self::Error>;
    fn next_storage_key(
        &self,
        key: &[u8],
    ) -> Result<Option<StorageKey>, Self::Error>;
    fn next_child_storage_key(
        &self,
        child_info: &ChildInfo,
        key: &[u8],
    ) -> Result<Option<StorageKey>, Self::Error>;
    fn apply_to_child_keys_while<F: FnMut(&[u8]) -> bool>(
        &self,
        child_info: &ChildInfo,
        f: F,
    );
    fn for_key_values_with_prefix<F: FnMut(&[u8], &[u8])>(
        &self,
        prefix: &[u8],
        f: F,
    );
    fn for_child_keys_with_prefix<F: FnMut(&[u8])>(
        &self,
        child_info: &ChildInfo,
        prefix: &[u8],
        f: F,
    );
    fn storage_root<'a>(
        &self,
        delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
    ) -> (H::Out, Self::Transaction)
       where H::Out: Ord;
    fn child_storage_root<'a>(
        &self,
        child_info: &ChildInfo,
        delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
    ) -> (H::Out, bool, Self::Transaction)
       where H::Out: Ord;
    fn pairs(&self) -> Vec<(StorageKey, StorageValue)>;
    fn register_overlay_stats(&mut self, _stats: &StateMachineStats);
    fn usage_info(&self) -> UsageInfo;

    // Provided methods
    fn storage_hash(&self, key: &[u8]) -> Result<Option<H::Out>, Self::Error> { ... }
    fn child_storage_hash(
        &self,
        child_info: &ChildInfo,
        key: &[u8],
    ) -> Result<Option<H::Out>, Self::Error> { ... }
    fn exists_storage(&self, key: &[u8]) -> Result<bool, Self::Error> { ... }
    fn exists_child_storage(
        &self,
        child_info: &ChildInfo,
        key: &[u8],
    ) -> Result<bool, Self::Error> { ... }
    fn for_keys_with_prefix<F: FnMut(&[u8])>(&self, prefix: &[u8], f: F) { ... }
    fn keys(&self, prefix: &[u8]) -> Vec<StorageKey>  { ... }
    fn child_keys(
        &self,
        child_info: &ChildInfo,
        prefix: &[u8],
    ) -> Vec<StorageKey>  { ... }
    fn as_trie_backend(
        &mut self,
    ) -> Option<&TrieBackend<Self::TrieBackendStorage, H>> { ... }
    fn full_storage_root<'a>(
        &self,
        delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
        child_deltas: impl Iterator<Item = (&'a ChildInfo, impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>)>,
    ) -> (H::Out, Self::Transaction)
       where H::Out: Ord + Encode { ... }
    fn wipe(&self) -> Result<(), Self::Error> { ... }
    fn commit(
        &self,
        _: H::Out,
        _: Self::Transaction,
        _: StorageCollection,
        _: ChildStorageCollection,
    ) -> Result<(), Self::Error> { ... }
    fn read_write_count(&self) -> (u32, u32, u32, u32) { ... }
    fn reset_read_write_count(&self) { ... }
    fn get_whitelist(&self) -> Vec<TrackedStorageKey> { ... }
    fn set_whitelist(&self, _: Vec<TrackedStorageKey>) { ... }
}

A state backend is used to read state data and can have changes committed to it.

The clone operation (if implemented) should be cheap.

Required Associated Types

type Error: Error

An error type when fetching data is not possible.

type Transaction: Consolidate + Default + Send

Storage changes to be applied if committing

type TrieBackendStorage: TrieBackendStorage<H>

Type of trie backend storage.

Required Methods

fn storage(&self, key: &[u8]) -> Result<Option<StorageValue>, Self::Error>

Get keyed storage or None if there is nothing associated.

fn child_storage( &self, child_info: &ChildInfo, key: &[u8], ) -> Result<Option<StorageValue>, Self::Error>

Get keyed child storage or None if there is nothing associated.

fn next_storage_key( &self, key: &[u8], ) -> Result<Option<StorageKey>, Self::Error>

Return the next key in storage in lexicographic order or None if there is no value.

fn next_child_storage_key( &self, child_info: &ChildInfo, key: &[u8], ) -> Result<Option<StorageKey>, Self::Error>

Return the next key in child storage in lexicographic order or None if there is no value.

fn apply_to_child_keys_while<F: FnMut(&[u8]) -> bool>( &self, child_info: &ChildInfo, f: F, )

Retrieve all entries keys of child storage and call f for each of those keys. Aborts as soon as f returns false.

fn for_key_values_with_prefix<F: FnMut(&[u8], &[u8])>( &self, prefix: &[u8], f: F, )

Retrieve all entries keys and values of which start with the given prefix and call f for each of those keys.

fn for_child_keys_with_prefix<F: FnMut(&[u8])>( &self, child_info: &ChildInfo, prefix: &[u8], f: F, )

Retrieve all child entries keys which start with the given prefix and call f for each of those keys.

fn storage_root<'a>( &self, delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>, ) -> (H::Out, Self::Transaction)

where H::Out: Ord,

Calculate the storage root, with given delta over what is already stored in the backend, and produce a “transaction” that can be used to commit. Does not include child storage updates.

fn child_storage_root<'a>( &self, child_info: &ChildInfo, delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>, ) -> (H::Out, bool, Self::Transaction)

where H::Out: Ord,

Calculate the child storage root, with given delta over what is already stored in the backend, and produce a “transaction” that can be used to commit. The second argument is true if child storage root equals default storage root.

fn pairs(&self) -> Vec<(StorageKey, StorageValue)>

Get all key/value pairs into a Vec.

fn register_overlay_stats(&mut self, _stats: &StateMachineStats)

Register stats from overlay of state machine.

By default nothing is registered.

fn usage_info(&self) -> UsageInfo

Query backend usage statistics (i/o, memory)

Not all implementations are expected to be able to do this. In the case when they don’t, empty statistics is returned.

Provided Methods

fn storage_hash(&self, key: &[u8]) -> Result<Option<H::Out>, Self::Error>

Get keyed storage value hash or None if there is nothing associated.

fn child_storage_hash( &self, child_info: &ChildInfo, key: &[u8], ) -> Result<Option<H::Out>, Self::Error>

Get child keyed storage value hash or None if there is nothing associated.

fn exists_storage(&self, key: &[u8]) -> Result<bool, Self::Error>

true if a key exists in storage.

fn exists_child_storage( &self, child_info: &ChildInfo, key: &[u8], ) -> Result<bool, Self::Error>

true if a key exists in child storage.

fn for_keys_with_prefix<F: FnMut(&[u8])>(&self, prefix: &[u8], f: F)

Retrieve all entries keys which start with the given prefix and call f for each of those keys.

fn keys(&self, prefix: &[u8]) -> Vec<StorageKey>

Get all keys with given prefix

fn child_keys(&self, child_info: &ChildInfo, prefix: &[u8]) -> Vec<StorageKey>

Get all keys of child storage with given prefix

fn as_trie_backend( &mut self, ) -> Option<&TrieBackend<Self::TrieBackendStorage, H>>

Try convert into trie backend.

fn full_storage_root<'a>( &self, delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>, child_deltas: impl Iterator<Item = (&'a ChildInfo, impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>)>, ) -> (H::Out, Self::Transaction)

where H::Out: Ord + Encode,

Calculate the storage root, with given delta over what is already stored in the backend, and produce a “transaction” that can be used to commit. Does include child storage updates.

fn wipe(&self) -> Result<(), Self::Error>

Wipe the state database.

fn commit( &self, _: H::Out, _: Self::Transaction, _: StorageCollection, _: ChildStorageCollection, ) -> Result<(), Self::Error>

Commit given transaction to storage.

fn read_write_count(&self) -> (u32, u32, u32, u32)

Get the read/write count of the db

fn reset_read_write_count(&self)

Get the read/write count of the db

fn get_whitelist(&self) -> Vec<TrackedStorageKey>

Get the whitelist for tracking db reads/writes

fn set_whitelist(&self, _: Vec<TrackedStorageKey>)

Update the whitelist for tracking db reads/writes

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, T: Backend<H>, H: Hasher> Backend<H> for &'a T

type Error = <T as Backend<H>>::Error

type Transaction = <T as Backend<H>>::Transaction

type TrieBackendStorage = <T as Backend<H>>::TrieBackendStorage

fn storage(&self, key: &[u8]) -> Result<Option<StorageKey>, Self::Error>

fn child_storage( &self, child_info: &ChildInfo, key: &[u8], ) -> Result<Option<StorageKey>, Self::Error>

fn apply_to_child_keys_while<F: FnMut(&[u8]) -> bool>( &self, child_info: &ChildInfo, f: F, )

fn next_storage_key( &self, key: &[u8], ) -> Result<Option<StorageKey>, Self::Error>

fn next_child_storage_key( &self, child_info: &ChildInfo, key: &[u8], ) -> Result<Option<StorageKey>, Self::Error>

fn for_keys_with_prefix<F: FnMut(&[u8])>(&self, prefix: &[u8], f: F)

fn for_child_keys_with_prefix<F: FnMut(&[u8])>( &self, child_info: &ChildInfo, prefix: &[u8], f: F, )

fn storage_root<'b>( &self, delta: impl Iterator<Item = (&'b [u8], Option<&'b [u8]>)>, ) -> (H::Out, Self::Transaction)

where H::Out: Ord,

fn child_storage_root<'b>( &self, child_info: &ChildInfo, delta: impl Iterator<Item = (&'b [u8], Option<&'b [u8]>)>, ) -> (H::Out, bool, Self::Transaction)

where H::Out: Ord,

fn pairs(&self) -> Vec<(StorageKey, StorageValue)>

fn for_key_values_with_prefix<F: FnMut(&[u8], &[u8])>( &self, prefix: &[u8], f: F, )

fn register_overlay_stats(&mut self, _stats: &StateMachineStats)

fn usage_info(&self) -> UsageInfo

Implementors

impl<'a, S, H> Backend<H> for ProvingBackend<'a, S, H>

where S: 'a + TrieBackendStorage<H>, H: 'a + Hasher, H::Out: Ord + Codec,

type Error = String

type Transaction = <S as TrieBackendStorage<H>>::Overlay

type TrieBackendStorage = S

impl<S: TrieBackendStorage<H>, H: Hasher> Backend<H> for TrieBackend<S, H>

where H::Out: Ord + Codec,

type Error = String

type Transaction = <S as TrieBackendStorage<H>>::Overlay

type TrieBackendStorage = S