Method serialize

atomic-core/src/change/change.rs:307–437

Serialize this change to a writer using the V3 format. Writes the complete V3 change file (header, hash table, sections, trailer) to the given writer. The content hash is computed incrementally as sections are written. # Arguments `writer` - Where to write the serialized change # Returns The blake3 content hash of the change (its identity). # Errors Returns an error if serialization, compre

(&self, writer: &mut W)

    ///
    /// Returns an error if serialization, compression, or I/O fails.
    pub fn serialize<W: Write>(&self, writer: &mut W) -> Result<Hash, ChangeError> {
        use format_v3::*;

        // 1. Build the hash dedup table from all referenced hashes
        //    Use a placeholder self-hash (we'll know the real one after finalize)
        let placeholder_hash = [0u8; 32];
        let mut hash_table = HashDedupTable::new(placeholder_hash);

        // Collect all unique hashes from dependencies
        for dep in &self.hashed.dependencies {
            hash_table.insert(*dep.as_bytes())?;
        }
        for dep in &self.hashed.extra_known {
            hash_table.insert(*dep.as_bytes())?;
        }

        // Collect all unique hashes from hunks
        self.collect_hunk_hashes(&mut hash_table)?;

        // 2. Compute section counts
        let has_provenance = !self.hashed.provenance.is_empty();
        let has_unhashed = self.unhashed.is_some();
        let has_content = !self.contents.is_empty();

        // Chunk content with FastCDC for delta transfer + parallel compression
        let content_chunks = if has_content {
            format_v3::chunk_content(&self.contents, &format_v3::ChunkingOptions::default())
        } else {
            Vec::new()
        };

        // For now, we write all hunks in a single GRAPH section (per-file splitting is future work)
        let graph_section_count = if self.hashed.hunks.is_empty() {
            0u32
        } else {
            1
        };
        let semantic_section_count = if self.hashed.file_ops.is_empty() {
            0u32
        } else {
            1
        };
        let contents_chunks_count = content_chunks.len() as u32;

        // 3. Build file header
        let mut file_header_builder = FileHeader::builder()
            .hash_table_entries(hash_table.len() as u32)
            .graph_section_count(graph_section_count)
            .semantic_section_count(semantic_section_count)
            .contents_chunks(contents_chunks_count);

        if has_provenance {
            file_header_builder = file_header_builder.with_provenance();
        }
        if has_unhashed {
            file_header_builder = file_header_builder.with_unhashed();
        }