Struct linera_views :: views :: map_view :: ByteMapView Copy item path

impl<C, V> ByteMapView<C, V>
where C: Context, ViewError: From<C::Error>,

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 + Sync, ViewError: From<C::Error>, 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 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, ViewError: From<C::Error>, 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, ViewError: From<C::Error>, 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 + Sync, ViewError: From<C::Error>, 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> ClonableView<C> for ByteMapView<C, V>
where C: Context + Send + Sync, ViewError: From<C::Error>, 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, V> ContainerType for ByteMapView<C, V>
where C: Context + Send + Sync, 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. Read more

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

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

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. Read more

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

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

Formats the value using the given formatter. Read more

impl<C, V> HashableView<C> for ByteMapView<C, V>
where C: Context + Send + Sync, ViewError: From<C::Error>, 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. Read more

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. Read more

impl<C, V> OutputType for ByteMapView<C, V>
where C: Context + Send + Sync, 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 Read more

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

Auto Trait Implementations§

impl<C, V> Freeze for ByteMapView<C, V>
where C: Freeze,

impl<C, V> RefUnwindSafe for ByteMapView<C, V>
where C: RefUnwindSafe, V: RefUnwindSafe,

impl<C, V> UnwindSafe for ByteMapView<C, V>
where C: UnwindSafe, V: RefUnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> ArchivePointee for T

type ArchivedMetadata = ()

The archived version of the pointer metadata for this type.

fn pointer_metadata( _: &<T as ArchivePointee>::ArchivedMetadata, ) -> <T as Pointee>::Metadata

Converts some archived metadata to the pointer metadata for itself.

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<Choices> CoproductSubsetter<CNil, HNil> for Choices

type Remainder = Choices

fn subset( self, ) -> Result<CNil, <Choices as CoproductSubsetter<CNil, HNil>>::Remainder>

Extract a subset of the possible types in a coproduct (or get the remaining possibilities) Read more

impl<F, W, T, D> Deserialize<With<T, W>, D> for F
where W: DeserializeWith<F, T, D>, D: Fallible + ?Sized, F: ?Sized,

fn deserialize( &self, deserializer: &mut D, ) -> Result<With<T, W>, <D as Fallible>::Error>

Deserializes using the given deserializer

impl<To, From> DynInto<To> for From
where From: Into<To>,

fn into_box(self: Box<From>) -> To

Converts a boxed object into the target type.

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.

impl<T> LayoutRaw for T

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

Gets the layout of the type.

impl<T, U, I> LiftInto<U, I> for T
where U: LiftFrom<T, I>,

fn lift_into(self) -> U

Performs the indexed conversion.

impl<T> MockResults for T

type Results = T

The mock native type of the results for the MockInstance.

impl<T> Pointable for T

const ALIGN: usize = _

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> Pointee for T

type Metadata = ()

The type for metadata in pointers and references to Self.

impl<M, I> RuntimeMemory<&mut I> for M
where M: RuntimeMemory,

fn read<'instance>( &self, instance: &'instance &mut I, location: GuestPointer, length: u32, ) -> Result<Cow<'instance, [u8]>, RuntimeError>

Reads length bytes from memory from the provided location.

fn write( &mut self, instance: &mut &mut I, location: GuestPointer, bytes: &[u8], ) -> Result<(), RuntimeError>

Writes the bytes to memory at the provided location.

impl<T> Same for T

type Output = T

Should always be Self

impl<Source> Sculptor<HNil, HNil> for Source

type Remainder = Source

fn sculpt(self) -> (HNil, <Source as Sculptor<HNil, HNil>>::Remainder)

Consumes the current HList and returns an HList with the requested shape. Read more

impl<AnyTail> Split<HNil> for AnyTail

type Remainder = AnyTail

The tail of remaining elements after splitting up the list.

fn split(self) -> (HNil, <AnyTail as Split<HNil>>::Remainder)

Splits the current heterogeneous list in two.

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<T> Upcastable for T
where T: Any + Send + Sync + 'static,

fn upcast_any_ref(&self) -> &(dyn Any + 'static)

upcast ref

fn upcast_any_mut(&mut self) -> &mut (dyn Any + 'static)

upcast mut ref

fn upcast_any_box(self: Box<T>) -> Box<dyn Any>

upcast boxed dyn

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

impl<T> ErasedDestructor for T
where T: 'static,

impl<T> MaybeSendSync for T