Struct linera_views::views::map_view::MapView

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

A View that has a type for keys. The ordering of the entries is determined by the serialization of the context.

Implementations

impl<C, I, V> MapView<C, I, V>

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

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

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

Inserts or resets a value at an index.

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

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

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

Removes a value. If absent then the operation does nothing.

let mut map = MapView::<_, u32, String>::load(context).await.unwrap();
map.remove(&(37 as u32));
assert_eq!(map.get(&(37 as u32)).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::<_, u32, String>::load(context).await.unwrap();
map.insert(&(37 as u32), String::from("Hello"));
assert!(map.contains_key(&(37 as u32)).await.unwrap());
assert!(!map.contains_key(&(34 as u32)).await.unwrap());

impl<C, I, V> MapView<C, I, V>

where C: Context + Sync, ViewError: From<C::Error>, I: Serialize, V: Clone + DeserializeOwned + 'static,

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

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

Reads the value at the given position, if any.

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

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

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

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

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

impl<C, I, V> MapView<C, I, V>

where C: Context + Sync, ViewError: From<C::Error>, I: Send + DeserializeOwned, V: Clone + Sync + 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 serialization.

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

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

let mut map: MapView<_, u128, String> = MapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Thanks"));
map.insert(&(37 as u128), String::from("Spasiba"));
map.insert(&(38 as u128), String::from("Merci"));
let mut count = 0;
map.for_each_index_while(|_index| {
    count += 1;
    Ok(count < 2)
})
.await
.unwrap();
assert_eq!(count, 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 the order determined by serialization.

let mut map: MapView<_, u128, String> = MapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Hello"));
let mut count = 0;
map.for_each_index(|_index| {
    count += 1;
    Ok(())
})
.await
.unwrap();
assert_eq!(count, 1);

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 each index/value pair. Indices and values are visited in an order determined by serialization. If the function returns false, then the loop ends prematurely.

let mut map: MapView<_, u128, String> = MapView::load(context).await.unwrap();
map.insert(&(34 as u128), String::from("Thanks"));
map.insert(&(37 as u128), String::from("Spasiba"));
map.insert(&(38 as u128), String::from("Merci"));
let mut values = Vec::new();
map.for_each_index_value_while(|_index, value| {
    values.push(value);
    Ok(values.len() < 2)
})
.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 on each index/value pair. Indices and values are visited in an order determined by serialization.

let mut map: MapView<_, Vec<u8>, _> = MapView::load(context).await.unwrap();
map.insert(&vec![0, 1], String::from("Hello"));
let mut count = 0;
map.for_each_index_value(|_index, _value| {
    count += 1;
    Ok(())
})
.await
.unwrap();
assert_eq!(count, 1);

impl<C, I, V> MapView<C, I, V>

where C: Context + Sync, ViewError: From<C::Error>, I: Send + DeserializeOwned, 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> MapView<C, I, V>

where C: Context + Sync, ViewError: From<C::Error>, I: Serialize, 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: Sync + Send + Serialize + ?Sized,

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

let mut map: MapView<_, u32, u128> = MapView::load(context).await.unwrap();
let value = map.get_mut_or_default(&(34 as u32)).await.unwrap();
assert_eq!(*value, 0 as u128);

Trait Implementations

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

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

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 MapView<C, I, V>

where C: Context + Send + Sync, I: OutputType + InputType + Serialize + DeserializeOwned + 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 MapView<C, I, V>

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

Formats the value using the given formatter.

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

where C: Context + Send + Sync, ViewError: From<C::Error>, I: Send + Sync + Serialize + DeserializeOwned, V: Clone + Send + Sync + Serialize + DeserializeOwned + '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, I, V> OutputType for MapView<C, I, V>

where C: Context + Send + Sync, I: OutputType + InputType + Serialize + DeserializeOwned + 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 MapView<C, I, V>

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

Returns a GraphQL type name.

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

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

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

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