Struct PrefixSetMut 

pub struct PrefixSetMut { /* private fields */ }

A container for efficiently storing and checking for the presence of key prefixes.

This data structure stores a set of Nibbles and provides methods to insert new elements and check whether any existing element has a given prefix.

Internally, this implementation stores keys in an unsorted Vec<Nibbles> together with an all flag. The all flag indicates that every entry should be considered changed and that individual keys can be ignored.

Sorting and deduplication do not happen during insertion or membership checks on this mutable structure. Instead, keys are sorted and deduplicated when converting into the immutable PrefixSet via freeze(). The immutable PrefixSet provides contains and relies on the sorted and unique keys produced by freeze(); it does not perform additional sorting or deduplication.

This guarantees that a PrefixSet constructed from a PrefixSetMut is always sorted and deduplicated.

Examples

use reth_trie_common::{prefix_set::PrefixSetMut, Nibbles};

let mut prefix_set_mut = PrefixSetMut::default();
prefix_set_mut.insert(Nibbles::from_nibbles_unchecked(&[0xa, 0xb]));
prefix_set_mut.insert(Nibbles::from_nibbles_unchecked(&[0xa, 0xb, 0xc]));
let mut prefix_set = prefix_set_mut.freeze();
assert!(prefix_set.contains(&Nibbles::from_nibbles_unchecked([0xa, 0xb])));
assert!(prefix_set.contains(&Nibbles::from_nibbles_unchecked([0xa, 0xb, 0xc])));

Implementations

impl PrefixSetMut

pub fn with_capacity(capacity: usize) -> PrefixSetMut

Create PrefixSetMut with pre-allocated capacity.

pub const fn all() -> PrefixSetMut

Create PrefixSetMut that considers all key changed.

pub fn insert(&mut self, nibbles: Nibbles)

Inserts the given nibbles into the set.

pub fn extend(&mut self, other: PrefixSetMut)

Extend prefix set with contents of another prefix set.

pub fn extend_ref(&mut self, other: &PrefixSetMut)

Extend prefix set with contents of another prefix set by reference.

pub fn append(&mut self, other: &mut PrefixSetMut)

Appends prefix set keys from another mutable prefix set, leaving it empty.

pub fn extend_keys<I>(&mut self, keys: I)

where I: IntoIterator<Item = Nibbles>,

Extend prefix set keys with contents of provided iterator.

pub fn iter(&self) -> Iter<'_, Nibbles>

Returns an iterator over all currently retained keys.

pub const fn len(&self) -> usize

Returns the number of elements in the set.

pub const fn is_empty(&self) -> bool

Returns true if the set is empty and all flag is not set.

pub fn clear(&mut self)

Clears the inner vec for reuse, setting all to false.

pub fn freeze(self) -> PrefixSet

Returns a PrefixSet with the same elements as this set.

If not yet sorted, the elements will be sorted and deduplicated.

Trait Implementations

impl Clone for PrefixSetMut

fn clone(&self) -> PrefixSetMut

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PrefixSetMut

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

Formats the value using the given formatter.

impl Default for PrefixSetMut

fn default() -> PrefixSetMut

Returns the “default value” for a type.

impl Eq for PrefixSetMut

impl<I> From<I> for PrefixSetMut

where I: IntoIterator<Item = Nibbles>,

fn from(value: I) -> PrefixSetMut

Converts to this type from the input type.

impl<'a> IntoIterator for &'a PrefixSetMut

type Item = &'a Nibbles

The type of the elements being iterated over.

type IntoIter = Iter<'a, Nibbles>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a PrefixSetMut as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for PrefixSetMut

fn eq(&self, other: &PrefixSetMut) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PrefixSetMut

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes