Struct Diff

pub struct Diff { /* private fields */ }

Represents a series of operations that were performed on a file to transform it into a new version.

The operations are stored in file order, which means that every operation that affects an earlier part of the file must be stored before an operation that affects a later part. The diff also assumes that insert operations are performed prior to delete operations.

Implementations

impl Diff

pub fn new() -> Diff

Creates a new Diff

pub fn inserts(&self) -> Iter<'_, Insert>

Gets an iterator over all insert operations

pub fn deletes(&self) -> Iter<'_, Delete>

Gets an iterator over all delete operations

pub fn is_empty(&self) -> bool

Checks if this set of diffs has any actual content

pub fn apply_to_string(&self, string: &str) -> Result<String, FromUtf8Error>

Applies all of the operations in the diff to the given string. Gives an error if the resulting string can’t be represented by utf8.

Panics

When the operations refer to positions that are not represented by the string.

pub fn apply(&self, file: &mut File) -> Result<()>

Apply the operations in this sequence to a file. This should not be called until after the sequence has been integrated via Engine::integrate_remote The file must have been opened on both read and write mode (see OpenOptions).

pub fn compress_to<W: Write>(&self, writer: &mut W) -> Result<()>

Compress this diff and write to writer. The output can then be expanded back into an equivilent Diff using expand_from()

pub fn expand_from<R: Read>(reader: &mut R) -> Result<Diff>

Expand this diff from previously compressed data in reader. The data in reader should have been written using compress_to()

Trait Implementations

impl Debug for Diff

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

Formats the value using the given formatter.

impl PartialEq for Diff

fn eq(&self, other: &Diff) -> 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 StructuralPartialEq for Diff