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

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

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

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

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 = 1

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