Struct Manifest 

pub struct Manifest {
    pub entries: BTreeMap<String, ContentHash>,
}

A per-view manifest body: path -> the content hash of the populating slice.

Backed by a BTreeMap so serialization has deterministic key order — a manifest with the same entries always hashes identically, which keeps its record revision stable under content-addressed dedup.

Fields

entries: BTreeMap<String, ContentHash>

Implementations

impl Manifest

pub fn new() -> Self

An empty manifest.

pub fn key(repo: impl Into<String>, view_id: impl Into<String>) -> RecordKey

The stable RecordKey addressing the manifest for (repo, view_id). A view has exactly one manifest, so this is a pure function of the pair.

pub fn collection() -> &'static str

The collection segment every manifest is addressed under. A KeyPrefix with this collection and no namespace lists every view’s manifest across all repos — the set GC must union to mark live slices.

pub fn insert(&mut self, path: impl Into<String>, hash: ContentHash)

Record that path is populated by the slice with content hash hash.

pub fn get(&self, path: &str) -> Option<&ContentHash>

The content hash of the slice populating path, if the view has one.

pub fn to_body(&self) -> Body

Serialize into an inline record Body (deterministic key order).

pub fn from_body(body: &Body) -> Result<Self>

Reconstruct a manifest from a record Body. Errors if the body bytes are not a valid serialized manifest.

pub fn reconcile( &self, desired: &BTreeMap<String, ContentHash>, ) -> Reconciliation

Reconcile this manifest against the desired path -> content_hash set of a working tree, returning the change sets and the reconciled manifest.

The A/M/D classification is a pure set difference, so it is robust to missed events — a full reconcile always converges the manifest onto the tree regardless of how the desired set was sourced (a git diff stream is only an optimization for building it). Unchanged paths (present in both with an equal hash) appear in none of the change sets. Each set is sorted for deterministic output, and the reconciled manifest equals desired.

Trait Implementations

impl Clone for Manifest

fn clone(&self) -> Manifest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Manifest

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

Formats the value using the given formatter.

impl Default for Manifest

fn default() -> Manifest

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Manifest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Manifest

fn eq(&self, other: &Manifest) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Manifest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Manifest

impl StructuralPartialEq for Manifest