Struct Diff

pub struct Diff { /* private fields */ }

The serializable representation of a git diff.

A Diff can be retrieved by the following functions:

• crate::Repository::diff
• crate::Repository::diff_commit

Implementations

impl Diff

pub fn files(&self) -> impl Iterator<Item = &FileDiff>

Returns an iterator of the file in the diff.

pub fn into_files(self) -> Vec<FileDiff>

Returns owned files in the diff.

pub fn added(&self) -> impl Iterator<Item = &Added>

Examples found in repository

examples/diff.rs (line 60)

fn print_diff_summary(diff: &Diff, elapsed_nanos: u128) {
    diff.added().for_each(|created| {
        println!("+++ {:?}", created.path);
    });
    diff.deleted().for_each(|deleted| {
        println!("--- {:?}", deleted.path);
    });
    diff.modified().for_each(|modified| {
        println!("mod {:?}", modified.path);
    });

    println!(
        "created {} / deleted {} / modified {} / total {}",
        diff.added().count(),
        diff.deleted().count(),
        diff.modified().count(),
        diff.added().count() + diff.deleted().count() + diff.modified().count()
    );
    println!("diff took {elapsed_nanos} nanos ");
}

pub fn deleted(&self) -> impl Iterator<Item = &Deleted>

Examples found in repository

examples/diff.rs (line 63)

fn print_diff_summary(diff: &Diff, elapsed_nanos: u128) {
    diff.added().for_each(|created| {
        println!("+++ {:?}", created.path);
    });
    diff.deleted().for_each(|deleted| {
        println!("--- {:?}", deleted.path);
    });
    diff.modified().for_each(|modified| {
        println!("mod {:?}", modified.path);
    });

    println!(
        "created {} / deleted {} / modified {} / total {}",
        diff.added().count(),
        diff.deleted().count(),
        diff.modified().count(),
        diff.added().count() + diff.deleted().count() + diff.modified().count()
    );
    println!("diff took {elapsed_nanos} nanos ");
}

pub fn moved(&self) -> impl Iterator<Item = &Moved>

pub fn modified(&self) -> impl Iterator<Item = &Modified>

Examples found in repository

examples/diff.rs (line 66)

fn print_diff_summary(diff: &Diff, elapsed_nanos: u128) {
    diff.added().for_each(|created| {
        println!("+++ {:?}", created.path);
    });
    diff.deleted().for_each(|deleted| {
        println!("--- {:?}", deleted.path);
    });
    diff.modified().for_each(|modified| {
        println!("mod {:?}", modified.path);
    });

    println!(
        "created {} / deleted {} / modified {} / total {}",
        diff.added().count(),
        diff.deleted().count(),
        diff.modified().count(),
        diff.added().count() + diff.deleted().count() + diff.modified().count()
    );
    println!("diff took {elapsed_nanos} nanos ");
}

pub fn copied(&self) -> impl Iterator<Item = &Copied>

pub fn stats(&self) -> &Stats

pub fn insert_modified( &mut self, path: PathBuf, diff: DiffContent, old: DiffFile, new: DiffFile, )

pub fn insert_moved( &mut self, old_path: PathBuf, new_path: PathBuf, old: DiffFile, new: DiffFile, content: DiffContent, )

pub fn insert_copied( &mut self, old_path: PathBuf, new_path: PathBuf, old: DiffFile, new: DiffFile, content: DiffContent, )

pub fn insert_added(&mut self, path: PathBuf, diff: DiffContent, new: DiffFile)

pub fn insert_deleted( &mut self, path: PathBuf, diff: DiffContent, old: DiffFile, )

Trait Implementations

impl Clone for Diff

fn clone(&self) -> Diff

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Diff

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

Formats the value using the given formatter.

impl Default for Diff

fn default() -> Diff

Returns the “default value” for a type.

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 TryFrom<Diff<'_>> for Diff

type Error = Diff

The type returned in the event of a conversion error.

fn try_from(git_diff: Diff<'_>) -> Result<Diff, Self::Error>

Performs the conversion.

impl Eq for Diff

impl StructuralPartialEq for Diff