Function render_name_conflict

atomic-repository/src/repository/materialize.rs:187–236

(
    txn: &atomic_core::pristine::ReadTxn,
    store: &C,
    inode_graph_table: &redb::ReadOnlyMultimapTable<&'static [u8; 32], &'static [u8; 24]>,
    change_filter_arc: &Arc<std::collections::Hash

/// deterministic order so the rendering is stable across runs.
#[allow(clippy::too_many_arguments)]
fn render_name_conflict<C: atomic_core::change::ChangeStore>(
    txn: &atomic_core::pristine::ReadTxn,
    store: &C,
    inode_graph_table: &redb::ReadOnlyMultimapTable<&'static [u8; 32], &'static [u8; 24]>,
    change_filter_arc: &Arc<std::collections::HashSet<NodeId>>,
    path: &str,
    sides: &[(Inode, Position<NodeId>)],
) -> Result<Vec<u8>, String> {
    use atomic_core::output::repo::{
        output_graph_content_resolved, resolve_conflicts_semantically,
    };
    use atomic_core::output::{compute_order, retrieve_graph, RetrieveOptions, Writer};
    use atomic_core::pristine::InodePreloadTxn;

    let mut out: Vec<u8> = Vec::new();
    for (i, (inode, position)) in sides.iter().enumerate() {
        if i == 0 {
            out.extend_from_slice(format!(">>>>>>> {} (name conflict)\n", path).as_bytes());
        } else {
            out.extend_from_slice(b"=======\n");
        }

        let preloaded = InodePreloadTxn::from_table(txn, *inode, inode_graph_table)
            .map_err(|e| format!("{}: name-conflict preload: {:?}", path, e))?;
        let retrieve_opts =
            RetrieveOptions::default().with_change_filter_arc(change_filter_arc.clone());
        let retrieve_result = retrieve_graph(&preloaded, *position, retrieve_opts)
            .map_err(|e| format!("{}: name-conflict retrieve: {:?}", path, e))?;
        let mut graph = retrieve_result.graph;
        let order = compute_order(&mut graph);
        let resolved = resolve_conflicts_semantically(&preloaded, store, &graph, &order);
        let buffer = Vec::with_capacity(graph.total_bytes());
        let mut writer = Writer::new(buffer);
        let hash_fn = |node_id: NodeId| -> Option<Hash> {
            if node_id.is_root() {
                return None;
            }
            preloaded.get_external(node_id).ok().flatten()
        };
        output_graph_content_resolved(store, hash_fn, &graph, &order, &mut writer, &resolved)
            .map_err(|e| format!("{}: name-conflict content: {:?}", path, e))?;
        let side = writer.into_inner();
        out.extend_from_slice(&side);
        if !side.ends_with(b"\n") {
            out.push(b'\n');
        }
    }
    out.extend_from_slice(format!("<<<<<<< {} (name conflict)\n", path).as_bytes());
    Ok(out)
}

impl Repository {
    /// Persist the conflict state discovered by a materialize into the