Struct Pack 

pub struct Pack {
    pub number: usize,
    pub signature: ObjectHash,
    pub objects: Vec<Box<dyn ObjectTrait>>,
    pub pool: Arc<ThreadPool>,
    pub waitlist: Arc<Waitlist>,
    pub caches: Arc<Caches>,
    pub mem_limit: Option<usize>,
    pub cache_objs_mem: Arc<AtomicUsize>,
    pub clean_tmp: bool,
}

Representation of a Git pack file in memory.

Fields

number: usize

signature: ObjectHash

objects: Vec<Box<dyn ObjectTrait>>

pool: Arc<ThreadPool>

waitlist: Arc<Waitlist>

caches: Arc<Caches>

mem_limit: Option<usize>

cache_objs_mem: Arc<AtomicUsize>

clean_tmp: bool

Implementations

impl Pack

pub fn new( thread_num: Option<usize>, mem_limit: Option<usize>, temp_path: Option<PathBuf>, clean_tmp: bool, ) -> Self

Parameters

• thread_num: The number of threads to use for decoding and cache, None means use the number of logical CPUs. The requested value is capped by available parallelism to avoid over-threading in constrained containers. It can’t be zero, or panic
  
• mem_limit: The maximum size of the memory cache in bytes, or None for unlimited. The 80% of it will be used for Caches. Very large limits use the direct in-memory cache path and skip per-object memory backpressure to avoid hot-loop cache accounting.
  ​Not very accurate, because of memory alignment and other reasons, overuse about 15%
  
• temp_path: The path to a directory for temporary files, default is “./.cache_temp”
  For example, thread_num = 4 will use up to 8 threads (4 for decoding and 4 for cache)
  
• clean_tmp: whether to remove temp directory when Pack is dropped

pub fn check_header(pack: &mut impl BufRead) -> Result<(u32, Vec<u8>), GitError>

Checks and reads the header of a Git pack file.

This function reads the first 12 bytes of a pack file, which include the b“PACK“ magic identifier, the version number, and the number of objects in the pack. It verifies that the magic identifier is correct and that the version number is 2 (which is the version currently supported by Git). It also collects these header bytes for later use, such as for hashing the entire pack file.

Parameters

• pack - A mutable reference to an object implementing the Read trait, representing the source of the pack file data (e.g., file, memory stream).

Returns

A Result which is:

• Ok((u32, Vec<u8>)): On successful reading and validation of the header, returns a tuple where:
  • The first element is the number of objects in the pack file (u32).
  • The second element is a vector containing the bytes of the pack file header (Vec<u8>).
• Err(GitError): On failure, returns a GitError with a description of the issue.

Errors

This function can return an error in the following situations:

• If the pack file does not start with the “PACK” magic identifier.
• If the pack file’s version number is not 2.
• If there are any issues reading from the provided pack source.

pub fn decompress_data( pack: &mut (impl BufRead + Send), expected_size: usize, ) -> Result<(Vec<u8>, usize), GitError>

Decompresses data from a given Read and BufRead source using Zlib decompression.

Parameters

• pack: A source that implements both Read and BufRead traits (e.g., file, network stream).
• expected_size: The expected decompressed size of the data.

Returns

Returns a Result containing either:

• A tuple with a Vec<u8> of the decompressed data and the total number of input bytes processed,
• Or a GitError in case of a mismatch in expected size or any other reading error.

pub fn decode_pack_object( pack: &mut (impl BufRead + Send), offset: &mut usize, ) -> Result<Option<CacheObject>, GitError>

Decodes a pack object from a given Read and BufRead source and returns the object as a CacheObject.

Parameters

• pack: A source that implements both Read and BufRead traits.
• offset: A mutable reference to the current offset within the pack.

Returns

Returns a Result containing either:

• A tuple of the next offset in the pack and the original compressed data as Vec<u8>,
• Or a GitError in case of any reading or decompression error.

pub fn decode<F, C>( &mut self, pack: &mut (impl BufRead + Send), callback: F, pack_id_callback: Option<C>, ) -> Result<(), GitError>

where F: Fn(MetaAttached<Entry, EntryMeta>) + Sync + Send + 'static, C: FnOnce(ObjectHash) + Send + 'static,

Decodes a pack file from a given Read and BufRead source, for each object in the pack, it decodes the object and processes it using the provided callback function.

Parameters

• pack_id_callback: A callback that seed pack_file sha1 for updating database

pub fn decode_without_callback<C>( &mut self, pack: &mut (impl BufRead + Send), pack_id_callback: Option<C>, ) -> Result<(), GitError>

where C: FnOnce(ObjectHash) + Send + 'static,

Decodes a pack file without materializing callback entries.

Use this when the caller only needs validation, hashing, and cache/delta reconstruction side effects. This preserves decode for callers that consume each decoded object, while avoiding one full object-data clone per completed object on the no-callback path.

pub fn decode_file<F, C>( &mut self, pack_path: impl AsRef<Path>, callback: F, pack_id_callback: Option<C>, ) -> Result<(), GitError>

where F: Fn(MetaAttached<Entry, EntryMeta>) + Sync + Send + 'static, C: FnOnce(ObjectHash) + Send + 'static,

Decodes a pack file from disk and invokes a callback for each decoded object.

File-backed callers can use this path to reuse the same index-guided retention scan as decode_file_without_callback, while preserving the object metadata and CRC32 values needed by callback consumers such as index generation.

pub fn decode_file_full_without_callback<C>( &mut self, pack_path: impl AsRef<Path>, pack_id_callback: Option<C>, ) -> Result<(), GitError>

where C: FnOnce(ObjectHash) + Send + 'static,

Decodes a pack file from disk without constructing callback entries, while still restoring every object in the pack.

Compared with decode_file, this avoids callback metadata and object-data clones. Compared with decode_file_without_callback, it does not skip leaf objects, so benchmark callers can measure a complete decode without producing per-object output.

pub fn decode_file_without_callback<C>( &mut self, pack_path: impl AsRef<Path>, pack_id_callback: Option<C>, ) -> Result<(), GitError>

where C: FnOnce(ObjectHash) + Send + 'static,

Decodes a pack file from disk without retaining objects after their final delta user.

This is a no-callback fast path for validation/benchmark callers. It performs a light dependency scan first, then releases cache entries as soon as all later delta objects that need them have acquired an Arc to the base.

pub fn decode_async( self, pack: impl BufRead + Send + 'static, sender: UnboundedSender<Entry>, ) -> JoinHandle<Pack>

Decode a Pack in a new thread and send the CacheObjects while decoding.
Attention: It will consume the pack and return in a JoinHandle.

pub async fn decode_stream( self, stream: impl Stream<Item = Result<Bytes, Error>> + Unpin + Send + 'static, sender: UnboundedSender<MetaAttached<Entry, EntryMeta>>, pack_hash_send: Option<UnboundedSender<ObjectHash>>, ) -> Self

Decodes a Pack from a Stream of Bytes, and sends the Entry while decoding.

pub fn rebuild_delta( delta_obj: CacheObject, base_obj: Arc<CacheObject>, ) -> CacheObject

Reconstruct the Delta Object based on the “base object” and return the new object.

pub fn rebuild_zstdelta( delta_obj: CacheObject, base_obj: Arc<CacheObject>, ) -> CacheObject

impl Pack

pub fn stats_pack(path: PathBuf) -> Result<PackStats, GitError>

Scans a pack file and returns statistics about the object types it contains.

This is a lightweight read-only utility that parses the pack header and every object header without fully reconstructing delta chains. It therefore runs much faster than a full Pack::decode call for large packs.

Parameters

• path - Path to the .pack file on disk.

Returns

• Ok(PackStats) – breakdown of object counts by type.
• Err(GitError) – if the file cannot be opened or the pack header is invalid.

Example

use std::path::PathBuf;
use git_internal::internal::pack::{Pack, decode::PackStats};

let stats = Pack::stats_pack(PathBuf::from("repo.pack")).unwrap();
println!("total={}, commits={}, blobs={}", stats.total, stats.commits, stats.blobs);

Trait Implementations

impl Drop for Pack

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.