Struct BlobContent 

pub struct BlobContent {
    pub old: Vec<u8>,
    pub new: Vec<u8>,
}

Owned blob sides loaded from a tree change, ready to borrow in super::diff.

Missing sides become empty buffers. Existence and modes remain on the original TreeChange: an absent side and a present empty blob compare as unchanged content. Symlinks are compared as their stored target bytes, without dereferencing a filesystem path.

Fields

old: Vec<u8>

Original payload, or empty bytes for an addition.

new: Vec<u8>

Replacement payload, or empty bytes for a deletion.

Implementations

impl BlobContent

pub fn read( objects: &Objects, change: &TreeChange, read: ReadLimits, max_bytes: usize, cancel: &AtomicBool, ) -> Result<Self, ContentReadError>

Loads and verifies both blob sides without changing storage.

Accepts regular, executable and symlink modes. Tree/gitlink modes are rejected before any read. Both sides are read even for equal IDs, so dangling or wrong-kind objects cannot be hidden by an identity skip. read bounds each individual read; max_bytes additionally bounds the combined retained payload bytes, constraining decoding before each read. Memory also includes Objects’ pack snapshot and per-read reconstruction workspace.

Storage is synchronous and subject to Objects::read’s trust/pruning assumptions. Cancellation is checked before mode validation, between reads and after the final read; an individual storage read cannot be interrupted. A read error takes precedence over a cancellation observed after it. Callers own scheduling and may borrow the returned buffers for repeated pure comparisons under different binary policies.

Errors

Returns ContentReadError for unsupported modes, missing/wrong-kind objects, storage or decoding failures, or cancellation. Errors retain the offending side’s ID or mode; the caller retains path and side context in change. No partial pair or writes are produced.

use std::sync::atomic::AtomicBool;
use girt::{EntryMode, InitKind, ObjectFormat, Repository, Tree, TreeEntry};
use girt::content_diff::BlobContent;

let directory = tempfile::tempdir()?;
let repo = Repository::init(ObjectFormat::Sha1, directory.path().join("r"), InitKind::Bare)?;

let loose = repo.loose_objects();
let id = loose.write_blob(b"added\n")?;
let tree = loose.write_tree(&Tree::new(ObjectFormat::Sha1,
    vec![TreeEntry { name: b"file".to_vec(), mode: EntryMode::Blob, id }])?)?;

let objects = repo.objects_with(Default::default())?;
let cancel = AtomicBool::new(false);
let changes = objects.compare_trees_with(None, Some(tree), Default::default(), &cancel)?;

let content = BlobContent::read(&objects, &changes[0], Default::default(), 1024, &cancel)?;
assert!(content.old.is_empty());
assert_eq!(content.new, b"added\n");
assert!(changes[0].old.is_none()); // Keep existence independently from the empty content buffer.

Examples found in repository

examples/content_diff.rs (lines 51-57)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let root = tempfile::tempdir()?;
    let repo = Repository::init(
        girt::ObjectFormat::Sha1,
        root.path().join("repo"),
        InitKind::Bare,
    )?;

    let store = repo.loose_objects();
    let old_blob = store.write_blob(b"heading\r\nold\n")?;
    let new_blob = store.write_blob(b"heading\r\nnew\xff")?;

    let old = store.write_tree(&Tree::new(
        girt::ObjectFormat::Sha1,
        vec![TreeEntry {
            name: b"example.txt".to_vec(),
            mode: EntryMode::Blob,
            id: old_blob,
        }],
    )?)?;
    let new = store.write_tree(&Tree::new(
        girt::ObjectFormat::Sha1,
        vec![TreeEntry {
            name: b"example.txt".to_vec(),
            mode: EntryMode::Executable,
            id: new_blob,
        }],
    )?)?;

    let objects = repo.objects()?;
    let cancel = AtomicBool::new(false);
    let limits = DiffLimits::default();

    let changes = objects.compare_trees(Some(old), Some(new))?;
    for change in changes {
        println!(
            "{}: {:?} -> {:?}",
            escaped(&change.path),
            change.old.map(|v| v.mode),
            change.new.map(|v| v.mode)
        );

        // Gitlinks require a submodule policy; the blob adapter deliberately rejects them.
        let content = BlobContent::read(
            &objects,
            &change,
            ReadLimits::default(),
            limits.max_input_bytes,
            &cancel,
        )?;

        match diff(
            &content.old,
            &content.new,
            BinaryMode::Auto,
            limits,
            &cancel,
        )? {
            ContentDiff::Unchanged => println!("  unchanged content (check modes/existence above)"),
            ContentDiff::Binary { old, new } => {
                println!("  binary: {} -> {} bytes", old.len(), new.len())
            }
            ContentDiff::Text(text) => {
                for edit in text.edits() {
                    println!(
                        "  old lines {:?} -> new lines {:?} (zero-based)",
                        edit.old_lines, edit.new_lines
                    );
                    println!("  - {}", escaped(&text.old_bytes()[edit.old_bytes.clone()]));
                    println!("  + {}", escaped(&text.new_bytes()[edit.new_bytes.clone()]));
                }
            }
            _ => return Err("unsupported content diff kind".into()),
        }
    }

    Ok(())
}

Trait Implementations

impl Debug for BlobContent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.