Struct CustomMapView

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

A map view that uses custom serialization

Implementations

impl<C: Context, I: CustomSerialize, V> CustomMapView<C, I, V>

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

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

Insert or resets a value.

let mut map: MapView<_, u128, _> = MapView::load(context).await.unwrap();
map.insert(&(24 as u128), String::from("Hello"));
assert_eq!(
    map.get(&(24 as u128)).await.unwrap(),
    Some(String::from("Hello"))
);

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

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

Removes a value. If absent then this does not do anything.

let mut map = MapView::<_, u128, String>::load(context).await.unwrap();
map.remove(&(37 as u128));
assert_eq!(map.get(&(37 as u128)).await.unwrap(), None);

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

Obtains the extra data.

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

where I: Borrow<Q>, Q: Serialize + ?Sized,

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

let mut map = MapView::<_, u128, String>::load(context).await.unwrap();
map.insert(&(37 as u128), String::from("Hello"));
assert!(map.contains_key(&(37 as u128)).await.unwrap());
assert!(!map.contains_key(&(34 as u128)).await.unwrap());

impl<C, I, V> CustomMapView<C, I, V>

where C: Context, I: CustomSerialize, V: Clone + DeserializeOwned + 'static,

pub async fn get<Q>(&self, index: &Q) -> Result<Option<V>, ViewError>

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

Reads the value at the given position, if any.

let mut map: CustomMapView<MemoryContext<()>, u128, String> =
    CustomMapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Hello"));
assert_eq!(
    map.get(&(34 as u128)).await.unwrap(),
    Some(String::from("Hello"))
);

pub async fn multi_get<'a, Q>( &self, indices: impl IntoIterator<Item = &'a Q>, ) -> Result<Vec<Option<V>>, ViewError>

where I: Borrow<Q>, Q: CustomSerialize + 'a,

Read values at several positions, if any.

let mut map: CustomMapView<MemoryContext<()>, u128, String> =
    CustomMapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Hello"));
map.insert(&(12 as u128), String::from("Hi"));
assert_eq!(
    map.multi_get(&[34 as u128, 12 as u128, 89 as u128])
        .await
        .unwrap(),
    [Some(String::from("Hello")), Some(String::from("Hi")), None]
);

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

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

Read index-value pairs at several positions, if any.

let mut map: CustomMapView<MemoryContext<()>, u128, String> =
    CustomMapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Hello"));
map.insert(&(12 as u128), String::from("Hi"));
assert_eq!(
    map.multi_get_pairs([34 as u128, 12 as u128, 89 as u128])
        .await
        .unwrap(),
    vec![
        (34 as u128, Some(String::from("Hello"))),
        (12 as u128, Some(String::from("Hi"))),
        (89 as u128, None)
    ]
);

pub async fn get_mut<Q>( &mut self, index: &Q, ) -> Result<Option<&mut V>, ViewError>

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

Obtains a mutable reference to a value at a given position if available

let mut map: CustomMapView<_, u128, String> = CustomMapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Hello"));
let value = map.get_mut(&(34 as u128)).await.unwrap().unwrap();
*value = String::from("Hola");
assert_eq!(
    map.get(&(34 as u128)).await.unwrap(),
    Some(String::from("Hola"))
);

impl<C, I, V> CustomMapView<C, I, V>

where C: Context, I: Send + CustomSerialize, V: Clone + Serialize + DeserializeOwned + 'static,

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

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

let mut map: MapView<_, u128, String> = MapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Hello"));
map.insert(&(37 as u128), String::from("Bonjour"));
assert_eq!(map.indices().await.unwrap(), vec![34 as u128, 37 as u128]);

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

let mut map = CustomMapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Hello"));
map.insert(&(37 as u128), String::from("Hola"));
let mut indices = Vec::<u128>::new();
map.for_each_index_while(|index| {
    indices.push(index);
    Ok(indices.len() < 5)
})
.await
.unwrap();
assert_eq!(indices.len(), 2);

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 map = CustomMapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Hello"));
map.insert(&(37 as u128), String::from("Hola"));
let mut indices = Vec::<u128>::new();
map.for_each_index(|index| {
    indices.push(index);
    Ok(())
})
.await
.unwrap();
assert_eq!(indices, vec![34, 37]);

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

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

Applies a function f on the index/value pairs. Indices and values are visited in an order determined by the custom serialization. If the function returns false, then the loop ends prematurely.

let mut map = CustomMapView::<_, u128, String>::load(context)
    .await
    .unwrap();
map.insert(&(34 as u128), String::from("Hello"));
map.insert(&(37 as u128), String::from("Hola"));
let mut values = Vec::new();
map.for_each_index_value_while(|_index, value| {
    values.push(value);
    Ok(values.len() < 5)
})
.await
.unwrap();
assert_eq!(values.len(), 2);

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

where F: FnMut(I, Cow<'a, V>) -> Result<(), ViewError> + Send,

Applies a function f on each index/value pair. Indices and values are visited in an order determined by the custom serialization.

let mut map: CustomMapView<_, u128, String> = CustomMapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Hello"));
map.insert(&(37 as u128), String::from("Hola"));
let mut indices = Vec::<u128>::new();
map.for_each_index_value(|index, _value| {
    indices.push(index);
    Ok(())
})
.await
.unwrap();
assert_eq!(indices, vec![34, 37]);

impl<C, I, V> CustomMapView<C, I, V>

where C: Context, I: Send + CustomSerialize, V: Clone + Sync + Send + Serialize + DeserializeOwned + 'static,

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

Obtains all the (index,value) pairs.

let mut map: MapView<_, String, _> = MapView::load(context).await.unwrap();
map.insert("Italian", String::from("Ciao"));
let index_values = map.index_values().await.unwrap();
assert_eq!(
    index_values,
    vec![("Italian".to_string(), "Ciao".to_string())]
);

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

Obtains the number of entries in the map

let mut map: MapView<_, String, _> = MapView::load(context).await.unwrap();
map.insert("Italian", String::from("Ciao"));
map.insert("French", String::from("Bonjour"));
assert_eq!(map.count().await.unwrap(), 2);

impl<C, I, V> CustomMapView<C, I, V>

where C: Context, I: CustomSerialize, V: Default + DeserializeOwned + 'static,

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

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

Obtains a mutable reference to a value at a given position. Default value if the index is missing.

let mut map: CustomMapView<_, u128, String> = CustomMapView::load(context).await.unwrap();
assert_eq!(
    *map.get_mut_or_default(&(34 as u128)).await.unwrap(),
    String::new()
);

Trait Implementations

impl<C, I, V: Allocative> Allocative for CustomMapView<C, I, V>

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

impl<C, I, V> ClonableView for CustomMapView<C, I, V>

where Self: View, ByteMapView<C, V>: ClonableView,

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, V> ContainerType for CustomMapView<C, I, V>

where C: Context, I: OutputType + InputType + CustomSerialize + Debug + Clone + Send + Sync + 'static, V: OutputType + Serialize + DeserializeOwned + Clone + Send + Sync + 'static,

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

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

Formats the value using the given formatter.

impl<C, I, V> HashableView for CustomMapView<C, I, V>

where C: Context, I: Send + Sync + CustomSerialize, V: Clone + Send + Sync + Serialize + DeserializeOwned + 'static,

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

where C: Context, I: OutputType + InputType + CustomSerialize + Debug + Clone + Send + Sync + 'static, V: OutputType + Serialize + DeserializeOwned + Clone + Send + Sync + 'static,

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

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

Returns a GraphQL type name.

impl<C, I, V> View for CustomMapView<C, I, V>

where C: Context, I: CustomSerialize + Send + Sync, V: Serialize + Clone + Send + Sync,

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, V> ObjectType for CustomMapView<C, I, V>

where C: Context, I: OutputType + InputType + CustomSerialize + Debug + Clone + Send + Sync + 'static, V: OutputType + Serialize + DeserializeOwned + Clone + Send + Sync + 'static,