Struct git_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 entries(&self) -> &[Entry]

Return our entries

pub fn path_backing(&self) -> &PathStorage

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

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 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_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(&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 entries_mut_with_paths_in<'state, 'backing>(
    &'state mut self,
    backing: &'backing PathStorage
) -> 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_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(&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().

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 from_tree<Find>(tree: &oid, find: Find) -> Result<Self, Error>where
    Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<TreeRefIter<'a>>,

Takes in an oid of a tree object and creates and returns a State from its children.

impl State

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

Decode an index state from data and store timestamp in the resulting instance for pass-through.

impl State

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

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.