Struct exonum_merkledb::migration::Migration

pub struct Migration<T> { /* fields omitted */ }

Access to migrated indexes.

Migration is conceptually similar to a Prefixed access. For example, an index with address "list" in a migration Migration::new("foo", _) will map to the address "foo.list" after the migration is flushed. The major difference with Prefixed is that the indexes in a migration cannot be accessed in any other way. That is, it is impossible to access an index in a migration without constructing a Migration object first.

Methods

impl<T: RawAccess> Migration<T>

pub fn new(namespace: impl Into<String>, access: T) -> Self

Creates a migration in the specified namespace.

pub fn state_hash(&self) -> Hash

Returns the state hash of indexes within the migration. The state hash is up to date for Snapshots (including Patches), but is generally stale for Forks.

impl<T: RawAccess + AsReadonly> Migration<T>

pub fn state_aggregator(&self) -> ProofMapIndex<T::Readonly, str, Hash>

Returns the state aggregator for the indexes within the migration. The aggregator is up to date for Snapshots (including Patches), but is generally stale for Forks.

Note that keys in the aggregator are full addresses, which include the migration namespace, as is the case for the default aggregator.

Examples

let db = TemporaryDB::new();
let fork = db.fork();
{
    let migration = Migration::new("migration", &fork);
    migration.get_proof_entry("entry").set(42);
}
let patch = fork.into_patch();
let migration_view = Migration::new("migration", &patch);
let aggregator = migration_view.state_aggregator();
assert!(aggregator.contains("migration.entry")); // Not "entry": `state_aggregator` uses
                                                 // full index names as keys.

impl<T: RawAccessMut> Migration<T>

pub fn create_tombstone<I>(&self, addr: I) where
    I: Into<IndexAddress>, 

Marks an index with the specified address as removed during migration.

Panics

Panics if an index already exists at the specified address.

Trait Implementations

impl<T: RawAccess> Access for Migration<T>

type Base = T

Raw access serving as the basis for created indexes.

fn get_index_metadata(
    self,
    addr: IndexAddress
) -> Result<Option<IndexMetadata>, AccessError>

Gets index metadata at the specified address, or None if there is no index.

fn get_or_create_view(
    self,
    addr: IndexAddress,
    index_type: IndexType
) -> Result<ViewWithMetadata<Self::Base>, AccessError>

Gets or creates a generic view with the specified address.

fn group_keys<K: ?Sized>(
    self,
    base_addr: IndexAddress
) -> GroupKeys<Self::Base, K> where
    K: BinaryKey,
    Self::Base: AsReadonly<Readonly = Self::Base>, 

Returns an iterator over keys in a group with the specified address.

impl<T: Clone> Clone for Migration<T>

fn clone(&self) -> Migration<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Migration<T>

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

Formats the value using the given formatter.

impl<T: RawAccess> From<Migration<T>> for GenericAccess<T>

fn from(access: Migration<T>) -> Self

Performs the conversion.

impl<'a, T> IntoErased<'a> for Migration<T> where
    T: Into<GenericRawAccess<'a>>, 

fn into_erased(self) -> ErasedAccess<'a>

Performs the conversion.