Struct gix_index::State

pub struct State { /* private fields */ }

An in-memory cache of a fully parsed git index file.

As opposed to a snapshot, it’s meant to be altered and eventually be written back to disk or converted into a tree. We treat index and its state synonymous.

Implementations

impl State

General information and entries

pub fn version(&self) -> Version

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

pub fn timestamp(&self) -> FileTime

Returns time at which the state was created, indicating its freshness compared to other files on disk.

pub fn set_timestamp(&mut self, timestamp: FileTime)

Updates the timestamp of this state, indicating its freshness compared to other files on disk.

Be careful about using this as setting a timestamp without correctly updating the index will cause (file system) race conditions see racy-git.txt in the git documentation for more details.

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) -> &PathStorageRef

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 PathStorageRef ) -> 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: Stage ) -> 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_icase( &self, path: &BStr, stage: Stage, ignore_case: bool ) -> Option<usize>

Find the entry index in entries() matching the given repository-relative path and stage, or None. If ignore_case is true, a case-insensitive (ASCII-folding only) search will be performed.

Note that if there are ambiguities, like x and X being present in the index, any of these will be returned, deterministically.

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: Stage, 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: Stage ) -> Option<&Entry>

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

pub fn entry_by_path_and_stage_icase( &self, path: &BStr, stage: Stage, ignore_case: bool ) -> Option<&Entry>

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

pub fn directory_kind_by_path_icase( &self, path: &BStr, ignore_case: bool ) -> Option<DirectoryKind>

Return the kind of directory that path represents, or None if the path is not a directory, or not tracked in this index in any other way.

Note that we will not match path, like a/b, to a submodule or sparse directory at a, which means that path should be grown one component at a time in order to find the relevant entries.

If ignore_case is true, a case-insensitive (ASCII-folding only) search will be performed.

Deviation

We allow conflicting entries to serve as indicator for an inferred directory, whereas git only looks at stage 0.

pub fn entry_by_path(&self, path: &BStr) -> Option<&Entry>

Return the entry at path that is either at stage 0, or at stage 2 (ours) in case of a merge conflict.

Using this method is more efficient in comparison to doing two searches, one for stage 0 and one for stage 2.

pub fn entry_by_path_icase( &self, path: &BStr, ignore_case: bool ) -> Option<&Entry>

Return the entry at path that is either at stage 0, or at stage 2 (ours) in case of a merge conflict. If ignore_case is true, a case-insensitive (ASCII-folding only) search will be performed.

Using this method is more efficient in comparison to doing two searches, one for stage 0 and one for stage 2.

Note that if there are ambiguities, like x and X being present in the index, any of these will be returned, deterministically.

pub fn prefixed_entries(&self, prefix: &BStr) -> Option<&[Entry]>

Return the slice of entries which all share the same prefix, or None if there isn’t a single such entry.

If prefix is empty, all entries are returned.

pub fn prefixed_entries_range(&self, prefix: &BStr) -> Option<Range<usize>>

Return the range of entries which all share the same prefix, or None if there isn’t a single such entry.

If prefix is empty, the range will include all entries.

pub fn prefixed_entries_range_icase( &self, prefix: &BStr, ignore_case: bool ) -> Option<Range<usize>>

Return the range of entries which all share the same prefix, or None if there isn’t a single such entry. If ignore_case is true, a case-insensitive (ASCII-folding only) search will be performed. Otherwise the search is case-sensitive.

If prefix is empty, the range will include all entries.

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 entry_range(&self, path: &BStr) -> Option<Range<usize>>

Return the range of entries that exactly match the given path, in all available stages, or None if no entry with such path exists.

The range can be used to access the respective entries via entries() or `entries_mut().

impl State

Mutation

pub fn return_path_backing(&mut self, backing: PathStorage)

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_and_pathbacking(&mut self) -> (&mut [Entry], &PathStorageRef)

Return a writable slice to entries and read-access to their path storage at the same time.

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 into_entries(self) -> (Vec<Entry>, PathStorage)

Return all parts that relate to entries, which includes path storage.

This can be useful for obtaining a standalone, boxable iterator

pub fn take_path_backing(&mut self) -> PathStorage

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: Stage ) -> 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(), but applies compare after comparing by path and stage as a third criteria.

pub fn remove_entries( &mut self, should_remove: impl FnMut(usize, &BStr, &mut Entry) -> bool )

Physically remove all entries for which should_remove(idx, path, entry) returns true, traversing them from first to last.

Note that the memory used for the removed entries paths is not freed, as it’s append-only.

Performance

To implement this operation typically, one would rather add entry::Flags::REMOVE to each entry to remove them when writing the index.

impl State

Extensions

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>>

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.

impl State

Initialization

pub fn new(object_hash: Kind) -> Self

Return a new and empty in-memory index assuming the given object_hash.

pub fn from_tree<Find>(tree: &oid, objects: Find) -> Result<Self, Error>

where Find: Find,

Create an index State by traversing tree recursively, accessing sub-trees with objects.

No extension data is currently produced.

impl State

pub fn from_bytes( data: &[u8], timestamp: FileTime, object_hash: Kind, _: Options ) -> Result<(Self, Option<ObjectId>), Error>

Decode an index state from data and store timestamp in the resulting instance for pass-through, assuming object_hash to be used through the file. Also return the stored hash over all bytes in data or None if none was written due to index.skipHash.

impl State

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

Assure our entries are consistent.

pub fn verify_extensions( &self, use_find: bool, objects: impl Find ) -> Result<(), Error>

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

impl State

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

Serialize this instance to out with options.

Trait Implementations

impl Clone for State

fn clone(&self) -> State

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for State

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

Formats the value using the given formatter.

impl From<File> for State

fn from(f: File) -> Self

Converts to this type from the input type.