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> Allocative for ByteSetView<C>

fn visit<'allocative_a, 'allocative_b: 'allocative_a>( &self, visitor: &'allocative_a mut Visitor<'allocative_b>, )

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 pre_save(&self, batch: &mut Batch) -> Result<bool, ViewError>

Computes the batch of operations to persist changes to storage without modifying the view. Crash-resistant storage implementations accumulate the desired changes in the batch variable. The returned boolean indicates whether the operation removes the view or not.

fn post_save(&mut self)

Updates the view state after the batch has been executed in the database. This should be called after pre_save and after the batch has been successfully written to storage. This leaves the view in a clean state with no pending changes.

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