Function collect_all_dependencies

atomic-repository/src/apply/mod.rs:480–525

Collect all dependencies needed to insert a change. This recursively collects all transitive dependencies. # Arguments `txn` - Read transaction `change` - The change to collect dependencies for `available` - Set of available change hashes `max_depth` - Maximum recursion depth # Returns Set of all dependency hashes needed (not including those already applied).

(
    txn: &T,
    change: &Change,
    available: &HashSet<Hash>,
    max_depth: usize,
)

///
/// Set of all dependency hashes needed (not including those already applied).
pub fn collect_all_dependencies<T: GraphTxnT>(
    txn: &T,
    change: &Change,
    available: &HashSet<Hash>,
    max_depth: usize,
) -> InsertResult<HashSet<Hash>> {
    let mut needed = HashSet::new();
    let mut queue: VecDeque<(Hash, usize)> = VecDeque::new();
    let mut visited = HashSet::new();

    // Start with direct dependencies
    for dep in change.dependencies() {
        if !visited.contains(dep) {
            queue.push_back((*dep, 0));
            visited.insert(*dep);
        }
    }

    while let Some((hash, depth)) = queue.pop_front() {
        if depth > max_depth {
            return Err(InsertError::CyclicDependency {
                message: format!("Maximum dependency depth {} exceeded", max_depth),
            });
        }

        // Check if already in repository
        if txn
            .get_internal(&hash)
            .map_err(|e| InsertError::Database(e.to_string()))?
            .is_some()
        {
            continue;
        }

        // Check if available
        if available.contains(&hash) {
            needed.insert(hash);
            // Note: We'd need the actual change content to recurse further
            // For now, we assume available changes have their deps satisfied
        } else {
            needed.insert(hash);
        }
    }

    Ok(needed)
}