pub struct State { /* private fields */ }
Expand description
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.
§A note on safety
An index (i.e. State
) created by hand is not guaranteed to have valid entry paths as they are entirely controlled
by the caller, without applying any level of validation.
This means that before using these paths to recreate files on disk, they must be validated.
It’s notable that it’s possible to manufacture tree objects which contain names like .git/hooks/pre-commit
which then will look like .git/hooks/pre-commit
in the index, which doesn’t care that the name came from a single
tree instead of from trees named .git
, hooks
and a blob named pre-commit
. The effect is still the same - an invalid
path is presented in the index and its consumer must validate each path component before usage.
It’s recommended to do that using gix_worktree::Stack
which has it built-in if it’s created for_checkout()
. Alternatively
one can validate component names with gix_validate::path::component()
.
Implementations§
source§impl State
impl State
General information and entries
sourcepub fn version(&self) -> Version
pub fn version(&self) -> Version
Return the version used to store this state’s information on disk.
sourcepub fn timestamp(&self) -> FileTime
pub fn timestamp(&self) -> FileTime
Returns time at which the state was created, indicating its freshness compared to other files on disk.
sourcepub fn set_timestamp(&mut self, timestamp: FileTime)
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.
sourcepub fn object_hash(&self) -> Kind
pub fn object_hash(&self) -> Kind
Return the kind of hashes used in this instance.
sourcepub fn path_backing(&self) -> &PathStorageRef
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.
sourcepub 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
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
.
sourcepub fn entries_mut_with_paths_in<'state, 'backing>(
&'state mut self,
backing: &'backing PathStorageRef,
) -> impl Iterator<Item = (&'state mut Entry, &'backing BStr)>
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
.
sourcepub fn entry_index_by_path_and_stage(
&self,
path: &BStr,
stage: Stage,
) -> Option<usize>
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.
sourcepub fn prepare_icase_backing(&self) -> AccelerateLookup<'_>
pub fn prepare_icase_backing(&self) -> AccelerateLookup<'_>
Return a data structure to help with case-insensitive lookups.
It’s required perform any case-insensitive lookup. TODO: needs multi-threaded insertion, raw-table to have multiple locks depending on bucket.
sourcepub fn entry_by_path_icase<'a>(
&'a self,
path: &BStr,
ignore_case: bool,
lookup: &AccelerateLookup<'a>,
) -> Option<&'a Entry>
pub fn entry_by_path_icase<'a>( &'a self, path: &BStr, ignore_case: bool, lookup: &AccelerateLookup<'a>, ) -> Option<&'a Entry>
Return the entry at path
that is at the lowest available stage, using lookup
for acceleration.
It must have been created from this instance, and was ideally kept up-to-date with it.
If ignore_case
is true
, a case-insensitive (ASCII-folding only) search will be performed.
sourcepub fn entry_closest_to_directory_icase<'a>(
&'a self,
directory: &BStr,
ignore_case: bool,
lookup: &AccelerateLookup<'a>,
) -> Option<&Entry>
pub fn entry_closest_to_directory_icase<'a>( &'a self, directory: &BStr, ignore_case: bool, lookup: &AccelerateLookup<'a>, ) -> Option<&Entry>
Return the entry (at any stage) that is inside of directory
, or None
,
using lookup
for acceleration.
Note that submodules are not detected as directories and the user should
make another call to entry_by_path_icase()
to check for this
possibility. Doing so might also reveal a sparse directory.
If ignore_case
is set
sourcepub fn entry_closest_to_directory(&self, directory: &BStr) -> Option<&Entry>
pub fn entry_closest_to_directory(&self, directory: &BStr) -> Option<&Entry>
Return the entry (at any stage) that is inside of directory
, or None
.
Note that submodules are not detected as directories and the user should
make another call to entry_by_path_icase()
to check for this
possibility. Doing so might also reveal a sparse directory.
Note that this is a case-sensitive search.
sourcepub fn entry_index_by_path_and_stage_bounded(
&self,
path: &BStr,
stage: Stage,
upper_bound: usize,
) -> Option<usize>
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.
sourcepub fn entry_by_path_and_stage(
&self,
path: &BStr,
stage: Stage,
) -> Option<&Entry>
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.
sourcepub fn entry_by_path(&self, path: &BStr) -> Option<&Entry>
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.
sourcepub fn entry_index_by_path(&self, path: &BStr) -> Result<usize, usize>
pub fn entry_index_by_path(&self, path: &BStr) -> Result<usize, usize>
Return the index at Ok(index)
where the entry matching path
(in any stage) can be found, or return
Err(index)
to indicate the insertion position at which an entry with path
would fit in.
sourcepub fn prefixed_entries(&self, prefix: &BStr) -> Option<&[Entry]>
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.
sourcepub fn prefixed_entries_range(&self, prefix: &BStr) -> Option<Range<usize>>
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.
sourcepub fn entry(&self, idx: usize) -> &Entry
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()
.
sourcepub fn is_sparse(&self) -> bool
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.
sourcepub fn entry_range(&self, path: &BStr) -> Option<Range<usize>>
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().
source§impl State
impl State
Mutation
sourcepub fn return_path_backing(&mut self, backing: PathStorage)
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.
sourcepub fn entries_mut(&mut self) -> &mut [Entry]
pub fn entries_mut(&mut self) -> &mut [Entry]
Return mutable entries in a slice.
sourcepub fn entries_mut_and_pathbacking(&mut self) -> (&mut [Entry], &PathStorageRef)
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.
sourcepub fn entries_mut_with_paths(
&mut self,
) -> impl Iterator<Item = (&mut Entry, &BStr)>
pub fn entries_mut_with_paths( &mut self, ) -> impl Iterator<Item = (&mut Entry, &BStr)>
Return mutable entries along with their paths in an iterator.
sourcepub fn into_entries(self) -> (Vec<Entry>, PathStorage)
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
sourcepub fn take_path_backing(&mut self) -> PathStorage
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.
sourcepub fn entry_mut_by_path_and_stage(
&mut self,
path: &BStr,
stage: Stage,
) -> Option<&mut Entry>
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.
sourcepub fn dangerously_push_entry(
&mut self,
stat: Stat,
id: ObjectId,
flags: Flags,
mode: Mode,
path: &BStr,
)
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.
sourcepub fn sort_entries(&mut self)
pub fn sort_entries(&mut self)
Unconditionally sort entries as needed to perform lookups quickly.
sourcepub fn sort_entries_by(
&mut self,
compare: impl FnMut(&Entry, &Entry) -> Ordering,
)
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.
sourcepub fn remove_entries(
&mut self,
should_remove: impl FnMut(usize, &BStr, &mut Entry) -> bool,
)
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.
source§impl State
impl State
Extensions
sourcepub fn resolve_undo(&self) -> Option<&Vec<ResolvePath>>
pub fn resolve_undo(&self) -> Option<&Vec<ResolvePath>>
Obtain the resolve-undo extension.
sourcepub fn untracked(&self) -> Option<&UntrackedCache>
pub fn untracked(&self) -> Option<&UntrackedCache>
Obtain the untracked extension.
sourcepub fn fs_monitor(&self) -> Option<&FsMonitor>
pub fn fs_monitor(&self) -> Option<&FsMonitor>
Obtain the fsmonitor extension.
sourcepub fn had_end_of_index_marker(&self) -> bool
pub fn had_end_of_index_marker(&self) -> bool
Return true
if the end-of-index extension was present when decoding this index.
sourcepub fn had_offset_table(&self) -> bool
pub fn had_offset_table(&self) -> bool
Return true
if the offset-table extension was present when decoding this index.
source§impl State
impl State
Initialization
sourcepub fn new(object_hash: Kind) -> Self
pub fn new(object_hash: Kind) -> Self
Return a new and empty in-memory index assuming the given object_hash
.
sourcepub fn from_tree<Find>(
tree: &oid,
objects: Find,
validate: Options,
) -> Result<Self, Error>where
Find: Find,
pub fn from_tree<Find>(
tree: &oid,
objects: Find,
validate: Options,
) -> Result<Self, Error>where
Find: Find,
Create an index State
by traversing tree
recursively, accessing sub-trees
with objects
.
validate
is used to determine which validations to perform on every path component we see.
No extension data is currently produced.
source§impl State
impl State
sourcepub fn from_bytes(
data: &[u8],
timestamp: FileTime,
object_hash: Kind,
_options: Options,
) -> Result<(Self, Option<ObjectId>), Error>
pub fn from_bytes( data: &[u8], timestamp: FileTime, object_hash: Kind, _options: 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
.
Trait Implementations§
Auto Trait Implementations§
impl Freeze for State
impl RefUnwindSafe for State
impl Send for State
impl Sync for State
impl Unpin for State
impl UnwindSafe for State
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)