Struct WorkingCopySnapshot

pub struct WorkingCopySnapshot<'repo> {
    pub base_commit: Commit<'repo>,
    pub head_commit: Option<Commit<'repo>>,
    pub head_reference_name: Option<ReferenceName>,
    pub commit_unstaged: Commit<'repo>,
    pub commit_stage0: Commit<'repo>,
    pub commit_stage1: Commit<'repo>,
    pub commit_stage2: Commit<'repo>,
    pub commit_stage3: Commit<'repo>,
}

A special Commit which represents the status of the working copy at a given point in time. This means that it can include changes in any stage.

Fields

base_commit: Commit<'repo>

The commit which contains the metadata about the HEAD commit and all the “stage commits” included in this snapshot.

The stage commits each correspond to one of the possible stages in the index. If a file is not present in that stage, it’s assumed that it’s unchanged from the HEAD commit at the time which the snapshot was taken.

The metadata is stored in the commit message.

head_commit: Option<Commit<'repo>>

The commit that was checked out at the time of this snapshot. It’s possible that no commit was checked out (called an “unborn HEAD”). This could happen when the repository has been freshly initialized, but no commits have yet been made.

head_reference_name: Option<ReferenceName>

The branch that was checked out at the time of this snapshot, if any. This includes the refs/heads/ prefix.

commit_unstaged: Commit<'repo>

The unstaged changes in the working copy.

commit_stage0: Commit<'repo>

The index contents at stage 0 (normal staged changes).

commit_stage1: Commit<'repo>

The index contents at stage 1. For a merge conflict, this corresponds to the contents of the file at the common ancestor of the merged commits.

commit_stage2: Commit<'repo>

The index contents at stage 2 (“ours”).

commit_stage3: Commit<'repo>

The index contents at stage 3 (“theirs”, i.e. the commit being merged in).

Implementations

impl<'repo> WorkingCopySnapshot<'repo>

pub fn try_from_base_commit<'a>( repo: &'repo Repo, base_commit: &'a Commit<'repo>, ) -> Result<Option<WorkingCopySnapshot<'repo>>>

Attempt to load the provided commit as if it were the base commit for a WorkingCopySnapshot. Returns None if it was not.

pub fn get_working_copy_changes_type(&self) -> Result<WorkingCopyChangesType>

Determine what kind of changes to the working copy the user made in this snapshot.

Trait Implementations

impl<'repo> Clone for WorkingCopySnapshot<'repo>

fn clone(&self) -> WorkingCopySnapshot<'repo>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'repo> Debug for WorkingCopySnapshot<'repo>

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

Formats the value using the given formatter.