Struct gix_pack::data::File

pub struct File {
    pub id: Id,
    /* private fields */
}

A pack data file

Fields

id: Id

A value to represent this pack uniquely when used with cache lookup, or a way to identify this pack by its location on disk. The same location on disk should yield the same id.

These must be unique per pack and must be stable, that is they don’t change if the pack doesn’t change. If the same id is assigned (or reassigned) to different packs, pack creation or cache access will fail in hard-to-debug ways.

This value is controlled by the owning object store, which can use it in whichever way it wants as long as the above constraints are met.

Implementations

impl File

Instantiation

pub fn at(path: impl AsRef<Path>, object_hash: Kind) -> Result<File, Error>

Try opening a data file at the given path.

The object_hash is a way to read (and write) the same file format with different hashes, as the hash kind isn’t stored within the file format itself.

impl File

Checksums and verify checksums

pub fn checksum(&self) -> ObjectId

The checksum in the trailer of this pack data file

pub fn verify_checksum( &self, progress: &mut dyn Progress, should_interrupt: &AtomicBool, ) -> Result<ObjectId, Error>

Verifies that the checksum of the packfile over all bytes preceding it indeed matches the actual checksum, returning the actual checksum equivalent to the return value of checksum() if there is no mismatch.

Note that if no progress is desired, one can pass gix_features::progress::Discard.

Have a look at index::File::verify_integrity(…) for an even more thorough integrity check.

impl File

Decompression of objects

pub fn decompress_entry( &self, entry: &Entry, inflate: &mut Inflate, out: &mut [u8], ) -> Result<usize, Error>

Decompress the given entry into out and return the amount of bytes read from the pack data. Note that inflate is not reset after usage, but will be reset before using it.

Note that this method does not resolve deltified objects, but merely decompresses their content out is expected to be large enough to hold entry.size bytes.

Panics

If out isn’t large enough to hold the decompressed entry

pub fn entry(&self, offset: Offset) -> Result<Entry, Error>

Obtain the Entry at the given offset into the pack.

The offset is typically obtained from the pack index file.

pub fn decode_entry( &self, entry: Entry, out: &mut Vec<u8>, inflate: &mut Inflate, resolve: &dyn Fn(&oid, &mut Vec<u8>) -> Option<ResolvedBase>, delta_cache: &mut dyn DecodeEntry, ) -> Result<Outcome, Error>

Decode an entry, resolving delta’s as needed, while growing the out vector if there is not enough space to hold the result object.

The entry determines which object to decode, and is commonly obtained with the help of a pack index file or through pack iteration. inflate will be used for decompressing entries, and will not be reset after usage, but before first using it.

resolve is a function to lookup objects with the given ObjectId, in case the full object id is used to refer to a base object, instead of an in-pack offset.

delta_cache is a mechanism to avoid looking up base objects multiple times when decompressing multiple objects in a row. Use a Noop-Cache to disable caching all together at the cost of repeating work.

impl File

Obtain object information quickly.

pub fn decode_header( &self, entry: Entry, inflate: &mut Inflate, resolve: &dyn Fn(&oid) -> Option<ResolvedBase>, ) -> Result<Outcome, Error>

Resolve the object header information starting at entry, following the chain of entries as needed.

The entry determines which object to decode, and is commonly obtained with the help of a pack index file or through pack iteration. inflate will be used for (partially) decompressing entries, and will be reset before first use, but not after the last use.

resolve is a function to lookup objects with the given ObjectId, in case the full object id is used to refer to a base object, instead of an in-pack offset.

impl File

pub fn streaming_iter(&self) -> Result<BytesToEntriesIter<impl BufRead>, Error>

Available on crate feature streaming-input only.

Returns an iterator over Entries, without making use of the memory mapping.

impl File

Information about the pack data file itself

pub fn version(&self) -> Version

The pack data version of this file

pub fn num_objects(&self) -> u32

The number of objects stored in this pack data file

pub fn data_len(&self) -> usize

The length of all mapped data, including the pack header and the pack trailer

pub fn object_hash(&self) -> Kind

The kind of hash we use internally.

pub fn pack_end(&self) -> usize

The position of the byte one past the last pack entry, or in other terms, the first byte of the trailing hash.

pub fn path(&self) -> &Path

The path to the pack data file on disk

pub fn entry_slice(&self, slice: EntryRange) -> Option<&[u8]>

Returns the pack data at the given slice if its range is contained in the mapped pack data

pub fn entry_crc32(&self, pack_offset: Offset, size: usize) -> u32

Returns the CRC32 of the pack data indicated by pack_offset and the size of the mapped data.

Note: finding the right size is only possible by decompressing the pack entry beforehand, or by using the (to be sorted) offsets stored in an index file.

Panics

If pack_offset or size are pointing to a range outside of the mapped pack data.