Function import_seed_alive_reaches

atomic-repository/src/repository/insert.rs:299–360

(
    txn: &T,
    inode: Inode,
    start: GraphNode<NodeId>,
    target: GraphNode<NodeId>,
    visible: &HashSet<NodeId>,
)

}

fn import_seed_alive_reaches<T>(
    txn: &T,
    inode: Inode,
    start: GraphNode<NodeId>,
    target: GraphNode<NodeId>,
    visible: &HashSet<NodeId>,
) -> bool
where
    T: GraphTxnT + InodeGraphOps,
{
    if start == target {
        return true;
    }

    let mut stack = vec![start];
    let mut seen = HashSet::new();

    while let Some(current) = stack.pop() {
        if !seen.insert(current) {
            continue;
        }

        let mut adj = match txn.init_inode_adj(inode, current, EdgeFlags::BLOCK, EdgeFlags::all()) {
            Ok(adj) => adj,
            Err(_) => continue,
        };

        while let Some(edge) = txn.next_inode_adj(&mut adj) {
            let Ok(edge) = edge else {
                continue;
            };
            let flags = edge.flag();
            if flags.contains(EdgeFlags::PARENT)
                || flags.contains(EdgeFlags::DELETED)
                || flags.contains(EdgeFlags::PSEUDO)
                || !import_seed_edge_visible(&edge, visible)
            {
                continue;
            }

            let Some(dest) = txn
                .find_block_in_inode(inode, edge.dest())
                .ok()
                .flatten()
                .or_else(|| txn.find_block(edge.dest()).ok())
            else {
                continue;
            };
            if !import_seed_node_visible(dest, visible)
                || import_seed_is_dead(txn, inode, dest, visible)
            {
                continue;
            }
            if dest == target {
                return true;
            }
            stack.push(dest);
        }