Trait CollectionSnapshotExt 

pub trait CollectionSnapshotExt: Sized + StoreRead {
    // Provided methods
    fn collection<E>(
        &self,
        target: Collection<E>,
    ) -> Result<CollectionSnapshot<Self, E>, CollectionRealizationError>
       where E: CollectionEncoding,
             Handle<E>: InlineEncoding { ... }
    fn collection_acquiring<E>(
        &self,
        target: Collection<E>,
    ) -> Result<CollectionSnapshot<Self, E>, CollectionRealizationError>
       where E: CollectionEncoding,
             Handle<E>: InlineEncoding { ... }
    fn attached<E>(
        &self,
        attached: Collection<E>,
    ) -> Result<AttachedSnapshot<Self, E>, CollectionRealizationError>
       where E: CollectionEncoding,
             Handle<E>: InlineEncoding { ... }
    fn attached_acquiring<E>(
        &self,
        attached: Collection<E>,
    ) -> Result<AttachedSnapshot<Self, E>, CollectionRealizationError>
       where E: CollectionEncoding,
             Handle<E>: InlineEncoding { ... }
}

Immutable collection observations implemented by every complete store snapshot.

A snapshot is the temporal boundary. The returned CollectionSnapshot therefore owns this exact store observation, the physical target cover selected inside it, and the Support that cover stands on: a cover of the collection’s own foundations.

Provided Methods

fn collection<E>( &self, target: Collection<E>, ) -> Result<CollectionSnapshot<Self, E>, CollectionRealizationError>

where E: CollectionEncoding, Handle<E>: InlineEncoding,

Observe what one collection contains in this immutable snapshot.

Capability decisions use this snapshot’s immutable proof and definition state, independently of its clock. Physical target realization is selected entirely from this immutable store snapshot. Accepted target endorsements do not depend on the residency of their historical source records or source payloads.

fn collection_acquiring<E>( &self, target: Collection<E>, ) -> Result<CollectionSnapshot<Self, E>, CollectionRealizationError>

where E: CollectionEncoding, Handle<E>: InlineEncoding,

Select the resident cover plus known foundations it does not represent. A fetching reader can then read that fixed cover’s exact bytes through view. No new observation is taken during acquisition; a view which cannot read a chosen member returns an error, not a partial value.

fn attached<E>( &self, attached: Collection<E>, ) -> Result<AttachedSnapshot<Self, E>, CollectionRealizationError>

where E: CollectionEncoding, Handle<E>: InlineEncoding,

Observe what one attached collection holds for its parent in this immutable snapshot: the attached cover.

For each node of the parent’s frontier, widest first, its usable attachment is taken – a MAP the host signed, whose bytes and representation dependencies are here – and otherwise the attachments of the highest nodes beneath it that have one, found through the host’s own merges. The parent foundations no taken attachment reaches are the AttachedSnapshot::residual: read those nodes raw, or report them. Supports and usability come from this one observation.

fn attached_acquiring<E>( &self, attached: Collection<E>, ) -> Result<AttachedSnapshot<Self, E>, CollectionRealizationError>

where E: CollectionEncoding, Handle<E>: InlineEncoding,

Select one fixed attached observation, reading its explicit target and parent descriptors even when frozen residency says absent. A fetching reader may acquire those exact bytes. Selection otherwise uses the same frozen records/proofs and resident attachment cover as attached; read_acquiring subsequently reads its fixed residual.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<R> CollectionSnapshotExt for R

where R: StoreRead,