similar/algorithms/
hook.rs

Help
1/// A trait for reacting to an edit script from the "old" version to
2/// the "new" version.
3pub trait DiffHook: Sized {
4    /// The error produced from the hook methods.
5    type Error;
6
7    /// Called when lines with indices `old_index` (in the old version) and
8    /// `new_index` (in the new version) start an section equal in both
9    /// versions, of length `len`.
10    fn equal(&mut self, old_index: usize, new_index: usize, len: usize) -> Result<(), Self::Error> {
11        let _ = old_index;
12        let _ = new_index;
13        let _ = len;
14        Ok(())
15    }
16
17    /// Called when a section of length `old_len`, starting at `old_index`,
18    /// needs to be deleted from the old version.
19    fn delete(
20        &mut self,
21        old_index: usize,
22        old_len: usize,
23        new_index: usize,
24    ) -> Result<(), Self::Error> {
25        let _ = old_index;
26        let _ = old_len;
27        let _ = new_index;
28        Ok(())
29    }
30
31    /// Called when a section of the new version, of length `new_len`
32    /// and starting at `new_index`, needs to be inserted at position `old_index'.
33    fn insert(
34        &mut self,
35        old_index: usize,
36        new_index: usize,
37        new_len: usize,
38    ) -> Result<(), Self::Error> {
39        let _ = old_index;
40        let _ = new_index;
41        let _ = new_len;
42        Ok(())
43    }
44
45    /// Called when a section of the old version, starting at index
46    /// `old_index` and of length `old_len`, needs to be replaced with a
47    /// section of length `new_len`, starting at `new_index`, of the new
48    /// version.
49    ///
50    /// The default implementations invokes `delete` and `insert`.
51    ///
52    /// You can use the [`Replace`](crate::algorithms::Replace) hook to
53    /// automatically generate these.
54    #[inline(always)]
55    fn replace(
56        &mut self,
57        old_index: usize,
58        old_len: usize,
59        new_index: usize,
60        new_len: usize,
61    ) -> Result<(), Self::Error> {
62        self.delete(old_index, old_len, new_index)?;
63        self.insert(old_index, new_index, new_len)
64    }
65
66    /// Always called at the end of the algorithm.
67    #[inline(always)]
68    fn finish(&mut self) -> Result<(), Self::Error> {
69        Ok(())
70    }
71}
72
73impl<'a, D: DiffHook + 'a> DiffHook for &'a mut D {
74    type Error = D::Error;
75
76    #[inline(always)]
77    fn equal(&mut self, old_index: usize, new_index: usize, len: usize) -> Result<(), Self::Error> {
78        (*self).equal(old_index, new_index, len)
79    }
80
81    #[inline(always)]
82    fn delete(
83        &mut self,
84        old_index: usize,
85        old_len: usize,
86        new_index: usize,
87    ) -> Result<(), Self::Error> {
88        (*self).delete(old_index, old_len, new_index)
89    }
90
91    #[inline(always)]
92    fn insert(
93        &mut self,
94        old_index: usize,
95        new_index: usize,
96        new_len: usize,
97    ) -> Result<(), Self::Error> {
98        (*self).insert(old_index, new_index, new_len)
99    }
100
101    #[inline(always)]
102    fn replace(
103        &mut self,
104        old: usize,
105        old_len: usize,
106        new: usize,
107        new_len: usize,
108    ) -> Result<(), Self::Error> {
109        (*self).replace(old, old_len, new, new_len)
110    }
111
112    #[inline(always)]
113    fn finish(&mut self) -> Result<(), Self::Error> {
114        (*self).finish()
115    }
116}
117
118/// Wrapper [`DiffHook`] that prevents calls to [`DiffHook::finish`].
119///
120/// This hook is useful in situations where diff hooks are composed but you
121/// want to prevent that the finish hook method is called.
122pub struct NoFinishHook<D: DiffHook>(D);
123
124impl<D: DiffHook> NoFinishHook<D> {
125    /// Wraps another hook.
126    pub fn new(d: D) -> NoFinishHook<D> {
127        NoFinishHook(d)
128    }
129
130    /// Extracts the inner hook.
131    pub fn into_inner(self) -> D {
132        self.0
133    }
134}
135
136impl<D: DiffHook> DiffHook for NoFinishHook<D> {
137    type Error = D::Error;
138
139    #[inline(always)]
140    fn equal(&mut self, old_index: usize, new_index: usize, len: usize) -> Result<(), Self::Error> {
141        self.0.equal(old_index, new_index, len)
142    }
143
144    #[inline(always)]
145    fn delete(
146        &mut self,
147        old_index: usize,
148        old_len: usize,
149        new_index: usize,
150    ) -> Result<(), Self::Error> {
151        self.0.delete(old_index, old_len, new_index)
152    }
153
154    #[inline(always)]
155    fn insert(
156        &mut self,
157        old_index: usize,
158        new_index: usize,
159        new_len: usize,
160    ) -> Result<(), Self::Error> {
161        self.0.insert(old_index, new_index, new_len)
162    }
163
164    #[inline(always)]
165    fn replace(
166        &mut self,
167        old_index: usize,
168        old_len: usize,
169        new_index: usize,
170        new_len: usize,
171    ) -> Result<(), Self::Error> {
172        self.0.replace(old_index, old_len, new_index, new_len)
173    }
174
175    fn finish(&mut self) -> Result<(), Self::Error> {
176        Ok(())
177    }
178}
similar/algorithms/hook.rs

similar/algorithms/
hook.rs
