Struct HistoricallyHashableView 

pub struct HistoricallyHashableView<C, W> { /* private fields */ }

Wrapper to compute the hash of the view based on its history of modifications.

Implementations

impl<W: View> HistoricallyHashableView<W::Context, W>

pub async fn historical_hash(&mut self) -> Result<HasherOutput, ViewError>

Obtains a hash of the history of the changes in the view.

pub async fn dump_content( &mut self, ) -> Result<(Vec<u8>, HasherOutput), ViewError>

Returns the canonical byte representation of the inner view’s persisted content and arranges for the next save to record the hash of those bytes as the new stored hash. Subsequent updates extend the history from that hash normally.

The bytes are the BCS encoding of Vec<(Vec<u8>, Vec<u8>)> — every entry stored under the inner view’s prefix, in sorted lexicographic key order. Two views with identical persisted content produce identical bytes by construction; the hash is therefore reproducible by any party holding the bytes.

Errors with ViewError::HasPendingChanges if the inner view has unflushed changes — the dump reads from the underlying KV store and would silently miss in-memory modifications.

pub async fn restore_from_content( &mut self, bytes: &[u8], ) -> Result<HasherOutput, ViewError>

Replaces the inner view’s persisted content with bytes (a prior dump_content output) and atomically records the hash of those bytes as the new stored hash. Returns the recorded hash, so the caller can compare against an expected value.

The replacement is save-atomic: this method writes a single batch containing the inner-prefix wipe, the decoded (key, value) puts, and the wrapper’s hash key. The wrapper’s normal pre_save lifecycle is bypassed.

The inner view’s in-memory state is undefined after this returns. Callers should drop the view and reload before using it further.

Trait Implementations

impl<C, W: Allocative> Allocative for HistoricallyHashableView<C, W>

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

impl<W> ClonableView for HistoricallyHashableView<W::Context, W>

where W: ClonableView,

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: Debug, W: Debug> Debug for HistoricallyHashableView<C, W>

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

Formats the value using the given formatter.

impl<C, W> Deref for HistoricallyHashableView<C, W>

type Target = W

The resulting type after dereferencing.

fn deref(&self) -> &W

Dereferences the value.

impl<C, W> DerefMut for HistoricallyHashableView<C, W>

fn deref_mut(&mut self) -> &mut W

Mutably dereferences the value.

impl<C, W> OutputType for HistoricallyHashableView<C, W>

where C: Context, W: OutputType + Send + Sync,

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

Type the name.

fn qualified_type_name() -> String

Qualified typename.

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 introspection_type_name(&self) -> Cow<'static, str>

Introspection type name

impl<C, W, C2> ReplaceContext<C2> for HistoricallyHashableView<C, W>

where W: View<Context = C> + ReplaceContext<C2>, C: Context, C2: Context,

type Target = HistoricallyHashableView<C2, <W as ReplaceContext<C2>>::Target>

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<W> View for HistoricallyHashableView<W::Context, W>

where W: View,

const NUM_INIT_KEYS: usize

The number of keys used for the initialization

type Context = <W as View>::Context

The type of context stored in this view

fn context(&self) -> Self::Context

Obtains a mutable reference to the internal context.

fn pre_load(context: &Self::Context) -> Result<Vec<Vec<u8>>, ViewError>

Creates the keys needed for loading the view

fn post_load( context: Self::Context, values: &[Option<Vec<u8>>], ) -> Result<Self, ViewError>

Loads a view from the values

async fn load(context: Self::Context) -> Result<Self, ViewError>

Loads a view

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 new(context: Self::Context) -> Result<Self, ViewError>

Builds a trivial view that is already deleted