1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use Diff;

/// A "differ" that combines deletions and insertions to give blocks
/// of maximal length, and replacements when appropriate.
pub struct Replace<D:Diff> {
    d: D,
    del: Option<(usize, usize)>,
    ins: Option<(usize, usize, usize)>,
    eq: Option<(usize, usize, usize)>,
}

impl<D:Diff> Replace<D> {
    pub fn new(d: D) -> Self {
        Replace {
            d,
            del: None,
            ins: None,
            eq: None,
        }
    }
}


impl<D:Diff> Diff for Replace<D> {
    fn equal(&mut self, old: usize, new: usize, len: usize) {
        if let Some((old0, len0)) = self.del.take() {
            if let Some((_, new1, new_len1)) = self.ins.take() {
                self.d.replace(old0, len0, new1, new_len1)
            } else {
                self.d.delete(old0, len0);
            }
        } else if let Some((old0, new0, new_len0)) = self.ins.take() {
            self.d.insert(old0, new0, new_len0);
        }

        if let Some((a, b, c)) = self.eq.take() {
            self.eq = Some((a, b, c + len))
        } else {
            self.eq = Some((old, new, len))
        }
    }
    fn delete(&mut self, old: usize, len: usize) {
        if let Some((a, b, c)) = self.eq.take() {
            self.d.equal(a, b, c)
        }
        if let Some((old0, len0)) = self.del.take() {
            assert_eq!(old, old0 + len0);
            self.del = Some((old0, len0+len))
        } else {
            self.del = Some((old, len))
        }
    }

    fn insert(&mut self, old: usize, new: usize, new_len: usize) {
        if let Some((a, b, c)) = self.eq.take() {
            self.d.equal(a, b, c)
        }
        if let Some((old1, new1, new_len1)) = self.ins.take() {
            assert_eq!(new1+new_len1, new);
            self.ins = Some((old1, new1, new_len + new_len1))
        } else {
            self.ins = Some((old, new, new_len))
        }
    }

    fn replace(&mut self, old: usize, old_len: usize, new: usize, new_len: usize) {
        if let Some((a, b, c)) = self.eq.take() {
            self.d.equal(a, b, c)
        }
        self.d.replace(old, old_len, new, new_len)
    }

    fn finish(&mut self) {
        if let Some((old0, len0)) = self.del.take() {
            if let Some((_, new1, new_len1)) = self.ins.take() {
                self.d.replace(old0, len0, new1, new_len1)
            } else {
                self.d.delete(old0, len0);
            }
        } else if let Some((old0, new0, new_len0)) = self.ins.take() {
            self.d.insert(old0, new0, new_len0);
        }
        self.d.finish();
    }
}