Enum EntryBytes 

pub enum EntryBytes {
    Extent {
        offset: u64,
        len: u64,
    },
    Owned(Vec<u8>),
}

Where an entry’s bytes are — an address into the archive, or bytes that exist nowhere else.

Why this is not a Vec<u8>

It was one until 2026-08-14, and that single field is what made a clone hold the whole repository. crate::git_ops::GitStore::emit_set filled it with a pread into a fresh Vec::with_capacity(len) — one syscall, one allocation and one kernel→user copy per object — and every one of those Vecs was live at once, because the entries are all built before emit_pack writes a byte. On a linux.git clone: ~13.8 M syscalls, ~27.6 M allocations, 6.4 GB copied and held, and a peak RSS of 2314 MB against gitea’s 122 MB on the identical clone (gunnar/.nornir/forge-bakeoff-benchmarks.md, vs_forge_clone).

An Extent is 16 bytes and addresses bytes that are already in the page cache. Resolving it is [crate::archive_map::Mapped::get] — pointer arithmetic and a bounds check — with a pread fallback for the one case a mapping cannot answer.

Variants

Extent

The stored entry exactly as received, addressed in the archive’s coordinate space. Header and all: offset is the entry’s type/size varint and len runs to where the next entry starts.

This is what a full clone is made of, end to end. Nothing copies it until emit_pack writes it to the wire.

Fields

offset: u64

len: u64

Owned(Vec<u8>)

The exception: bytes that are on no disk.

Three shapes reach here, and every one of them genuinely computed bytes that no extent addresses:

• a delta whose base the request does not carry, rebuilt whole or re-deltified against a base it does carry ([Self::recompressed] — crate::delta);
• an OFS_DELTA re-headed as a REF_DELTA for a client with no ofs-delta capability, or for a thin fetch — the payload is a copy but the header in front of it is new, so the concatenation is new;
• a fixture built by hand in a test.

It is zero for a whole-repository clone, which is the measurement the extent form exists to make true rather than a promise this makes.

Implementations

impl EntryBytes

pub fn len(&self) -> u64

How many bytes this entry contributes, without resolving it.

Free for an Extent — the length is the address — which is what lets a caller size or account for a pack it has not read.

pub fn is_empty(&self) -> bool

Whether this entry contributes nothing. Only a hand-built fixture can.

pub fn owned(&self) -> Option<&[u8]>

The bytes, when this entry carries them itself. None for an extent, which has to be resolved against the archive.

Trait Implementations

impl Clone for EntryBytes

fn clone(&self) -> EntryBytes

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EntryBytes

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

Formats the value using the given formatter.

impl Eq for EntryBytes

impl PartialEq for EntryBytes

fn eq(&self, other: &EntryBytes) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for EntryBytes