Struct 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: Context, I: CustomSerialize> CustomSetView<C, I>

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, 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, I: Sync + 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> Allocative for CustomSetView<C, I>

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

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

where C: Context, 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, I> ContainerType for CustomSetView<C, I>

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

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

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

Formats the value using the given formatter.

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

where Self: View,

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

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

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

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

Returns a GraphQL type name.

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

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

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

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

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