Trait sp_state_machine::backend::Backend

source · [−]
pub trait Backend<H: Hasher>: Debug {
    type Error: Error;
    type Transaction: Consolidate + Default + Send;
    type TrieBackendStorage: TrieBackendStorage<H>;

Show 27 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)>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
    A: Allocator, ;

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

    fn usage_info(&self) -> UsageInfo;

    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>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
    A: Allocator,  { ... }

    fn child_keys(
        &self, 
        child_info: &ChildInfo, 
        prefix: &[u8]
    ) -> Vec<StorageKey>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
    A: Allocator,  { ... }

    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>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
    A: Allocator,  { ... }

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

}
Expand description

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

The clone operation (if implemented) should be cheap.

Associated Types

An error type when fetching data is not possible.

Storage changes to be applied if committing

Type of trie backend storage.

Required methods

Get keyed storage or None if there is nothing associated.

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

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

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

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

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

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

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.

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.

Get all key/value pairs into a Vec.

Register stats from overlay of state machine.

By default nothing is registered.

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

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

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

true if a key exists in storage.

true if a key exists in child storage.

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

Get all keys with given prefix

Get all keys of child storage with given prefix

Try convert into trie backend.

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.

Wipe the state database.

Commit given transaction to storage.

Get the read/write count of the db

Get the read/write count of the db

Get the whitelist for tracking db reads/writes

Update the whitelist for tracking db reads/writes

Implementations on Foreign Types

Implementors