Struct CacheData 

pub struct CacheData {
    pub cache_version: String,
    pub directory: String,
    pub file_snapshot: Vec<SnapshotItem>,
    pub match_operations: Vec<OpItem>,
    pub created_at: u64,
    pub ai_model_used: String,
    pub config_hash: String,
    pub original_relocation_mode: String,
    pub original_backup_enabled: bool,
}

Dry-run cache data structure containing snapshot and match history.

Stores the complete state of a directory scan and match operations, enabling efficient incremental processing and result caching.

Fields

cache_version: String

Version of the cache format for compatibility checking

directory: String

Path to the directory that was processed

file_snapshot: Vec<SnapshotItem>

Snapshot of all files found during scanning

match_operations: Vec<OpItem>

List of all match operations performed

created_at: u64

Timestamp when the cache was created

ai_model_used: String

AI model used for matching operations

config_hash: String

Hash of configuration used for matching

original_relocation_mode: String

Records the relocation mode when the cache was generated

original_backup_enabled: bool

Records whether backup was enabled when the cache was generated

Implementations

impl CacheData

pub fn load(path: &Path) -> Result<Self, Error>

Loads cache data from the specified file path.

pub fn has_empty_snapshot(&self) -> bool

Returns true when the cache carries no file snapshot entries.

Legacy caches generated before snapshot population was implemented will report true; callers should treat such caches as unable to perform freshness validation.

pub fn validate_snapshot(&self) -> Vec<StaleFile>

Validates every snapshot entry against the current filesystem state.

Returns a list of StaleFile records describing each file whose on-disk state diverges from the snapshot (missing, size mismatch, or modification-time mismatch). An empty result indicates that the snapshot is still consistent with the filesystem.

pub fn validate_target_paths(&self) -> Vec<PathBuf>

Checks whether any planned subtitle target path already exists on disk.

For every cached operation, the target path is computed based on the recorded relocation mode: when the mode is anything other than "None", the target resides next to the video file; otherwise it stays alongside the original subtitle file. Returns the list of target paths that already exist and would therefore conflict with applying the cached plan.

Trait Implementations

impl Clone for CacheData

fn clone(&self) -> CacheData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CacheData

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CacheData

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

where __S: Serializer,

Serialize this value into the given Serde serializer.