Struct exonum_merkledb::Patch

pub struct Patch { /* fields omitted */ }

A set of changes that can be atomically applied to a Database.

This set can contain changes from multiple indexes. Changes can be read from the Patch using its RawAccess implementation.

Examples

let db = TemporaryDB::new();
let fork = db.fork();
fork.get_proof_list("list").extend(vec![1_i32, 2, 3]);
let patch: Patch = fork.into_patch();
// The patch contains changes recorded in the fork.
let list = patch.get_proof_list::<_, i32>("list");
assert_eq!(list.len(), 3);
// Unlike `Fork`, `Patch`es have consistent aggregated state.
let aggregator = SystemSchema::new(&patch).state_aggregator();
assert_eq!(aggregator.get("list").unwrap(), list.object_hash());

Trait Implementations

impl<'_> AsReadonly for &'_ Patch

type Readonly = Self

Readonly version of the access.

fn as_readonly(&self) -> Self::Readonly

Performs the conversion.

impl Debug for Patch

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

Formats the value using the given formatter.

impl From<Patch> for Fork

fn from(patch: Patch) -> Self

Creates a fork based on the provided patch and snapshot.

Note: using created fork to modify data already present in patch may lead to an inconsistent database state. Hence, this method is useful only if you are sure that the fork and patch interacted with different indexes.

impl<'_> RawAccess for &'_ Patch

type Changes = ()

Type of the changes() that will be applied to the database.

fn snapshot(&self) -> &dyn Snapshot

Reference to a Snapshot. This is the base relative to which the changes are defined.

fn changes(&self, _address: &ResolvedAddress) -> Self::Changes

Returns changes related to specific address compared to the snapshot().

impl Snapshot for Patch

fn get(&self, name: &ResolvedAddress, key: &[u8]) -> Option<Vec<u8>>

Returns a value corresponding to the specified address and key as a raw vector of bytes, or None if it does not exist.

fn contains(&self, name: &ResolvedAddress, key: &[u8]) -> bool

Returns true if the snapshot contains a value for the specified address and key.

fn iter(&self, name: &ResolvedAddress, from: &[u8]) -> Iter

Returns an iterator over the entries of the snapshot in ascending order starting from the specified key. The iterator element type is (&[u8], &[u8]).