Function output_graph_content

atomic-core/src/output/repo/content.rs:137–268

Output the content of an alive graph to a span buffer. This function traverses the graph in SCC order (as computed by [`compute_order`](crate::output::alive::compute_order)) and writes each span's content to the buffer. Conflicts are handled by: - **Cyclic conflicts**: Multi-span SCCs are output with conflict markers - **Zombie content**: Deleted vertices with live edges get zombie markers # Ar

(
    changes: &C,
    hash_fn: F,
    graph: &AliveGraph,
    order: &OrderResult,
    buffer: &mut V,
)

/// 3. For zombie vertices: wrap in zombie conflict markers
/// 4. Track and report any content retrieval errors
pub fn output_graph_content<C, F, V>(
    changes: &C,
    hash_fn: F,
    graph: &AliveGraph,
    order: &OrderResult,
    buffer: &mut V,
) -> OutputResult<()>
where
    C: ChangeStore,
    F: Fn(NodeId) -> Option<Hash>,
    V: VertexBuffer,
{
    // Track conflict IDs
    let mut conflict_id: usize = 0;

    // Track zombie state
    let mut in_zombie: Option<usize> = None;

    // Process SCCs in reverse order (Tarjan produces reverse topological order,
    // so we iterate in reverse to get forward topological order for correct output)
    for scc in order.sccs.iter().rev() {
        // Skip empty SCCs (shouldn't happen, but be safe)
        if scc.is_empty() {
            continue;
        }

        // Check if this is a cyclic conflict (multi-span SCC)
        let is_cyclic = scc.len() > 1;

        if is_cyclic {
            conflict_id += 1;
            buffer
                .begin_cyclic_conflict(conflict_id)
                .map_err(OutputError::io)?;
        }

        // Output each span in the SCC
        for (i, &vertex_id) in scc.iter().enumerate() {
            // Get span data
            let vertex_data = match graph.try_get_vertex(vertex_id) {
                Some(v) => v,
                None => continue,
            };

            let node = vertex_data.node;

            // Handle zombie state transitions
            let is_zombie = vertex_data.is_zombie();

            if is_zombie && in_zombie.is_none() {
                // Entering zombie region
                conflict_id += 1;
                in_zombie = Some(conflict_id);

                let hash = hash_fn(node.change);
                let hashes: Vec<Hash> = hash.into_iter().collect();
                let hashes_ref: Option<&[Hash]> = if hashes.is_empty() {
                    None