Struct Diff 

pub struct Diff<'a> { /* private fields */ }

A diff of trees in terms of relative paths.

Implementations

impl<'a> Diff<'a>

pub fn new(old: &'a Path, new: &'a Path) -> Result<Self>

Diff two directory trees.

Paths are compared for equality with blake3, which has good performance characteristics in my testing. In the future, I hope to add pluggable comparators, rename detection, and the ability to produce a text diff of the compared files.

Note that directory entries which appear in both trees are considered to be DiffTag::Replaced, but this does not account for whether or not their contents have changed. A future version of this library may do something more intuitive in this case.

pub fn display(&'a self, opts: DisplayDiffOpts) -> impl Display + 'a

Display this diff with the given options.

Note that Diff already implements Display with default options, but this method is available to enable colored output.

Methods from Deref<Target = IdOrdMap<DiffEntry<'a>>>

pub fn capacity(&self) -> usize

Returns the currently allocated capacity of the map.

Examples

use iddqd::{IdOrdItem, IdOrdMap, id_upcast};

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Item {
    id: String,
    value: u32,
}

impl IdOrdItem for Item {
    type Key<'a> = &'a str;

    fn key(&self) -> Self::Key<'_> {
        &self.id
    }

    id_upcast!();
}

let map: IdOrdMap<Item> = IdOrdMap::with_capacity(10);
assert!(map.capacity() >= 10);

pub fn is_empty(&self) -> bool

Returns true if the map is empty.

Examples

use iddqd::{IdOrdItem, IdOrdMap, id_upcast};

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Item {
    id: String,
    value: u32,
}

impl IdOrdItem for Item {
    type Key<'a> = &'a str;

    fn key(&self) -> Self::Key<'_> {
        &self.id
    }

    id_upcast!();
}

let mut map = IdOrdMap::new();
assert!(map.is_empty());

map.insert_unique(Item { id: "foo".to_string(), value: 42 }).unwrap();
assert!(!map.is_empty());

pub fn len(&self) -> usize

Returns the number of items in the map.

Examples

use iddqd::{IdOrdItem, IdOrdMap, id_upcast};

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Item {
    id: String,
    value: u32,
}

impl IdOrdItem for Item {
    type Key<'a> = &'a str;

    fn key(&self) -> Self::Key<'_> {
        &self.id
    }

    id_upcast!();
}

let mut map = IdOrdMap::new();
assert_eq!(map.len(), 0);

map.insert_unique(Item { id: "foo".to_string(), value: 42 }).unwrap();
map.insert_unique(Item { id: "bar".to_string(), value: 99 }).unwrap();
assert_eq!(map.len(), 2);

pub fn iter(&self) -> Iter<'_, T>

Iterates over the items in the map.

Similar to BTreeMap, the iteration is ordered by T::Key.

Examples

use iddqd::{IdOrdItem, IdOrdMap, id_upcast};

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Item {
    id: String,
    value: u32,
}

impl IdOrdItem for Item {
    type Key<'a> = &'a str;

    fn key(&self) -> Self::Key<'_> {
        &self.id
    }

    id_upcast!();
}

let mut map = IdOrdMap::new();
map.insert_unique(Item { id: "charlie".to_string(), value: 30 }).unwrap();
map.insert_unique(Item { id: "alice".to_string(), value: 42 }).unwrap();
map.insert_unique(Item { id: "bob".to_string(), value: 99 }).unwrap();

// Iteration is ordered by key
let mut iter = map.iter();
let item = iter.next().unwrap();
assert_eq!(item.id, "alice");
let item = iter.next().unwrap();
assert_eq!(item.id, "bob");
let item = iter.next().unwrap();
assert_eq!(item.id, "charlie");
assert!(iter.next().is_none());

pub fn contains_key<'a, Q>(&'a self, key: &Q) -> bool

where Q: Comparable<<T as IdOrdItem>::Key<'a>> + ?Sized,

Returns true if the map contains the given key.

Examples

use iddqd::{IdOrdItem, IdOrdMap, id_upcast};

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Item {
    id: String,
    value: u32,
}

impl IdOrdItem for Item {
    type Key<'a> = &'a str;

    fn key(&self) -> Self::Key<'_> {
        &self.id
    }

    id_upcast!();
}

let mut map = IdOrdMap::new();
map.insert_unique(Item { id: "foo".to_string(), value: 42 }).unwrap();

assert!(map.contains_key("foo"));
assert!(!map.contains_key("bar"));

pub fn get<'a, Q>(&'a self, key: &Q) -> Option<&'a T>

where Q: Comparable<<T as IdOrdItem>::Key<'a>> + ?Sized,

Gets a reference to the value associated with the given key.

Examples

use iddqd::{IdOrdItem, IdOrdMap, id_upcast};

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Item {
    id: String,
    value: u32,
}

impl IdOrdItem for Item {
    type Key<'a> = &'a str;

    fn key(&self) -> Self::Key<'_> {
        &self.id
    }

    id_upcast!();
}

let mut map = IdOrdMap::new();
map.insert_unique(Item { id: "foo".to_string(), value: 42 }).unwrap();

assert_eq!(map.get("foo").unwrap().value, 42);
assert!(map.get("bar").is_none());

Trait Implementations

impl<'a> Debug for Diff<'a>

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

Formats the value using the given formatter.

impl<'a> Deref for Diff<'a>

type Target = IdOrdMap<DiffEntry<'a>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> Display for Diff<'a>

Display the diff with default options (no ANSI colors).

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

Formats the value using the given formatter.

impl<'a> IntoIterator for &'a Diff<'a>

type Item = &'a DiffEntry<'a>

The type of the elements being iterated over.

type IntoIter = Iter<'a, DiffEntry<'a>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for Diff<'a>

type Item = DiffEntry<'a>

The type of the elements being iterated over.

type IntoIter = IntoIter<<Diff<'a> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.