Struct ByteMapView

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

A view that supports inserting and removing values indexed by Vec<u8>.

Implementations

impl<C, V> ByteMapView<C, V>

where C: Context,

pub fn insert(&mut self, short_key: Vec<u8>, value: V)

Inserts or resets the value of a key of the map.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
assert_eq!(map.keys().await.unwrap(), vec![vec![0, 1]]);

pub fn remove(&mut self, short_key: Vec<u8>)

Removes a value. If absent then nothing is done.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], "Hello");
map.remove(vec![0, 1]);

pub fn remove_by_prefix(&mut self, key_prefix: Vec<u8>)

Removes a value. If absent then nothing is done.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
map.insert(vec![0, 2], String::from("Bonjour"));
map.remove_by_prefix(vec![0]);
assert!(map.keys().await.unwrap().is_empty());

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

Obtains the extra data.

pub async fn contains_key(&self, short_key: &[u8]) -> Result<bool, ViewError>

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

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
assert!(map.contains_key(&[0, 1]).await.unwrap());
assert!(!map.contains_key(&[0, 2]).await.unwrap());

impl<C, V> ByteMapView<C, V>

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

pub async fn get(&self, short_key: &[u8]) -> Result<Option<V>, ViewError>

Reads the value at the given position, if any.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
assert_eq!(map.get(&[0, 1]).await.unwrap(), Some(String::from("Hello")));

pub async fn multi_get( &self, short_keys: Vec<Vec<u8>>, ) -> Result<Vec<Option<V>>, ViewError>

Reads the values at the given positions, if any.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
let values = map.multi_get(vec![vec![0, 1], vec![0, 2]]).await.unwrap();
assert_eq!(values, vec![Some(String::from("Hello")), None]);

pub async fn multi_get_pairs( &self, short_keys: Vec<Vec<u8>>, ) -> Result<Vec<(Vec<u8>, Option<V>)>, ViewError>

Reads the key-value pairs at the given positions, if any.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
let pairs = map
    .multi_get_pairs(vec![vec![0, 1], vec![0, 2]])
    .await
    .unwrap();
assert_eq!(
    pairs,
    vec![
        (vec![0, 1], Some(String::from("Hello"))),
        (vec![0, 2], None)
    ]
);

pub async fn get_mut( &mut self, short_key: &[u8], ) -> Result<Option<&mut V>, ViewError>

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

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
let value = map.get_mut(&[0, 1]).await.unwrap().unwrap();
assert_eq!(*value, String::from("Hello"));
*value = String::from("Hola");
assert_eq!(map.get(&[0, 1]).await.unwrap(), Some(String::from("Hola")));

impl<C, V> ByteMapView<C, V>

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

pub async fn for_each_key_while<F>( &self, f: F, prefix: Vec<u8>, ) -> Result<(), ViewError>

where F: FnMut(&[u8]) -> Result<bool, ViewError> + Send,

Applies the function f on each index (aka key) which has the assigned prefix. Keys are visited in the lexicographic order. The shortened key is send to the function and if it returns false, then the loop exits

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
map.insert(vec![1, 2], String::from("Bonjour"));
map.insert(vec![1, 3], String::from("Bonjour"));
let prefix = vec![1];
let mut count = 0;
map.for_each_key_while(
    |_key| {
        count += 1;
        Ok(count < 3)
    },
    prefix,
)
.await
.unwrap();
assert_eq!(count, 2);

pub async fn for_each_key<F>( &self, f: F, prefix: Vec<u8>, ) -> Result<(), ViewError>

where F: FnMut(&[u8]) -> Result<(), ViewError> + Send,

Applies the function f on each index (aka key) having the specified prefix. The shortened keys are sent to the function f. Keys are visited in the lexicographic order.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
let mut count = 0;
let prefix = Vec::new();
map.for_each_key(
    |_key| {
        count += 1;
        Ok(())
    },
    prefix,
)
.await
.unwrap();
assert_eq!(count, 1);

pub async fn keys(&self) -> Result<Vec<Vec<u8>>, ViewError>

Returns the list of keys of the map in lexicographic order.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
map.insert(vec![1, 2], String::from("Bonjour"));
map.insert(vec![2, 2], String::from("Hallo"));
assert_eq!(
    map.keys().await.unwrap(),
    vec![vec![0, 1], vec![1, 2], vec![2, 2]]
);

pub async fn keys_by_prefix( &self, prefix: Vec<u8>, ) -> Result<Vec<Vec<u8>>, ViewError>

Returns the list of keys of the map having a specified prefix in lexicographic order.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
map.insert(vec![1, 2], String::from("Bonjour"));
map.insert(vec![1, 3], String::from("Hallo"));
assert_eq!(
    map.keys_by_prefix(vec![1]).await.unwrap(),
    vec![vec![1, 2], vec![1, 3]]
);

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

Returns the number of keys of the map

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
map.insert(vec![1, 2], String::from("Bonjour"));
map.insert(vec![2, 2], String::from("Hallo"));
assert_eq!(map.count().await.unwrap(), 3);

pub async fn for_each_key_value_while<'a, F>( &'a self, f: F, prefix: Vec<u8>, ) -> Result<(), ViewError>

where F: FnMut(&[u8], Cow<'a, V>) -> Result<bool, ViewError> + Send,

Applies a function f on each index/value pair matching a prefix. Keys and values are visited in the lexicographic order. The shortened index is send to the function f and if it returns false then the loop ends prematurely

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
map.insert(vec![1, 2], String::from("Bonjour"));
map.insert(vec![1, 3], String::from("Hallo"));
let mut part_keys = Vec::new();
let prefix = vec![1];
map.for_each_key_value_while(
    |key, _value| {
        part_keys.push(key.to_vec());
        Ok(part_keys.len() < 2)
    },
    prefix,
)
.await
.unwrap();
assert_eq!(part_keys.len(), 2);

pub async fn for_each_key_value<'a, F>( &'a self, f: F, prefix: Vec<u8>, ) -> Result<(), ViewError>

where F: FnMut(&[u8], Cow<'a, V>) -> Result<(), ViewError> + Send,

Applies a function f on each key/value pair matching a prefix. The shortened key and value are send to the function f. Keys and values are visited in the lexicographic order.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
let mut count = 0;
let prefix = Vec::new();
map.for_each_key_value(
    |_key, _value| {
        count += 1;
        Ok(())
    },
    prefix,
)
.await
.unwrap();
assert_eq!(count, 1);

impl<C, V> ByteMapView<C, V>

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

pub async fn key_values_by_prefix( &self, prefix: Vec<u8>, ) -> Result<Vec<(Vec<u8>, V)>, ViewError>

Returns the list of keys and values of the map matching a prefix in lexicographic order.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![1, 2], String::from("Hello"));
let prefix = vec![1];
assert_eq!(
    map.key_values_by_prefix(prefix).await.unwrap(),
    vec![(vec![1, 2], String::from("Hello"))]
);

pub async fn key_values(&self) -> Result<Vec<(Vec<u8>, V)>, ViewError>

Returns the list of keys and values of the map in lexicographic order.

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![1, 2], String::from("Hello"));
assert_eq!(
    map.key_values().await.unwrap(),
    vec![(vec![1, 2], String::from("Hello"))]
);

impl<C, V> ByteMapView<C, V>

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

pub async fn get_mut_or_default( &mut self, short_key: &[u8], ) -> Result<&mut V, ViewError>

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

let mut map = ByteMapView::load(context).await.unwrap();
map.insert(vec![0, 1], String::from("Hello"));
assert_eq!(map.get_mut_or_default(&[7]).await.unwrap(), "");
let value = map.get_mut_or_default(&[0, 1]).await.unwrap();
assert_eq!(*value, String::from("Hello"));
*value = String::from("Hola");
assert_eq!(map.get(&[0, 1]).await.unwrap(), Some(String::from("Hola")));

Trait Implementations

impl<C, V: Allocative> Allocative for ByteMapView<C, V>

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

impl<C: Clone, V: Clone> ClonableView for ByteMapView<C, V>

where Self: View,

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

where C: Context, 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, V: Debug> Debug for ByteMapView<C, V>

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

Formats the value using the given formatter.

impl<C, V> HashableView for ByteMapView<C, V>

where C: Context, 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, V> OutputType for ByteMapView<C, V>

where C: Context, 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: Context, C2: Context, V> ReplaceContext<C2> for ByteMapView<C, V>

where V: Send + Sync + Serialize + Clone,

type Target = ByteMapView<C2, V>

The type returned after replacing the context.

async fn with_context( &mut self, ctx: impl FnOnce(&Self::Context) -> C2 + Clone, ) -> Self::Target

Returns a view with a replaced context.

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

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

Returns a GraphQL type name.

impl<C, V> View for ByteMapView<C, V>

where C: Context, V: Send + Sync + Serialize,

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

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