Enum Change

pub enum Change<T = (), U = ()> {
    Removed,
    Type {
        worktree_mode: Mode,
    },
    Modification {
        executable_bit_changed: bool,
        content_change: Option<T>,
        set_entry_stat_size_zero: bool,
    },
    SubmoduleModification(U),
}

How an index entry needs to be changed to obtain the destination worktree state, i.e. entry.apply(this_change) == worktree-entry.

Variants

Removed

This corresponding file does not exist in the worktree anymore.

Type

The type of file changed compared to the worktree.

Examples include when a symlink is now a regular file, or a regular file was replaced with a named pipe.

Deviation

A change to a non-file is marked as modification in Git, but that’s related to the content which we can’t evaluate. Hence, a type-change is considered more appropriate.

Fields

worktree_mode: Mode

The mode the worktree file would have if it was added to the index, and the mode that differs compared to what’s currently stored in the index.

Modification

This worktree file was modified in some form, like a permission change or content change or both, as compared to this entry.

Fields

executable_bit_changed: bool

Indicates that one of the stat changes was an executable bit change which is a significant change itself.

content_change: Option<T>

The output of the CompareBlobs run on this entry. If there is no content change and only the executable bit changed then this is None.

set_entry_stat_size_zero: bool

If true, the caller is expected to set entry.stat.size = 0 to assure this otherwise racily clean entry can still be detected as dirty next time this is called, but this time without reading it from disk to hash it. It’s a performance optimization and not doing so won’t change the correctness of the operation.

SubmoduleModification(U)

A submodule is initialized and checked out, and there was modification to either:

• the HEAD as compared to the superproject’s desired commit for HEAD
• the worktree has at least one modified file
• there is at least one untracked file

The exact nature of the modification is handled by the caller which may retain information per submodule or re-compute details as needed when seeing this variant.

Trait Implementations

impl<T: Clone, U: Clone> Clone for Change<T, U>

fn clone(&self) -> Change<T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, U: Debug> Debug for Change<T, U>

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

Formats the value using the given formatter.

impl<T, U> From<Change<T, U>> for EntryStatus<T, U>

fn from(value: Change<T, U>) -> Self

Converts to this type from the input type.

impl<T: Ord, U: Ord> Ord for Change<T, U>

fn cmp(&self, other: &Change<T, U>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq, U: PartialEq> PartialEq for Change<T, U>

fn eq(&self, other: &Change<T, U>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd, U: PartialOrd> PartialOrd for Change<T, U>

fn partial_cmp(&self, other: &Change<T, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq, U: Eq> Eq for Change<T, U>

impl<T, U> StructuralPartialEq for Change<T, U>