Method collect_hunk_hashes

atomic-core/src/change/change.rs:590–747

Collect all unique hashes referenced by hunks into the hash dedup table. This walks every position, graph node, and introduced_by field in every hunk and registers each `Some(Hash)` in the table.

(
        &self,
        table: &mut format_v3::HashDedupTable,
    )

    /// This walks every position, graph node, and introduced_by field in
    /// every hunk and registers each `Some(Hash)` in the table.
    fn collect_hunk_hashes(
        &self,
        table: &mut format_v3::HashDedupTable,
    ) -> Result<(), format_v3::FormatError> {
        use crate::change::atom::{Atom, EdgeUpdate, Insertion, NewEdge};

        fn collect_position_hash(
            pos: &crate::Position<Option<Hash>>,
            table: &mut format_v3::HashDedupTable,
        ) -> Result<(), format_v3::FormatError> {
            if let Some(ref h) = pos.change {
                table.insert(*h.as_bytes())?;
            }
            Ok(())
        }

        fn collect_graph_node_hash(
            node: &crate::GraphNode<Option<Hash>>,
            table: &mut format_v3::HashDedupTable,
        ) -> Result<(), format_v3::FormatError> {
            if let Some(ref h) = node.change {
                table.insert(*h.as_bytes())?;
            }
            Ok(())
        }

        fn collect_insertion_hashes(
            v: &Insertion<Option<Hash>>,
            table: &mut format_v3::HashDedupTable,
        ) -> Result<(), format_v3::FormatError> {
            for p in &v.predecessors {
                collect_position_hash(p, table)?;
            }
            for p in &v.successors {
                collect_position_hash(p, table)?;
            }
            collect_position_hash(&v.inode, table)?;
            Ok(())
        }

        fn collect_new_edge_hashes(
            e: &NewEdge<Option<Hash>>,
            table: &mut format_v3::HashDedupTable,
        ) -> Result<(), format_v3::FormatError> {
            collect_position_hash(&e.from, table)?;
            collect_graph_node_hash(&e.to, table)?;
            if let Some(ref h) = e.introduced_by {
                table.insert(*h.as_bytes())?;
            }
            Ok(())
        }

        fn collect_edge_update_hashes(
            em: &EdgeUpdate<Option<Hash>>,
            table: &mut format_v3::HashDedupTable,
        ) -> Result<(), format_v3::FormatError> {
            for e in &em.edges {
                collect_new_edge_hashes(e, table)?;