Struct ByteSetView

pub struct ByteSetView<C> { /* private fields */ }

A View that supports inserting and removing values indexed by a key.

Implementations

impl<C: Context> ByteSetView<C>

pub fn insert(&mut self, short_key: Vec<u8>)

Insert a value. If already present then it has no effect.

let mut set = ByteSetView::load(context).await.unwrap();
set.insert(vec![0, 1]);
assert_eq!(set.contains(&[0, 1]).await.unwrap(), true);

pub fn remove(&mut self, short_key: Vec<u8>)

Removes a value from the set. If absent then no effect.

let mut set = ByteSetView::load(context).await.unwrap();
set.remove(vec![0, 1]);
assert_eq!(set.contains(&[0, 1]).await.unwrap(), false);

pub fn extra(&self) -> &C::Extra

Gets the extra data.

impl<C: Context> ByteSetView<C>

pub async fn contains(&self, short_key: &[u8]) -> Result<bool, ViewError>

Returns true if the given index exists in the set.

let mut set = ByteSetView::load(context).await.unwrap();
set.insert(vec![0, 1]);
assert_eq!(set.contains(&[34]).await.unwrap(), false);
assert_eq!(set.contains(&[0, 1]).await.unwrap(), true);

impl<C: Context> ByteSetView<C>

pub async fn keys(&self) -> Result<Vec<Vec<u8>>, ViewError>

Returns the list of keys in the set. The order is lexicographic.

let mut set = ByteSetView::load(context).await.unwrap();
set.insert(vec![0, 1]);
set.insert(vec![0, 2]);
assert_eq!(set.keys().await.unwrap(), vec![vec![0, 1], vec![0, 2]]);

pub async fn count(&self) -> Result<usize, ViewError>

Returns the number of entries in the set.

let mut set = ByteSetView::load(context).await.unwrap();
set.insert(vec![0, 1]);
set.insert(vec![0, 2]);
assert_eq!(set.keys().await.unwrap(), vec![vec![0, 1], vec![0, 2]]);

pub async fn for_each_key_while<F>(&self, f: F) -> Result<(), ViewError>

where F: FnMut(&[u8]) -> Result<bool, ViewError> + Send,

Applies a function f on each index (aka key). Keys are visited in a lexicographic order. If the function returns false, then the loop ends prematurely.

let mut set = ByteSetView::load(context).await.unwrap();
set.insert(vec![0, 1]);
set.insert(vec![0, 2]);
set.insert(vec![3]);
let mut count = 0;
set.for_each_key_while(|_key| {
    count += 1;
    Ok(count < 2)
})
.await
.unwrap();
assert_eq!(count, 2);

pub async fn for_each_key<F>(&self, f: F) -> Result<(), ViewError>

where F: FnMut(&[u8]) -> Result<(), ViewError> + Send,

Applies a function f on each serialized index (aka key). Keys are visited in a lexicographic order.

let mut set = ByteSetView::load(context).await.unwrap();
set.insert(vec![0, 1]);
set.insert(vec![0, 2]);
set.insert(vec![3]);
let mut count = 0;
set.for_each_key(|_key| {
    count += 1;
    Ok(())
})
.await
.unwrap();
assert_eq!(count, 3);

Trait Implementations

impl<C: Context> ClonableView for ByteSetView<C>

fn clone_unchecked(&mut self) -> Result<Self, ViewError>

Creates a clone of this view, sharing the underlying storage context but prone to data races which can corrupt the view state.

impl<C: Debug> Debug for ByteSetView<C>

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

Formats the value using the given formatter.

impl<C: Context> HashableView for ByteSetView<C>

type Hasher = CoreWrapper<Sha3_256Core>

How to compute hashes.

async fn hash_mut( &mut self, ) -> Result<<Self::Hasher as Hasher>::Output, ViewError>

Same as hash but guaranteed to be wait-free.

async fn hash(&self) -> Result<<Self::Hasher as Hasher>::Output, ViewError>

Computes the hash of the values.

impl<C: Context, C2: Context> ReplaceContext<C2> for ByteSetView<C>

type Target = ByteSetView<C2>

The type returned after replacing the context.

async fn with_context( &mut self, ctx: impl FnOnce(&Self::Context) -> C2 + Clone, ) -> Self::Target

Returns a view with a replaced context.

impl<C: Context> View for ByteSetView<C>

const NUM_INIT_KEYS: usize = 0usize

The number of keys used for the initialization

type Context = C

The type of context stored in this view

fn context(&self) -> &C

Obtains a mutable reference to the internal context.

fn pre_load(_context: &C) -> Result<Vec<Vec<u8>>, ViewError>

Creates the keys needed for loading the view

fn post_load(context: C, _values: &[Option<Vec<u8>>]) -> Result<Self, ViewError>

Loads a view from the values

fn rollback(&mut self)

Discards all pending changes. After that flush should have no effect to storage.

async fn has_pending_changes(&self) -> bool

Returns true if flushing this view would result in changes to the persistent storage.

fn flush(&mut self, batch: &mut Batch) -> Result<bool, ViewError>

Persists changes to storage. This leaves the view still usable and is essentially neutral to the program running. Crash-resistant storage implementations are expected to accumulate the desired changes in the batch variable first. If the view is dropped without calling flush, staged changes are simply lost. The returned boolean indicates whether the operation removes the view or not.

fn clear(&mut self)

Clears the view. That can be seen as resetting to default. If the clear is followed by a flush then all the relevant data is removed on the storage.

fn load( context: Self::Context, ) -> impl Future<Output = Result<Self, ViewError>> + Send + Sync

Loads a view

fn new(context: Self::Context) -> Result<Self, ViewError>

Builds a trivial view that is already deleted