Struct LogView

pub struct LogView<C, T> { /* private fields */ }

A view that supports logging values of type T.

Implementations

impl<C, T> LogView<C, T>

where C: Context,

pub fn push(&mut self, value: T)

Pushes a value to the end of the log.

let mut log = LogView::load(context).await.unwrap();
log.push(34);

pub fn count(&self) -> usize

Reads the size of the log.

let mut log = LogView::load(context).await.unwrap();
log.push(34);
log.push(42);
assert_eq!(log.count(), 2);

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

Obtains the extra data.

impl<C, T> LogView<C, T>

where C: Context, T: Clone + DeserializeOwned + Serialize + Send + Sync,

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

Reads the logged value with the given index (including staged ones).

let mut log = LogView::load(context).await.unwrap();
log.push(34);
assert_eq!(log.get(0).await.unwrap(), Some(34));

pub async fn multi_get( &self, indices: Vec<usize>, ) -> Result<Vec<Option<T>>, ViewError>

Reads several logged keys (including staged ones)

let mut log = LogView::load(context).await.unwrap();
log.push(34);
log.push(42);
assert_eq!(
    log.multi_get(vec![0, 1]).await.unwrap(),
    vec![Some(34), Some(42)]
);

pub async fn multi_get_pairs( &self, indices: Vec<usize>, ) -> Result<Vec<(usize, Option<T>)>, ViewError>

Reads the index-value pairs at the given positions.

let mut log = LogView::load(context).await.unwrap();
log.push(34);
log.push(42);
assert_eq!(
    log.multi_get_pairs(vec![0, 1, 5]).await.unwrap(),
    vec![(0, Some(34)), (1, Some(42)), (5, None)]
);

pub async fn read<R>(&self, range: R) -> Result<Vec<T>, ViewError>

where R: RangeBounds<usize>,

Reads the logged values in the given range (including staged ones).

let mut log = LogView::load(context).await.unwrap();
log.push(34);
log.push(42);
log.push(56);
assert_eq!(log.read(0..2).await.unwrap(), vec![34, 42]);

Trait Implementations

impl<C, T> ClonableView for LogView<C, T>

where C: Context, T: 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: Context, T> ContainerType for LogView<C, T>

where T: Serialize + DeserializeOwned + Clone + Send + Sync + 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, T: Debug> Debug for LogView<C, T>

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

Formats the value using the given formatter.

impl<C, T> HashableView for LogView<C, T>

where C: Context, T: Send + Sync + Clone + Serialize + DeserializeOwned,

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: Context, T> OutputType for LogView<C, T>

where T: Serialize + DeserializeOwned + Clone + Send + Sync + 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, T: OutputType> TypeName for LogView<C, T>

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

Returns a GraphQL type name.

impl<C, T> View for LogView<C, T>

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

const NUM_INIT_KEYS: usize = 1usize

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 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 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: Context, T> ObjectType for LogView<C, T>

where T: Serialize + DeserializeOwned + Clone + Send + Sync + OutputType,