Method cascade_invalidation

graphlite/src/cache/invalidation.rs:342–377

(&self, initial_entries: &HashSet<String>)

    }

    fn cascade_invalidation(&self, initial_entries: &HashSet<String>) -> HashSet<String> {
        let mut cascaded = HashSet::new();
        let mut to_process: Vec<String> = initial_entries.iter().cloned().collect();
        let mut processed = HashSet::new();

        let max_depth = match &self.strategy {
            InvalidationStrategy::DependencyBased { max_depth, .. } => *max_depth,
            _ => 3, // Default cascade depth
        };

        let mut current_depth = 0;

        while !to_process.is_empty() && current_depth < max_depth {
            let current_batch = to_process;
            to_process = Vec::new();
            current_depth += 1;

            for entry in current_batch {
                if processed.contains(&entry) {
                    continue;
                }
                processed.insert(entry.clone());

                // Find entries that depend on this entry
                let dependent_entries = self.find_entries_dependent_on(&entry);
                for dep in dependent_entries {
                    if !cascaded.contains(&dep) && !initial_entries.contains(&dep) {
                        cascaded.insert(dep.clone());
                        to_process.push(dep);
                    }
                }
            }
        }

        cascaded
    }

    fn find_entries_dependent_on(&self, _entry_key: &str) -> HashSet<String> {
        // This would require reverse dependency tracking