Enum gix_diff::blob::platform::prepare_diff::Operation

pub enum Operation<'a> {
    InternalDiff {
        algorithm: Algorithm,
    },
    ExternalCommand {
        command: &'a BStr,
    },
    SourceOrDestinationIsBinary,
}

Available on crate feature blob only.

The kind of operation that was performed during the diff operation.

Variants

InternalDiff

The internal diff algorithm should be called with the provided arguments. This only happens if none of the resources are binary, and if there is no external diff program configured via git-attributes or Options::skip_internal_diff_if_external_is_configured is false.

Use Outcome::interned_input() to easily obtain an interner for use with imara_diff::diff(), or maintain one yourself for greater reuse.

Fields

algorithm: Algorithm

The algorithm we determined should be used, which is one of (in order, first set one wins):

• the driver’s override
• the platforms own configuration (typically from git-config)
• the default algorithm

ExternalCommand

Run the external diff program according as configured in the source-resources driver. This only happens if Options::skip_internal_diff_if_external_is_configured was true, preventing the usage of the internal diff implementation.

Fields

command: &'a BStr

The command as extracted from Driver::command. Use it in Platform::prepare_diff_command to easily prepare a compatible invocation.

SourceOrDestinationIsBinary

One of the involved resources, old or new, were binary and thus no diff cannot be performed.

Trait Implementations

impl<'a> Clone for Operation<'a>

fn clone(&self) -> Operation<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Operation<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Operation<'a>

fn eq(&self, other: &Operation<'a>) -> 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<'a> Copy for Operation<'a>

impl<'a> Eq for Operation<'a>

impl<'a> StructuralPartialEq for Operation<'a>