Struct TrieDiff 

pub struct TrieDiff<T = ()> { /* private fields */ }

Implementations

impl<T> TrieDiff<T>

pub fn empty() -> Self

Builds a new empty diff.

pub fn clear(&mut self)

Removes all the entries within this diff.

pub fn diff_insert( &mut self, key: impl Into<Vec<u8>>, value: impl Into<Vec<u8>>, user_data: T, ) -> Option<(Option<Vec<u8>>, T)>

Inserts the given key-value combination in the diff.

Returns the value associated to this key that was previously in the diff, if any.

pub fn diff_insert_erase( &mut self, key: impl Into<Vec<u8>>, user_data: T, ) -> Option<(Option<Vec<u8>>, T)>

Inserts in the diff an entry at the given key that delete the value that is located in the base storage.

Returns the value associated to this key that was previously in the diff, if any.

pub fn diff_remove( &mut self, key: impl AsRef<[u8]>, ) -> Option<(Option<Vec<u8>>, T)>

Removes from the diff the entry corresponding to the given key.

Returns the value associated to this key that was previously in the diff, if any.

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

Returns the diff entry at the given key.

Returns None if the diff doesn’t have any entry for this key, and Some((None, _)) if the diff has an entry that deletes the storage item.

pub fn diff_iter_unordered( &self, ) -> impl ExactSizeIterator<Item = (&[u8], Option<&[u8]>, &T)> + Clone

Returns an iterator to all the entries in the diff.

Each value is either Some if the diff overwrites this diff, or None if it erases the underlying value.

pub fn diff_into_iter_unordered( self, ) -> impl ExactSizeIterator<Item = (Vec<u8>, Option<Vec<u8>>, T)>

Returns an iterator to all the entries in the diff.

Each value is either Some if the diff overwrites this diff, or None if it erases the underlying value.

pub fn diff_range_ordered<U>( &self, range: impl RangeBounds<U>, ) -> impl Iterator<Item = (&[u8], bool)> + Clone

where U: Ord + ?Sized, Vec<u8>: Borrow<U>,

Returns an iterator to all the entries in the diff within a given range.

Each iterator element is the given and a boolean. This boolean is true if the diff overwrites this entry, or false if it erases the underlying value.

pub fn storage_next_key<'a>( &'a self, key: &[u8], in_parent_next_key: Option<&'a [u8]>, or_equal: bool, ) -> StorageNextKey<'a>

Returns the storage key that immediately follows the provided key. Must be passed the storage key that immediately follows the provided key according to the base storage this diff is based upon.

If StorageNextKey::Found is returned, it contains the desired key. If StorageNextKey::NextOf is returned, then this function should be called again but by passing the key found in the StorageNextKey::NextOf (and of course the corresponding in_parent_next_key).

Panic

Panics if in_parent_next_key is provided and is inferior or equal to key.

pub fn merge(&mut self, other: &TrieDiff<T>)

where T: Clone,

Applies the given diff on top of the current one.

pub fn merge_map<U>(&mut self, other: &TrieDiff<U>, map: impl FnMut(&U) -> T)

Applies the given diff on top of the current one.

Each user data in the other diff is first passed through the map.

Trait Implementations

impl<T: Clone> Clone for TrieDiff<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for TrieDiff<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for TrieDiff<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> FromIterator<(Vec<u8>, Option<Vec<u8>>, T)> for TrieDiff<T>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = (Vec<u8>, Option<Vec<u8>>, T)>,

Creates a value from an iterator.

impl<T, U> PartialEq<TrieDiff<U>> for TrieDiff<T>

where T: PartialEq<U>,

fn eq(&self, other: &TrieDiff<U>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for TrieDiff<T>

where T: Eq,