Struct linera_views::views::set_view::CustomSetView

pub struct CustomSetView<C, I> { /* private fields */ }

A View implementing the set functionality with the index I being a type with a custom serialization format.

Implementations

impl<C, I> CustomSetView<C, I>

where C: Context, ViewError: From<C::Error>, I: CustomSerialize,

pub fn insert<Q>(&mut self, index: &Q) -> Result<(), ViewError>

where I: Borrow<Q>, Q: CustomSerialize,

Inserts a value. If present then it has no effect.

let mut set = CustomSetView::<_, u128>::load(context).await.unwrap();
set.insert(&(34 as u128));
assert_eq!(set.indices().await.unwrap().len(), 1);

pub fn remove<Q>(&mut self, index: &Q) -> Result<(), ViewError>

where I: Borrow<Q>, Q: CustomSerialize,

Removes a value. If absent then nothing is done.

let mut set = CustomSetView::<_, u128>::load(context).await.unwrap();
set.remove(&(34 as u128));
assert_eq!(set.indices().await.unwrap().len(), 0);

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

Obtains the extra data.

impl<C, I> CustomSetView<C, I>

where C: Context, ViewError: From<C::Error>, I: CustomSerialize,

pub async fn contains<Q>(&self, index: &Q) -> Result<bool, ViewError>

where I: Borrow<Q>, Q: CustomSerialize,

Returns true if the given index exists in the set.

let mut set = CustomSetView::<_, u128>::load(context).await.unwrap();
set.insert(&(34 as u128));
assert_eq!(set.contains(&(34 as u128)).await.unwrap(), true);
assert_eq!(set.contains(&(37 as u128)).await.unwrap(), false);

impl<C, I> CustomSetView<C, I>

where C: Context, ViewError: From<C::Error>, I: Sync + Clone + Send + CustomSerialize,

pub async fn indices(&self) -> Result<Vec<I>, ViewError>

Returns the list of indices in the set. The order is determined by the custom serialization.

let mut set = CustomSetView::<_, u128>::load(context).await.unwrap();
set.insert(&(34 as u128));
set.insert(&(37 as u128));
assert_eq!(set.indices().await.unwrap(), vec![34 as u128, 37 as u128]);

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

Returns the number of entries of the set.

let mut set = CustomSetView::<_, u128>::load(context).await.unwrap();
set.insert(&(34 as u128));
set.insert(&(37 as u128));
assert_eq!(set.count().await.unwrap(), 2);

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

where F: FnMut(I) -> Result<bool, ViewError> + Send,

Applies a function f on each index. Indices are visited in an order determined by the custom serialization. If the function does return false, then the loop prematurely ends.

let mut set = CustomSetView::<_, u128>::load(context).await.unwrap();
set.insert(&(34 as u128));
set.insert(&(37 as u128));
set.insert(&(42 as u128));
let mut count = 0;
set.for_each_index_while(|_key| {
    count += 1;
    Ok(count < 5)
})
.await
.unwrap();
assert_eq!(count, 3);

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

where F: FnMut(I) -> Result<(), ViewError> + Send,

Applies a function f on each index. Indices are visited in an order determined by the custom serialization.

let mut set = CustomSetView::<_, u128>::load(context).await.unwrap();
set.insert(&(34 as u128));
set.insert(&(37 as u128));
set.insert(&(42 as u128));
let mut count = 0;
set.for_each_index(|_key| {
    count += 1;
    Ok(())
})
.await
.unwrap();
assert_eq!(count, 3);

Trait Implementations

impl<C, I> ClonableView<C> for CustomSetView<C, I>

where C: Context + Send + Sync, ViewError: From<C::Error>, I: Send + Sync + CustomSerialize,

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, I: Debug> Debug for CustomSetView<C, I>

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

Formats the value using the given formatter.

impl<C, I> HashableView<C> for CustomSetView<C, I>

where C: Context + Send + Sync, ViewError: From<C::Error>, I: Clone + Send + Sync + CustomSerialize,

type Hasher = CoreWrapper<Sha3_256Core>

How to compute hashes.

fn hash_mut<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<<Self::Hasher as Hasher>::Output, ViewError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Computes the hash of the values.

fn hash<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<<Self::Hasher as Hasher>::Output, ViewError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Computes the hash of the values.

impl<C, I> OutputType for CustomSetView<C, I>

where C: Send + Sync + Context, I: CustomSerialize + Clone + Send + Sync + OutputType,

fn type_name() -> Cow<'static, str>

Type the name.

fn qualified_type_name() -> String

Qualified typename.

fn create_type_info(registry: &mut Registry) -> String

Create type information in the registry and return qualified typename.

async fn resolve( &self, ctx: &ContextSelectionSet<'_>, field: &Positioned<Field>, ) -> ServerResult<Value>

Resolve an output value to async_graphql::Value.

fn introspection_type_name(&self) -> Cow<'static, str>

Introspection type name

impl<C, I> View<C> for CustomSetView<C, I>

where C: Context + Send + Sync, ViewError: From<C::Error>, I: Send + Sync + CustomSerialize,

const NUM_INIT_KEYS: usize = 0usize

The number of keys used for the initialization

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 load<'async_trait>( context: C, ) -> Pin<Box<dyn Future<Output = Result<Self, ViewError>> + Send + 'async_trait>>

where Self: 'async_trait,

Loads a view

fn rollback(&mut self)

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

fn has_pending_changes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

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 new(context: C) -> Result<Self, ViewError>

Builds a trivial view that is already deleted