Struct IndexPersistence 

pub struct IndexPersistence { /* private fields */ }

Manages saving and loading IndexSnapshot files

Example

use ipfrs_semantic::persistence::{IndexPersistence, IndexSnapshot};

let p = IndexPersistence::new("/path/to/my_index.snap");
// p.save(&snapshot)?;
// let snapshot = p.load()?;

Implementations

impl IndexPersistence

pub fn new(path: impl Into<PathBuf>) -> Self

Create a new IndexPersistence that reads/writes to path

pub fn save(&self, snapshot: &IndexSnapshot) -> Result<()>

Serialize snapshot and write it atomically to the configured path

Uses a write-to-temp-then-rename strategy so partial writes never corrupt an existing good snapshot.

pub fn load(&self) -> Result<IndexSnapshot>

Deserialize and return the IndexSnapshot stored at the configured path

pub fn exists(&self) -> bool

Return true if the snapshot file exists on disk

pub fn delete(&self) -> Result<()>

Delete the snapshot file. No-ops silently if the file is absent.

pub fn path(&self) -> &Path

Return the configured snapshot path

pub fn save_smart(&self, index: &VectorIndex) -> Result<()>

Smart save: use an incremental delta when fewer than 10 % of total entries are dirty, otherwise fall back to a full snapshot.

This is the preferred entry-point for Node::stop because it avoids re-writing the entire index on every shutdown when only a handful of embeddings have changed.

After a successful write the tracker inside index is marked clean.

Decision rule

• If the index is empty → full snapshot (no-op, but valid state).
• If dirty_count / total_count < 0.10 AND a full base snapshot already exists on disk → incremental delta.
• Otherwise → full snapshot.

pub fn incremental_path(&self) -> PathBuf

Path for the incremental (delta) snapshot alongside the full snapshot

For a base path of foo/index.snap this returns foo/index.snap.delta.

pub fn save_incremental(&self, snapshot: &IncrementalSnapshot) -> Result<()>

Serialize snapshot and write it as an incremental (delta) snapshot

The delta file sits alongside the full snapshot at <base>.delta. Uses the same atomic write-then-rename strategy as save.

pub fn load_incremental(&self) -> Result<IncrementalSnapshot>

Deserialize and return the IncrementalSnapshot stored at the delta path

pub fn apply_incremental( base: &mut IndexSnapshot, delta: &IncrementalSnapshot, ) -> Result<()>

Apply an incremental delta to an existing full IndexSnapshot in place

Entries whose IDs appear in delta.deleted_ids are removed, then all delta.changed_entries are upserted (replacing existing entries with the same id or appending new ones).