Struct ByteCollectionView

pub struct ByteCollectionView<C, W> { /* private fields */ }

A view that supports accessing a collection of views of the same kind, indexed by a Vec<u8>, one subview at a time.

Implementations

impl<W: View> ByteCollectionView<W::Context, W>

pub async fn load_entry_mut( &mut self, short_key: &[u8], ) -> Result<&mut W, ViewError>

Loads a subview for the data at the given index in the collection. If an entry is absent then a default entry is added to the collection. The resulting view can be modified.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
let subview = view.load_entry_mut(&[0, 1]).await.unwrap();
let value = subview.get();
assert_eq!(*value, String::default());

pub async fn try_load_entry( &self, short_key: &[u8], ) -> Result<Option<ReadGuardedView<'_, W>>, ViewError>

Loads a subview for the data at the given index in the collection. If an entry is absent then None is returned. The resulting view cannot be modified. May fail if one subview is already being visited.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
{
    let _subview = view.load_entry_mut(&[0, 1]).await.unwrap();
}
{
    let subview = view.try_load_entry(&[0, 1]).await.unwrap().unwrap();
    let value = subview.get();
    assert_eq!(*value, String::default());
}
assert!(view.try_load_entry(&[0, 2]).await.unwrap().is_none());

pub async fn try_load_entries( &self, short_keys: Vec<Vec<u8>>, ) -> Result<Vec<Option<ReadGuardedView<'_, W>>>, ViewError>

Load multiple entries for reading at once. The entries in short_keys have to be all distinct.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
{
    let _subview = view.load_entry_mut(&[0, 1]).await.unwrap();
}
let short_keys = vec![vec![0, 1], vec![2, 3]];
let subviews = view.try_load_entries(short_keys).await.unwrap();
let value0 = subviews[0].as_ref().unwrap().get();
assert_eq!(*value0, String::default());

pub async fn try_load_entries_pairs( &self, short_keys: Vec<Vec<u8>>, ) -> Result<Vec<(Vec<u8>, Option<ReadGuardedView<'_, W>>)>, ViewError>

Loads multiple entries for reading at once with their keys.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
{
    let subview = view.load_entry_mut(&vec![0, 1]).await.unwrap();
    subview.set("Bonjour".into());
}
let short_keys = vec![vec![0, 1], vec![0, 2]];
let pairs = view.try_load_entries_pairs(short_keys).await.unwrap();
assert_eq!(pairs[0].0, vec![0, 1]);
assert_eq!(pairs[1].0, vec![0, 2]);
let value0 = pairs[0].1.as_ref().unwrap().get();
assert_eq!(*value0, "Bonjour".to_string());
assert!(pairs[1].1.is_none());

pub async fn try_load_all_entries( &self, ) -> Result<Vec<(Vec<u8>, ReadGuardedView<'_, W>)>, ViewError>

Load all entries for reading at once.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
{
    let _subview = view.load_entry_mut(&[0, 1]).await.unwrap();
}
let subviews = view.try_load_all_entries().await.unwrap();
assert_eq!(subviews.len(), 1);

pub fn reset_entry_to_default( &mut self, short_key: &[u8], ) -> Result<(), ViewError>

Resets an entry to the default value.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
let subview = view.load_entry_mut(&[0, 1]).await.unwrap();
let value = subview.get_mut();
*value = String::from("Hello");
view.reset_entry_to_default(&[0, 1]).unwrap();
let subview = view.load_entry_mut(&[0, 1]).await.unwrap();
let value = subview.get_mut();
assert_eq!(*value, String::default());

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

Tests if the collection contains a specified key and returns a boolean.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
{
    let _subview = view.load_entry_mut(&[0, 1]).await.unwrap();
}
assert!(view.contains_key(&[0, 1]).await.unwrap());
assert!(!view.contains_key(&[0, 2]).await.unwrap());

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

Marks the entry as removed. If absent then nothing is done.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
let subview = view.load_entry_mut(&[0, 1]).await.unwrap();
let value = subview.get_mut();
assert_eq!(*value, String::default());
view.remove_entry(vec![0, 1]);
let keys = view.keys().await.unwrap();
assert_eq!(keys.len(), 0);

pub fn extra(&self) -> &<W::Context as Context>::Extra

Gets the extra data.

impl<W: View> ByteCollectionView<W::Context, W>

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 the lexicographic order. If the function returns false, then the loop ends prematurely.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
view.load_entry_mut(&[0, 1]).await.unwrap();
view.load_entry_mut(&[0, 2]).await.unwrap();
let mut count = 0;
view.for_each_key_while(|_key| {
    count += 1;
    Ok(count < 1)
})
.await
.unwrap();
assert_eq!(count, 1);

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 index (aka key). Keys are visited in a lexicographic order.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
view.load_entry_mut(&[0, 1]).await.unwrap();
view.load_entry_mut(&[0, 2]).await.unwrap();
let mut count = 0;
view.for_each_key(|_key| {
    count += 1;
    Ok(())
})
.await
.unwrap();
assert_eq!(count, 2);

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

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

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
view.load_entry_mut(&[0, 1]).await.unwrap();
view.load_entry_mut(&[0, 2]).await.unwrap();
let keys = view.keys().await.unwrap();
assert_eq!(keys, vec![vec![0, 1], vec![0, 2]]);

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

Returns the number of entries in the collection.

let mut view: ByteCollectionView<_, RegisterView<_, String>> =
    ByteCollectionView::load(context).await.unwrap();
view.load_entry_mut(&[0, 1]).await.unwrap();
view.load_entry_mut(&[0, 2]).await.unwrap();
assert_eq!(view.count().await.unwrap(), 2);

Trait Implementations

impl<C, W: Allocative> Allocative for ByteCollectionView<C, W>

fn visit<'a, 'b: 'a>(&self, visitor: &'a mut Visitor<'b>)

impl<W: ClonableView> ClonableView for ByteCollectionView<W::Context, W>

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, W: Debug> Debug for ByteCollectionView<C, W>

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

Formats the value using the given formatter.

impl<W: HashableView> HashableView for ByteCollectionView<W::Context, W>

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<W: View> View for ByteCollectionView<W::Context, W>

const NUM_INIT_KEYS: usize = 0usize

The number of keys used for the initialization

type Context = <W as View>::Context

The type of context stored in this view

fn context(&self) -> Self::Context

Obtains a mutable reference to the internal context.

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

Creates the keys needed for loading the view

fn post_load( context: Self::Context, _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