Function output_graph_content_resolved

atomic-core/src/output/repo/content.rs:502–733

Output graph content with semantic-merge resolution. This is the merge-aware counterpart of [`output_graph_content`]. For every SCC whose lead vertex appears in `resolved`, the merged bytes are written directly and the remaining vertices are silently skipped. All other SCCs are handled identically to `output_graph_content`. If `resolved` is empty this function behaves exactly like [`output_gra

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

/// If `resolved` is empty this function behaves exactly like
/// [`output_graph_content`].
pub fn output_graph_content_resolved<C, F, V>(
    changes: &C,
    hash_fn: F,
    graph: &AliveGraph,
    order: &OrderResult,
    buffer: &mut V,
    resolved: &ResolvedConflicts,
) -> OutputResult<()>
where
    C: ChangeStore,
    F: Fn(NodeId) -> Option<Hash>,
    V: VertexBuffer,
{
    // Fast path: nothing was resolved and no unresolved forks.
    if resolved.is_empty() && resolved.unresolved_forks().is_empty() {
        return output_graph_content(changes, hash_fn, graph, order, buffer);
    }

    // Track conflict IDs
    let mut conflict_id: usize = 0;

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

    // Track which fork-conflict vertices have already been emitted.
    let mut fork_emitted: std::collections::HashSet<VertexId> = std::collections::HashSet::new();

    for scc in order.sccs.iter().rev() {
        if scc.is_empty() {
            continue;
        }

        let is_cyclic = scc.len() > 1;

        // ── Resolved SCC: emit merged bytes, no conflict markers ──────
        if is_cyclic {
            if let Some(merged) = resolved.get_merged(scc[0]) {
                if !merged.is_empty() {
                    let synthetic = GraphNode::new(
                        NodeId::ROOT,
                        ChangePosition::new(0),
                        ChangePosition::new(merged.len() as u64),
                    );
                    // Clone into a local so the closure can own it
                    // (`output_line` takes `FnOnce`).
                    let bytes = merged.to_vec();
                    buffer
                        .output_line(synthetic, |buf: &mut [u8]| -> Result<(), std::io::Error> {
                            buf.copy_from_slice(&bytes);
                            Ok(())
                        })
                        .map_err(OutputError::io)?;
                }
                continue; // skip remaining vertices in this SCC
            }
        }

        // ── Fork-resolved: single-vertex SCC with merged or skipped content ─