Enum DiffCommand 

pub(crate) enum DiffCommand<'a> {
    Delete {
        low: usize,
        high: usize,
    },
    DeleteToEnd {
        low: usize,
    },
    Replace {
        low: usize,
        high: usize,
        lines: Vec<&'a str>,
    },
    Insert {
        pos: usize,
        lines: Vec<&'a str>,
    },
}

A command that can appear in a diff. Each command tells us to remove zero or more lines, and insert zero or more lines in their place.

Commands refer to lines by 1-indexed line number.

Variants

Delete

Remove the lines from low through high, inclusive.

Fields

low: usize

The first line to remove

high: usize

The last line to remove

DeleteToEnd

Remove the lines from low through the end of the file, inclusive.

Fields

low: usize

The first line to remove

Replace

Replace the lines from low through high, inclusive, with the lines in ‘lines’.

Fields

low: usize

The first line to replace

high: usize

The last line to replace

lines: Vec<&'a str>

The text to insert instead

Insert

Insert the provided ‘lines’ after the line with index ‘pos’.

Fields

pos: usize

The position after which to insert the text

lines: Vec<&'a str>

The text to insert

Implementations

impl<'a> DiffCommand<'a>

pub(crate) fn apply_to(&self, target: &mut DiffResult<'a>) -> Result<(), Error>

Transform ‘target’ according to the this command.

Because DiffResult internally uses a vector of line, this implementation is potentially O(n) in the size of the input.

pub(crate) fn apply_transformation( &self, input: &mut DiffResult<'a>, output: &mut DiffResult<'a>, ) -> Result<(), Error>

Apply this command to ‘input’, moving lines into ‘output’.

This is a more efficient algorithm, but it requires that the diff commands are sorted in reverse order by line number. (Fortunately, the Tor ed diff format guarantees this.)

Before calling this method, input and output must contain the results of having applied the previous command in the diff. (When no commands have been applied, input starts out as the original text, and output starts out empty.)

This method applies the command by copying unaffected lines from the end of input into output, adding any lines inserted by this command, and finally deleting any affected lines from input.

We build the output value in reverse order, and then put it back to normal before giving it to the user.

pub(crate) fn lines(&self) -> Option<&[&'a str]>

Return the lines that we should add to the output

pub(crate) fn linebuf_mut(&mut self) -> Option<&mut Vec<&'a str>>

Return a mutable reference to the vector of lines we should add to the output.

pub(crate) fn following_lines(&self) -> Option<usize>

Return the (1-indexed) line number of the first line in the input that comes after this command, and is not affected by it.

We use this line number to know which lines we should copy.

pub(crate) fn first_removed_line(&self) -> usize

Return the (1-indexed) line number of the first line that we should clear from the input when processing this command.

This can be the same as following_lines(), if we shouldn’t actually remove any lines.

pub(crate) fn is_insert(&self) -> bool

Return true if this is an Insert command.

pub(crate) fn from_line_iterator<I>(iter: &mut I) -> Result<Option<Self>, Error>

where I: Iterator<Item = &'a str>,

Extract a single command from a line iterator that yields lines of the diffs. Return None if we’re at the end of the iterator.

Trait Implementations

impl<'a> Clone for DiffCommand<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for DiffCommand<'a>

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

Formats the value using the given formatter.