Struct ViewStore 

pub struct ViewStore<'a, S> {
    pub store: &'a S,
    pub repo: &'a RepoId,
    pub writer: bool,
    pub policy: Option<&'a dyn PublicationPolicy>,
}

A read-only store facade selected after repository authorization.

Fields

store: &'a S

Underlying store; mutations through the facade are refused.

repo: &'a RepoId

Authorized repository identity.

writer: bool

Writer view, without conferring read permission.

policy: Option<&'a dyn PublicationPolicy>

Coherent serving-stop seam, shared by writer and reader views.

Trait Implementations

impl<S> Debug for ViewStore<'_, S>

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

Formats the value using the given formatter.

impl<S: NamespaceStore> NamespaceStore for ViewStore<'_, S>

fn capabilities(&self) -> StoreCapabilities

What this store supports.

async fn get( &self, p: &Partition, key: &Key, ) -> Result<Option<Value>, StoreError>

The value at key, if any.

async fn get_many( &self, p: &Partition, keys: &[Key], ) -> Result<Vec<Option<Value>>, StoreError>

Several keys in one round trip; results in input order. The default issues sequential Self::get calls.

async fn scan( &self, p: &Partition, start: &Key, end: &Key, after: Option<&Cursor>, limit: u32, ) -> Result<ScanPage, StoreError>

Up to limit (at least 1) entries in [start, end), ascending by key bytes. after resumes strictly after the cursor’s position; a cursor outside [start, end) (forged, or from another range) is StoreError::Invalid. A page may hold fewer than limit entries and still return next: callers page until next is None.

async fn scan_many( &self, p: &Partition, ranges: &[RangeScan], ) -> Result<Vec<ScanPage>, StoreError>

Scan a served prefix of ranges in order. A nonempty request returns at least its first page and at most one page per range; callers re-request any unserved suffix. Every returned page obeys Self::scan. The default serves every range sequentially.

async fn apply( &self, _: &Partition, _: Batch, ) -> Result<BatchOutcome, StoreError>

One atomic, all-or-nothing batch: validate it, read the backend clock once, check every precondition in order against committed state (NotAfter against that reading); on the first failure return BatchOutcome::PreconditionFailed or BatchOutcome::DeadlinePassed and write nothing, otherwise apply every write and return BatchOutcome::Committed.

async fn stats(&self, p: &Partition) -> Result<PartitionStats, StoreError>

Storage used by one partition; may be approximate or up to 60 s stale.

async fn probe(&self) -> Result<(), StoreError>

A cheap health check.

fn has( &self, p: &Partition, key: &Key, ) -> impl Future<Output = Result<bool, StoreError>> + MaybeSend

Whether key holds a value.