Enum gix::object::tree::diff::change::Event

pub enum Event<'a, 'old, 'new> {
    Addition {
        entry_mode: EntryMode,
        id: Id<'new>,
    },
    Deletion {
        entry_mode: EntryMode,
        id: Id<'old>,
    },
    Modification {
        previous_entry_mode: EntryMode,
        previous_id: Id<'old>,
        entry_mode: EntryMode,
        id: Id<'new>,
    },
    Rewrite {
        source_location: &'a BStr,
        source_entry_mode: EntryMode,
        source_id: Id<'old>,
        diff: Option<DiffLineStats>,
        entry_mode: EntryMode,
        id: Id<'new>,
        copy: bool,
    },
}

An event emitted when finding differences between two trees.

Variants

Addition

Fields

entry_mode: EntryMode

The mode of the added entry.

id: Id<'new>

The object id of the added entry.

An entry was added, like the addition of a file or directory.

Deletion

Fields

entry_mode: EntryMode

The mode of the deleted entry.

id: Id<'old>

The object id of the deleted entry.

An entry was deleted, like the deletion of a file or directory.

Modification

Fields

previous_entry_mode: EntryMode

The mode of the entry before the modification.

previous_id: Id<'old>

The object id of the entry before the modification.

entry_mode: EntryMode

The mode of the entry after the modification.

id: Id<'new>

The object id after the modification.

An entry was modified, e.g. changing the contents of a file adjusts its object id and turning a file into a symbolic link adjusts its mode.

Rewrite

Fields

source_location: &'a BStr

The location of the source of the rename operation.

It may be empty if neither file names nor file paths are tracked.

source_entry_mode: EntryMode

The mode of the entry before the rename.

source_id: Id<'old>

The object id of the entry before the rename.

Note that this is the same as id if we require the similarity to be 100%, but may be different otherwise.

diff: Option<DiffLineStats>

Information about the diff we performed to detect similarity and match the source_id with the current state at id. It’s None if source_id is equal to id, as identity made an actual diff computation unnecessary.

entry_mode: EntryMode

The mode of the entry after the rename. It could differ but still be considered a rename as we are concerned only about content.

id: Id<'new>

The object id after the rename.

copy: bool

If true, this rewrite is created by copy, and source_id is pointing to its source. Otherwise it’s a rename, and source_id points to a deleted object, as renames are tracked as deletions and additions of the same or similar content.

Entries are considered rewritten if they are not trees and they, according to some understanding of identity, were renamed or copied. In case of renames, this means they originally appeared as Deletion signalling their source as well as an Addition acting as destination.

In case of copies, the copy flag is true and typically represents a perfect copy of a source was made.

This variant can only be encountered if rewrite tracking is enabled.

Note that mode changes may have occurred as well, i.e. changes from executable to non-executable or vice-versa.

Implementations

impl<'a, 'old, 'new> Event<'a, 'old, 'new>

pub fn diff(&self) -> Option<Result<Platform<'old, 'new>, Error>>

Produce a platform for performing a line-diff, or None if this is not a Modification or one of the entries to compare is not a blob.

pub fn entry_mode(&self) -> EntryMode

Return the current mode of this instance.

Trait Implementations

impl<'a, 'old, 'new> Clone for Event<'a, 'old, 'new>

fn clone(&self) -> Event<'a, 'old, 'new>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, 'old, 'new> Debug for Event<'a, 'old, 'new>

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

Formats the value using the given formatter.

impl<'a, 'old, 'new> Copy for Event<'a, 'old, 'new>