Method copy_content_span

atomic-repository/src/changestore/mod.rs:412–459

Copy a content span from a change without cloning the full `Change`. Graph output calls this for every vertex it materializes. Using `load_change()` here is expensive for imported changes because cache hits clone the entire change, including potentially large unhashed Git metadata. This path copies only the requested bytes.

(
        &self,
        hash: &Hash,
        start: usize,
        end: usize,
        buf: &mut [u8],
    )

    /// hits clone the entire change, including potentially large unhashed Git
    /// metadata. This path copies only the requested bytes.
    pub(crate) fn copy_content_span(
        &self,
        hash: &Hash,
        start: usize,
        end: usize,
        buf: &mut [u8],
    ) -> ChangeStoreResult<usize> {
        // Fast path: shared read lock — multiple threads can read concurrently.
        // peek() doesn't update LRU order, which is an acceptable trade-off
        // to avoid serializing all readers on a write lock.
        if let Ok(cache) = self.cache.read() {
            if let Some(change) = cache.peek(hash) {
                return copy_content_from_change(hash, change, start, end, buf);
            }
        }

        let path = self.change_path(hash);
        log::debug!(
            "Loading change content {} from {}",
            hash.to_base32(),
            path.display()
        );

        if !path.exists() {
            return Err(ChangeStoreError::NotFound {
                hash: hash.to_base32(),
            });
        }

        let file = File::open(&path)?;
        let mut reader = BufReader::new(file);
        let (change, computed_hash) = Change::deserialize(&mut reader)?;

        if computed_hash != *hash {
            return Err(ChangeStoreError::HashMismatch {
                expected: hash.to_base32(),
                computed: computed_hash.to_base32(),
            });
        }

        let copied = copy_content_from_change(hash, &change, start, end, buf)?;

        if let Ok(mut cache) = self.cache.write() {
            cache.insert(*hash, change);
        }

        Ok(copied)
    }

    /// Delete a change from disk and the cache.
    ///