Struct HashCache 

pub struct HashCache {
    pub roots: HashMap<String, HashMap<String, String>>,
    pub dirty_roots: HashMap<String, DirtyInfo>,
}

Cache for file hashes to support incremental updates

Fields

roots: HashMap<String, HashMap<String, String>>

Map of root path -> (file path -> hash)

dirty_roots: HashMap<String, DirtyInfo>

Map of root paths that are currently being indexed (dirty state) with metadata If a root is in this map, its index may be incomplete/corrupted

Implementations

impl HashCache

pub fn load(cache_path: &Path) -> Result<Self>

Load cache from disk Handles migration from old format (dirty_roots as HashSet) to new format (dirty_roots as HashMap with DirtyInfo)

pub fn save(&self, cache_path: &Path) -> Result<()>

Save cache to disk

pub fn get_root(&self, root: &str) -> Option<&HashMap<String, String>>

Get file hashes for a root path

pub fn update_root(&mut self, root: String, hashes: HashMap<String, String>)

Update file hashes for a root path

pub fn remove_root(&mut self, root: &str)

Remove a root path from the cache

pub fn mark_dirty(&mut self, root: &str)

Mark a root path as dirty (indexing in progress) This should be called BEFORE indexing starts and the cache saved immediately

pub fn mark_dirty_with_info(&mut self, root: &str, expected_files: usize)

Mark a root path as dirty with expected file count

pub fn clear_dirty(&mut self, root: &str)

Clear the dirty flag for a root path (indexing completed successfully) This should be called AFTER indexing completes and the cache saved immediately

pub fn is_dirty(&self, root: &str) -> bool

Check if a root path is marked as dirty

pub fn get_dirty_info(&self, root: &str) -> Option<&DirtyInfo>

Get dirty info for a root path

pub fn get_dirty_roots(&self) -> &HashMap<String, DirtyInfo>

Get all dirty root paths

pub fn has_dirty_roots(&self) -> bool

Check if any roots are dirty

pub fn is_dirty_stale(&self, root: &str, max_age_secs: u64) -> bool

Check if a dirty flag is stale (older than the given duration) Returns true if the root is dirty AND the flag is older than max_age_secs

pub fn dirty_age_secs(&self, root: &str) -> Option<u64>

Get the age of a dirty flag in seconds, or None if not dirty

pub fn clear_stale_dirty_flags(&mut self, max_age_secs: u64) -> usize

Clear stale dirty flags (older than max_age_secs) Returns the number of stale flags cleared

pub fn default_path() -> PathBuf

Get default cache path (in user’s cache directory)

Trait Implementations

impl Clone for HashCache

fn clone(&self) -> HashCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HashCache

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

Formats the value using the given formatter.

impl Default for HashCache

fn default() -> HashCache

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for HashCache

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for HashCache

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

where __S: Serializer,

Serialize this value into the given Serde serializer.