Struct git_chunk::file::Index

pub struct Index { /* private fields */ }

A chunk file providing a table into the parent data.

Implementations

impl Index

pub fn from_bytes(
    data: &[u8],
    toc_offset: usize,
    num_chunks: u32
) -> Result<Self, Error>

Provided a mapped file at the beginning via data, starting at toc_offset decode all chunk information to return an index with num_chunks chunks.

impl Index

pub const ENTRY_SIZE: usize

The size of a single index entry in bytes

pub const EMPTY_SIZE: usize

The smallest possible size of an index, consisting only of the sentinel value pointing past itself.

pub const fn size_for_entries(num_entries: usize) -> usize

Returns the size in bytes an index with num_entries would take.

pub fn offset_by_id(&self, kind: Id) -> Result<Range<Offset>, Error>

Find a chunk of kind and return its offset into the data if found

pub fn usize_offset_by_id(&self, kind: Id) -> Result<Range<usize>, Error>

Find a chunk of kind and return its offset as usize range into the data if found.

Panics

• if the usize conversion fails, which isn’t expected as memory maps can’t be created if files are too large to require such offsets.

pub fn validated_usize_offset_by_id<T>(
    &self,
    kind: Id,
    validate: impl FnOnce(Range<usize>) -> T
) -> Result<T, Error>

Like Index::usize_offset_by_id() but with support for validation and transformation using a function.

pub fn data_by_id<'a>(
    &self,
    data: &'a [u8],
    kind: Id
) -> Result<&'a [u8], Error>

Find a chunk of kind and return its data slice based on its offset.

pub fn highest_offset(&self) -> Offset

Return the end offset lf the last chunk, which is the highest offset as well. It’s definitely available as we have one or more chunks.

impl Index

Writing

pub fn for_writing() -> Self

Create a new index whose sole purpose is to be receiving chunks using plan_chunk() and to be written to an output using into_write()

pub fn plan_chunk(&mut self, chunk: Id, exact_size_on_disk: u64)

Plan to write a new chunk as part of the index when into_write() is called.

pub fn planned_storage_size(&self) -> u64

Return the total size of all planned chunks thus far.

pub fn num_chunks(&self) -> usize

Return the amount of chunks we currently know.

pub fn into_write<W>(self, out: W, current_offset: usize) -> Result<Chunk<W>> where
    W: Write, 

After planning all chunks call this method with the destination to write the chunks to. Use the Chunk writer to write each chunk in order. current_offset is the byte position at which out will continue writing.