Method next_section

atomic-core/src/change/format_v3/reader/sections.rs:113–170

Read the next section, decompressing its payload. Returns `None` if all sections have been read. The returned [`ReadSection`] contains the decompressed payload and metadata. The compressed bytes of hashed sections are fed through the blake3 hasher for later verification. # Errors - [`FormatError::InvalidSectionType`] if the section type is unknown. - [`FormatError::Decompress`] if zstd decompr

(&mut self)

    /// }
    /// ```
    pub fn next_section(&mut self) -> FormatResult<Option<ReadSection>> {
        // Ensure we have a peeked header (reads from source if needed)
        if self.peeked.is_none() && self.peek_section_type()?.is_none() {
            return Ok(None);
        }

        let peeked = self.peeked.take().unwrap();

        // Read the compressed payload
        let mut compressed = vec![0u8; peeked.compressed_len as usize];
        self.reader.read_exact(&mut compressed)?;

        // Feed through hasher if this is a hashed section
        if peeked.section_type.is_hashed() {
            self.hasher.update(&peeked.header_bytes);
            self.hasher.update(&compressed);
        }

        // Decompress
        let decompressed = if peeked.compressed_len == 0 {
            Vec::new()
        } else {
            zstd::decode_all(&compressed[..]).map_err(|e| FormatError::Decompress(e.to_string()))?
        };

        // Build content chunk info if applicable
        let content_chunk_info = peeked.chunk_header.map(|ch| ContentChunkInfo {
            chunk_index: ch.chunk_index,
            chunk_hash: ch.chunk_hash,
            uncompressed_len: ch.uncompressed_len,
        });

        // Update stats
        let header_size = peeked.header_bytes.len() as u64;
        self.stats.sections_read += 1;
        self.stats.total_compressed += peeked.compressed_len as u64;
        self.stats.total_decompressed += decompressed.len() as u64;
        self.stats.total_bytes_read += header_size + peeked.compressed_len as u64;
        self.remaining_sections = self.remaining_sections.saturating_sub(1);

        match peeked.section_type {
            SectionType::Graph => self.stats.graph_sections_read += 1,
            SectionType::Semantic => self.stats.semantic_sections_read += 1,
            SectionType::Content => self.stats.content_chunks_read += 1,
            _ => {}
        }

        if self.remaining_sections == 0 {
            self.sections_exhausted = true;
        }

        Ok(Some(ReadSection {
            section_type: peeked.section_type,
            payload: decompressed,
            compressed_size: peeked.compressed_len,
            content_chunk_info,
        }))
    }