Struct linera_views::views::reentrant_collection_view::ReentrantCustomCollectionView

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

A view that supports accessing a collection of views of the same kind, indexed by an ordered key, possibly several subviews at a time.

Implementations

impl<C, I, W> ReentrantCustomCollectionView<C, I, W>

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

pub async fn try_load_entry_mut<Q>( &mut self, index: &Q, ) -> Result<WriteGuardedView<W>, ViewError>

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

Loads a subview for the data at the given index in the collection. If an entry is absent then a default entry is put in the collection on this index.

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
let subview = view.try_load_entry_mut(&23).await.unwrap();
let value = subview.get();
assert_eq!(*value, String::default());

pub async fn try_load_entry<Q>( &self, index: &Q, ) -> Result<Option<ReadGuardedView<W>>, ViewError>

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

Loads a subview at the given index in the collection and gives read-only access to the data. If an entry is absent then None is returned.

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
{
    let _subview = view.try_load_entry_mut(&23).await.unwrap();
}
let subview = view.try_load_entry(&23).await.unwrap().unwrap();
let value = subview.get();
assert_eq!(*value, String::default());

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

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

Returns true if the collection contains a value for the specified key.

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
let _subview = view.try_load_entry_mut(&23).await.unwrap();
assert!(view.contains_key(&23).await.unwrap());
assert!(!view.contains_key(&24).await.unwrap());

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

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

Removes an entry. If absent then nothing happens.

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
let mut subview = view.try_load_entry_mut(&23).await.unwrap();
let value = subview.get_mut();
assert_eq!(*value, String::default());
view.remove_entry(&23);
let keys = view.indices().await.unwrap();
assert_eq!(keys.len(), 0);

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

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

Marks the entry so that it is removed in the next flush.

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
{
    let mut subview = view.try_load_entry_mut(&23).await.unwrap();
    let value = subview.get_mut();
    *value = String::from("Hello");
}
{
    view.try_reset_entry_to_default(&23).unwrap();
    let subview = view.try_load_entry(&23).await.unwrap().unwrap();
    let value = subview.get();
    assert_eq!(*value, String::default());
}

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

Gets the extra data.

impl<C, I, W> ReentrantCustomCollectionView<C, I, W>

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

pub async fn try_load_entries_mut<Q>( &mut self, indices: impl IntoIterator<Item = Q>, ) -> Result<Vec<WriteGuardedView<W>>, ViewError>

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

Load multiple entries for writing at once. The entries in indices have to be all distinct.

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
let indices = vec![23, 42];
let subviews = view.try_load_entries_mut(indices).await.unwrap();
let value1 = subviews[0].get();
let value2 = subviews[1].get();
assert_eq!(*value1, String::default());
assert_eq!(*value2, String::default());

pub async fn try_load_entries<Q>( &self, indices: impl IntoIterator<Item = Q>, ) -> Result<Vec<Option<ReadGuardedView<W>>>, ViewError>

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

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

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
{
    let _subview = view.try_load_entry_mut(&23).await.unwrap();
}
let indices = vec![23, 42];
let subviews = view.try_load_entries(indices).await.unwrap();
assert!(subviews[1].is_none());
let value0 = subviews[0].as_ref().unwrap().get();
assert_eq!(*value0, String::default());

pub async fn try_load_all_entries_mut<Q>( &mut self, ) -> Result<Vec<(I, WriteGuardedView<W>)>, ViewError>

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

Loads all entries for writing at once. The entries in indices have to be all distinct.

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
{
    let _subview = view.try_load_entry_mut(&23).await.unwrap();
}
let subviews = view.try_load_all_entries_mut().await.unwrap();
assert_eq!(subviews.len(), 1);

pub async fn try_load_all_entries<Q>( &self, ) -> Result<Vec<(I, ReadGuardedView<W>)>, ViewError>

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

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

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
{
    let _subview = view.try_load_entry_mut(&23).await.unwrap();
}
let subviews = view.try_load_all_entries().await.unwrap();
assert_eq!(subviews.len(), 1);

impl<C, I, W> ReentrantCustomCollectionView<C, I, W>

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

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

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

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
view.try_load_entry_mut(&23).await.unwrap();
view.try_load_entry_mut(&25).await.unwrap();
let indices = view.indices().await.unwrap();
assert_eq!(indices, vec![23, 25]);

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

Returns the number of entries in the collection.

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
view.try_load_entry_mut(&23).await.unwrap();
view.try_load_entry_mut(&25).await.unwrap();
assert_eq!(view.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 f returns false then the loop ends prematurely.

let mut view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
view.try_load_entry_mut(&28).await.unwrap();
view.try_load_entry_mut(&24).await.unwrap();
view.try_load_entry_mut(&23).await.unwrap();
let mut part_indices = Vec::new();
view.for_each_index_while(|index| {
    part_indices.push(index);
    Ok(part_indices.len() < 2)
})
.await
.unwrap();
assert_eq!(part_indices, vec![23, 24]);

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 view: ReentrantCustomCollectionView<_, u128, RegisterView<_, String>> =
    ReentrantCustomCollectionView::load(context).await.unwrap();
view.try_load_entry_mut(&28).await.unwrap();
view.try_load_entry_mut(&24).await.unwrap();
view.try_load_entry_mut(&23).await.unwrap();
let mut indices = Vec::new();
view.for_each_index(|index| {
    indices.push(index);
    Ok(())
})
.await
.unwrap();
assert_eq!(indices, vec![23, 24, 28]);

Trait Implementations

impl<C, I, W> ClonableView<C> for ReentrantCustomCollectionView<C, I, W>

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

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, K, V> ContainerType for ReentrantCustomCollectionView<C, K, V>

where C: Send + Sync + Context, K: InputType + OutputType + CustomSerialize + Debug + Clone, V: View<C> + OutputType, MapInput<K>: InputType, MapFilters<K>: InputType,

async fn resolve_field(&self, ctx: &Context<'_>) -> ServerResult<Option<Value>>

Resolves a field value and outputs it as a json value async_graphql::Value.

async fn find_entity( &self, ctx: &Context<'_>, params: &Value, ) -> ServerResult<Option<Value>>

Find the GraphQL entity with the given name from the parameter.

fn collect_all_fields<'a>( &'a self, ctx: &ContextBase<'a, &'a Positioned<SelectionSet>>, fields: &mut Fields<'a>, ) -> Result<(), ServerError>

where Self: Send + Sync,

Collect all the fields of the container that are queried in the selection set.

impl<C: Debug, I: Debug, W: Debug> Debug for ReentrantCustomCollectionView<C, I, W>

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

Formats the value using the given formatter.

impl<C, I, W> HashableView<C> for ReentrantCustomCollectionView<C, I, W>

where C: Context + Send + Sync, ViewError: From<C::Error>, I: Send + Sync + CustomSerialize, W: HashableView<C> + Send + Sync + 'static,

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, K, V> OutputType for ReentrantCustomCollectionView<C, K, V>

where C: Send + Sync + Context, K: InputType + OutputType + CustomSerialize + Debug + Clone, V: View<C> + OutputType, MapInput<K>: InputType, MapFilters<K>: InputType,

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

Type the name.

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 qualified_type_name() -> String

Qualified typename.

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

Introspection type name

impl<C: Send + Sync, K: OutputType, V: OutputType> TypeName for ReentrantCustomCollectionView<C, K, V>

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

Returns a GraphQL type name.

impl<C, I, W> View<C> for ReentrantCustomCollectionView<C, I, W>

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

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

impl<C, K, V> ObjectType for ReentrantCustomCollectionView<C, K, V>

where C: Send + Sync + Context, K: InputType + OutputType + CustomSerialize + Debug + Clone, V: View<C> + OutputType, MapInput<K>: InputType, MapFilters<K>: InputType,