Struct git_repository::index::File

pub struct File { /* private fields */ }

An index file whose state was read from a file on disk.

Implementations

impl File

Consumption

pub fn into_parts(self) -> (State, PathBuf)

Take all non-copy parts of the index.

impl File

Access

pub fn path(&self) -> &Path

The path from which the index was read or to which it is supposed to be written when used with File::from_state().

pub fn checksum(&self) -> Option<ObjectId>

The checksum over the file that was read or written to disk, or None if the state in memory was never serialized.

Note that even if Some, it will only represent the state in memory right after reading or writing.

impl File

Mutating access

pub fn set_path(&mut self, path: impl Into<PathBuf>)

Set the path at which we think we are located to the given path.

This is useful to change the location of the index once it is written via write().

impl File

Initialization

pub fn at_or_default(
    path: impl Into<PathBuf>,
    object_hash: Kind,
    options: Options
) -> Result<File, Error>

Try to open the index file at path with options, assuming object_hash is used throughout the file, or create a new index that merely exists in memory and is empty.

Note that the path will not be written if it doesn’t exist.

pub fn at(
    path: impl Into<PathBuf>,
    object_hash: Kind,
    options: Options
) -> Result<File, Error>

Open an index file at path with options, assuming object_hash is used throughout the file.

pub fn from_state(state: State, path: impl Into<PathBuf>) -> File

Consume state and pretend it was read from path, setting our checksum to null.

File instances created like that should be written to disk to set the correct checksum via [File::write()].

impl File

pub fn verify_integrity(&self) -> Result<(), Error>

Verify the integrity of the index to assure its consistency.

impl File

pub fn write_to(
    &self,
    out: impl Write,
    options: Options
) -> Result<(Version, ObjectId), Error>

Write the index to out with options, to be readable by File::at(), returning the version that was actually written to retain all information of this index.

pub fn write(&mut self, options: Options) -> Result<(), Error>

Write ourselves to the path we were read from after acquiring a lock, using options.

Note that the hash produced will be stored which is why we need to be mutable.

Methods from Deref<Target = State>

pub fn version(&self) -> Version

Return the version used to store this state’s information on disk.

pub fn object_hash(&self) -> Kind

Return the kind of hashes used in this instance.

pub fn entries(&self) -> &[Entry]

Return our entries

pub fn path_backing(&self) -> &Vec<u8, Global>

Return our path backing, the place which keeps all paths one after another, with entries storing only the range to access them.

pub fn entries_with_paths_by_filter_map<'a, T>(
    &'a self,
    filter_map: impl FnMut(&'a BStr, &Entry) -> Option<T> + 'a
) -> impl Iterator<Item = (&'a BStr, T)> + 'a

Runs filter_map on all entries, returning an iterator over all paths along with the result of filter_map.

pub fn entries_mut_with_paths_in<'state, 'backing>(
    &'state mut self,
    backing: &'backing Vec<u8, Global>
) -> impl Iterator<Item = (&'state mut Entry, &'backing BStr)>

Return mutable entries along with their path, as obtained from backing.

pub fn entry_index_by_path_and_stage(
    &self,
    path: &BStr,
    stage: u32
) -> Option<usize>

Find the entry index in entries() matching the given repository-relative path and stage, or None.

Use the index for accessing multiple stages if they exists, but at least the single matching entry.

pub fn entry_index_by_path_and_stage_bounded(
    &self,
    path: &BStr,
    stage: u32,
    upper_bound: usize
) -> Option<usize>

Find the entry index in entries()[..upper_bound] matching the given repository-relative path and stage, or None.

Use the index for accessing multiple stages if they exists, but at least the single matching entry.

Panics

If upper_bound is out of bounds of our entries array.

pub fn entry_by_path_and_stage(&self, path: &BStr, stage: u32) -> Option<&Entry>

Like entry_index_by_path_and_stage(), but returns the entry instead of the index.

pub fn entry(&self, idx: usize) -> &Entry

Return the entry at idx or panic if the index is out of bounds.

The idx is typically returned by entry_by_path_and_stage().

pub fn is_sparse(&self) -> bool

Returns a boolean value indicating whether the index is sparse or not.

An index is sparse if it contains at least one Mode::DIR entry.

pub fn return_path_backing(&mut self, backing: Vec<u8, Global>)

After usage of the storage obtained by take_path_backing(), return it here. Note that it must not be empty.

pub fn entries_mut(&mut self) -> &mut [Entry]

Return mutable entries in a slice.

pub fn entries_mut_with_paths(
    &mut self
) -> impl Iterator<Item = (&mut Entry, &BStr)>

Return mutable entries along with their paths in an iterator.

pub fn take_path_backing(&mut self) -> Vec<u8, Global>

Sometimes it’s needed to remove the path backing to allow certain mutation to happen in the state while supporting reading the entry’s path.

pub fn entry_mut_by_path_and_stage(
    &mut self,
    path: &BStr,
    stage: u32
) -> Option<&mut Entry>

Like entry_index_by_path_and_stage(), but returns the mutable entry instead of the index.

pub fn dangerously_push_entry(
    &mut self,
    stat: Stat,
    id: ObjectId,
    flags: Flags,
    mode: Mode,
    path: &BStr
)

Push a new entry containing stat, id, flags and mode and path to the end of our storage, without performing any sanity checks. This means it’s possible to push a new entry to the same path on the same stage and even after sorting the entries lookups may still return the wrong one of them unless the correct binary search criteria is chosen.

Note that this is likely to break invariants that will prevent further lookups by path unless entry_index_by_path_and_stage_bounded() is used with the upper_bound being the amount of entries before the first call to this method.

Alternatively, make sure to call sort_entries() before entry lookup by path to restore the invariant.

pub fn sort_entries(&mut self)

Unconditionally sort entries as needed to perform lookups quickly.

pub fn sort_entries_by(
    &mut self,
    compare: impl FnMut(&Entry, &Entry) -> Ordering
)

Similar to [sort_entries()][State::sort_entries()], but applies compare` after comparing by path and stage as a third criteria.

pub fn tree(&self) -> Option<&Tree>

Access the tree extension.

pub fn link(&self) -> Option<&Link>

Access the link extension.

pub fn resolve_undo(&self) -> Option<&Vec<ResolvePath, Global>>

Obtain the resolve-undo extension.

pub fn untracked(&self) -> Option<&UntrackedCache>

Obtain the untracked extension.

pub fn fs_monitor(&self) -> Option<&FsMonitor>

Obtain the fsmonitor extension.

pub fn verify_entries(&self) -> Result<(), Error>

Assure our entries are consistent.

pub fn verify_extensions<F>(&self, use_find: bool, find: F) -> Result<(), Error>where
    F: for<'a> FnMut(&oid, &'a mut Vec<u8, Global>) -> Option<TreeRefIter<'a>>,

Note: find cannot be Option<F> as we can’t call it with a closure then due to the indirection through Some.

pub fn write_to(&self, out: impl Write, _: Options) -> Result<Version, Error>

Serialize this instance to out with options.

Trait Implementations

impl Clone for File

fn clone(&self) -> File

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for File

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

Formats the value using the given formatter.

impl Deref for File

type Target = State

The resulting type after dereferencing.

fn deref(&self) -> &<File as Deref>::Target

Dereferences the value.

impl DerefMut for File

fn deref_mut(&mut self) -> &mut <File as Deref>::Target

Mutably dereferences the value.

impl From<File> for State

fn from(f: File) -> State

Converts to this type from the input type.