Recorder

undoredo

Struct Recorder 

Source 
pub struct Recorder<K, V = (), C = BTreeMap<K, V>, EC = C> { /* private fields */ }
Expand description

Records edits applied to a collection so they can be replayed or reverted.

Implementations§

Source§

impl<K, V, C, EC: Default> Recorder<K, V, C, EC>

Source

pub fn new(collection: C) -> Self

Create a new recorder owning and recording a collection.

Examples found in repository?
examples/cmd_commit.rs (line 15)
14fn main() {
15    let mut recorder: Recorder<usize, char, HashMap<usize, char>> = Recorder::new(HashMap::new());
16    let mut undoredo: UndoRedo<HashMap<usize, char>, Command> = UndoRedo::new();
17
18    recorder.insert(1, 'A');
19
20    // Commit `Command::PushChar` enum variant as command metadata ("cmd") along
21    // with the recorded edit.
22    undoredo.cmd_commit(Command::PushChar, recorder.flush());
23
24    // `Command::PushChar` is now the top element of the stack of done cmd-edits.
25    assert_eq!(undoredo.done().last().unwrap().cmd, Command::PushChar);
26
27    undoredo.undo(&mut recorder);
28
29    // After undo, `Command::PushChar` is now the top element of the stack of
30    // undone cmd-edits.
31    assert_eq!(undoredo.undone().last().unwrap().cmd, Command::PushChar);
32}
More examples
Hide additional examples
examples/btreeset.rs (line 10)
9fn main() {
10    let mut recorder: Recorder<char, (), BTreeSet<char>> = Recorder::new(BTreeSet::new());
11    let mut undoredo: UndoRedo<BTreeSet<char>> = UndoRedo::new();
12
13    recorder.insert('A', ());
14    undoredo.commit(recorder.flush());
15
16    recorder.insert('B', ());
17    // Inserting to a set is idempotent: repeating the same insert does nothing.
18    // It is, however, a logic error if the recorded collection is a multiset,
19    // e.g. `rstar::RTree`.
20    recorder.insert('B', ());
21    undoredo.commit(recorder.flush());
22
23    recorder.insert('C', ());
24    undoredo.commit(recorder.flush());
25
26    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B', 'C']));
27
28    undoredo.undo(&mut recorder);
29    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B']));
30
31    undoredo.undo(&mut recorder);
32    assert_eq!(*recorder.collection(), BTreeSet::from(['A']));
33
34    undoredo.redo(&mut recorder);
35    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B']));
36
37    undoredo.redo(&mut recorder);
38    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B', 'C']));
39}
examples/stable_vec.rs (line 9)
8fn main() {
9    let mut recorder: Recorder<usize, char, StableVec<char>> = Recorder::new(StableVec::new());
10    let mut undoredo: UndoRedo<StableVec<char>> = UndoRedo::new();
11
12    recorder.push('A');
13    undoredo.commit(recorder.flush());
14
15    recorder.push('B');
16    recorder.push('B');
17    undoredo.commit(recorder.flush());
18
19    let key = recorder.push('X');
20    recorder.remove(&key);
21    recorder.push('C');
22    undoredo.commit(recorder.flush());
23
24    assert!(
25        recorder
26            .collection()
27            .values()
28            .copied()
29            .eq(['A', 'B', 'B', 'C'])
30    );
31
32    undoredo.undo(&mut recorder);
33    assert!(recorder.collection().values().copied().eq(['A', 'B', 'B']));
34
35    undoredo.undo(&mut recorder);
36    assert!(recorder.collection().values().copied().eq(['A']));
37
38    undoredo.redo(&mut recorder);
39    assert!(recorder.collection().values().copied().eq(['A', 'B', 'B']));
40
41    undoredo.redo(&mut recorder);
42    assert!(
43        recorder
44            .collection()
45            .values()
46            .copied()
47            .eq(['A', 'B', 'B', 'C'])
48    );
49}
examples/thunderdome.rs (line 9)
8fn main() {
9    let mut recorder: Recorder<Index, char, Arena<char>> = Recorder::new(Arena::new());
10    let mut undoredo: UndoRedo<Arena<char>> = UndoRedo::new();
11
12    recorder.push('A');
13    undoredo.commit(recorder.flush());
14
15    recorder.push('B');
16    recorder.push('B');
17    undoredo.commit(recorder.flush());
18
19    let key = recorder.push('X');
20    recorder.remove(&key);
21    recorder.push('C');
22    undoredo.commit(recorder.flush());
23
24    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
25    assert!(values == vec!['A', 'B', 'B', 'C']);
26
27    undoredo.undo(&mut recorder);
28    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
29    assert!(values == vec!['A', 'B', 'B']);
30
31    undoredo.undo(&mut recorder);
32    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
33    assert!(values == vec!['A']);
34
35    undoredo.redo(&mut recorder);
36    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
37    assert!(values == vec!['A', 'B', 'B']);
38
39    undoredo.redo(&mut recorder);
40    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
41    assert!(values == vec!['A', 'B', 'B', 'C']);
42}
examples/rstar.rs (line 9)
8fn main() {
9    let mut recorder: Recorder<(i32, i32), (), RTree<(i32, i32)>> = Recorder::new(RTree::new());
10    let mut undoredo: UndoRedo<RTree<(i32, i32)>> = UndoRedo::new();
11
12    recorder.insert((1, 1), ());
13    undoredo.commit(recorder.flush());
14
15    recorder.insert((2, 2), ());
16    undoredo.commit(recorder.flush());
17
18    recorder.insert((3, 3), ());
19    undoredo.commit(recorder.flush());
20
21    assert_eq!(
22        recorder.collection().iter().collect::<Vec<_>>(),
23        RTree::bulk_load(vec![(1, 1), (2, 2), (3, 3)])
24            .iter()
25            .collect::<Vec<_>>()
26    );
27
28    undoredo.undo(&mut recorder);
29    assert_eq!(
30        *recorder.collection().iter().collect::<Vec<_>>(),
31        RTree::bulk_load(vec![(1, 1), (2, 2)])
32            .iter()
33            .collect::<Vec<_>>()
34    );
35
36    undoredo.undo(&mut recorder);
37    assert_eq!(
38        *recorder.collection().iter().collect::<Vec<_>>(),
39        RTree::bulk_load(vec![(1, 1)]).iter().collect::<Vec<_>>()
40    );
41
42    undoredo.redo(&mut recorder);
43    assert_eq!(
44        *recorder.collection().iter().collect::<Vec<_>>(),
45        RTree::bulk_load(vec![(1, 1), (2, 2)])
46            .iter()
47            .collect::<Vec<_>>()
48    );
49
50    undoredo.redo(&mut recorder);
51    assert_eq!(
52        *recorder.collection().iter().collect::<Vec<_>>(),
53        RTree::bulk_load(vec![(1, 1), (2, 2), (3, 3)])
54            .iter()
55            .collect::<Vec<_>>()
56    );
57}
examples/basic_usage.rs (line 11)
9fn main() {
10    // The recorder records the ongoing changes to the recorded collection.
11    let mut recorder: Recorder<usize, char, HashMap<usize, char>> = Recorder::new(HashMap::new());
12
13    // The undo-redo struct maintains the undo-redo bistack.
14    let mut undoredo: UndoRedo<HashMap<usize, char>> = UndoRedo::new();
15
16    // Push elements while recording the changes in an edit.
17    recorder.insert(1, 'A');
18    recorder.insert(2, 'B');
19    recorder.insert(3, 'C');
20
21    // Flush the recorder and commit the recorded edit of pushing 'A', 'B', 'C'
22    // into the undo-redo bistack.
23    undoredo.commit(recorder.flush());
24
25    // The pushed elements are now present in the collection.
26    assert!(*recorder.collection() == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
27
28    // Now undo the action.
29    undoredo.undo(&mut recorder);
30
31    // The collection is now empty; the action of pushing elements has been undone.
32    assert!(*recorder.collection() == HashMap::from([]));
33
34    // Now redo the action.
35    undoredo.redo(&mut recorder);
36
37    // The elements are back in the collection; the action has been redone.
38    assert!(*recorder.collection() == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
39
40    // Once you are done recording, you can dissolve the recorder to regain
41    // ownership and mutability over the recorded collection.
42    let (mut hashmap, ..) = recorder.dissolve();
43    assert!(hashmap == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
44}
Additional examples can be found in:
Source

pub fn flush(&mut self) -> Edit<EC>

Flush the recorder, returning the currently recorded edit and replacing it with a new empty one.

Examples found in repository?
examples/cmd_commit.rs (line 22)
14fn main() {
15    let mut recorder: Recorder<usize, char, HashMap<usize, char>> = Recorder::new(HashMap::new());
16    let mut undoredo: UndoRedo<HashMap<usize, char>, Command> = UndoRedo::new();
17
18    recorder.insert(1, 'A');
19
20    // Commit `Command::PushChar` enum variant as command metadata ("cmd") along
21    // with the recorded edit.
22    undoredo.cmd_commit(Command::PushChar, recorder.flush());
23
24    // `Command::PushChar` is now the top element of the stack of done cmd-edits.
25    assert_eq!(undoredo.done().last().unwrap().cmd, Command::PushChar);
26
27    undoredo.undo(&mut recorder);
28
29    // After undo, `Command::PushChar` is now the top element of the stack of
30    // undone cmd-edits.
31    assert_eq!(undoredo.undone().last().unwrap().cmd, Command::PushChar);
32}
More examples
Hide additional examples
examples/btreeset.rs (line 14)
9fn main() {
10    let mut recorder: Recorder<char, (), BTreeSet<char>> = Recorder::new(BTreeSet::new());
11    let mut undoredo: UndoRedo<BTreeSet<char>> = UndoRedo::new();
12
13    recorder.insert('A', ());
14    undoredo.commit(recorder.flush());
15
16    recorder.insert('B', ());
17    // Inserting to a set is idempotent: repeating the same insert does nothing.
18    // It is, however, a logic error if the recorded collection is a multiset,
19    // e.g. `rstar::RTree`.
20    recorder.insert('B', ());
21    undoredo.commit(recorder.flush());
22
23    recorder.insert('C', ());
24    undoredo.commit(recorder.flush());
25
26    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B', 'C']));
27
28    undoredo.undo(&mut recorder);
29    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B']));
30
31    undoredo.undo(&mut recorder);
32    assert_eq!(*recorder.collection(), BTreeSet::from(['A']));
33
34    undoredo.redo(&mut recorder);
35    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B']));
36
37    undoredo.redo(&mut recorder);
38    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B', 'C']));
39}
examples/stable_vec.rs (line 13)
8fn main() {
9    let mut recorder: Recorder<usize, char, StableVec<char>> = Recorder::new(StableVec::new());
10    let mut undoredo: UndoRedo<StableVec<char>> = UndoRedo::new();
11
12    recorder.push('A');
13    undoredo.commit(recorder.flush());
14
15    recorder.push('B');
16    recorder.push('B');
17    undoredo.commit(recorder.flush());
18
19    let key = recorder.push('X');
20    recorder.remove(&key);
21    recorder.push('C');
22    undoredo.commit(recorder.flush());
23
24    assert!(
25        recorder
26            .collection()
27            .values()
28            .copied()
29            .eq(['A', 'B', 'B', 'C'])
30    );
31
32    undoredo.undo(&mut recorder);
33    assert!(recorder.collection().values().copied().eq(['A', 'B', 'B']));
34
35    undoredo.undo(&mut recorder);
36    assert!(recorder.collection().values().copied().eq(['A']));
37
38    undoredo.redo(&mut recorder);
39    assert!(recorder.collection().values().copied().eq(['A', 'B', 'B']));
40
41    undoredo.redo(&mut recorder);
42    assert!(
43        recorder
44            .collection()
45            .values()
46            .copied()
47            .eq(['A', 'B', 'B', 'C'])
48    );
49}
examples/thunderdome.rs (line 13)
8fn main() {
9    let mut recorder: Recorder<Index, char, Arena<char>> = Recorder::new(Arena::new());
10    let mut undoredo: UndoRedo<Arena<char>> = UndoRedo::new();
11
12    recorder.push('A');
13    undoredo.commit(recorder.flush());
14
15    recorder.push('B');
16    recorder.push('B');
17    undoredo.commit(recorder.flush());
18
19    let key = recorder.push('X');
20    recorder.remove(&key);
21    recorder.push('C');
22    undoredo.commit(recorder.flush());
23
24    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
25    assert!(values == vec!['A', 'B', 'B', 'C']);
26
27    undoredo.undo(&mut recorder);
28    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
29    assert!(values == vec!['A', 'B', 'B']);
30
31    undoredo.undo(&mut recorder);
32    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
33    assert!(values == vec!['A']);
34
35    undoredo.redo(&mut recorder);
36    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
37    assert!(values == vec!['A', 'B', 'B']);
38
39    undoredo.redo(&mut recorder);
40    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
41    assert!(values == vec!['A', 'B', 'B', 'C']);
42}
examples/rstar.rs (line 13)
8fn main() {
9    let mut recorder: Recorder<(i32, i32), (), RTree<(i32, i32)>> = Recorder::new(RTree::new());
10    let mut undoredo: UndoRedo<RTree<(i32, i32)>> = UndoRedo::new();
11
12    recorder.insert((1, 1), ());
13    undoredo.commit(recorder.flush());
14
15    recorder.insert((2, 2), ());
16    undoredo.commit(recorder.flush());
17
18    recorder.insert((3, 3), ());
19    undoredo.commit(recorder.flush());
20
21    assert_eq!(
22        recorder.collection().iter().collect::<Vec<_>>(),
23        RTree::bulk_load(vec![(1, 1), (2, 2), (3, 3)])
24            .iter()
25            .collect::<Vec<_>>()
26    );
27
28    undoredo.undo(&mut recorder);
29    assert_eq!(
30        *recorder.collection().iter().collect::<Vec<_>>(),
31        RTree::bulk_load(vec![(1, 1), (2, 2)])
32            .iter()
33            .collect::<Vec<_>>()
34    );
35
36    undoredo.undo(&mut recorder);
37    assert_eq!(
38        *recorder.collection().iter().collect::<Vec<_>>(),
39        RTree::bulk_load(vec![(1, 1)]).iter().collect::<Vec<_>>()
40    );
41
42    undoredo.redo(&mut recorder);
43    assert_eq!(
44        *recorder.collection().iter().collect::<Vec<_>>(),
45        RTree::bulk_load(vec![(1, 1), (2, 2)])
46            .iter()
47            .collect::<Vec<_>>()
48    );
49
50    undoredo.redo(&mut recorder);
51    assert_eq!(
52        *recorder.collection().iter().collect::<Vec<_>>(),
53        RTree::bulk_load(vec![(1, 1), (2, 2), (3, 3)])
54            .iter()
55            .collect::<Vec<_>>()
56    );
57}
examples/basic_usage.rs (line 23)
9fn main() {
10    // The recorder records the ongoing changes to the recorded collection.
11    let mut recorder: Recorder<usize, char, HashMap<usize, char>> = Recorder::new(HashMap::new());
12
13    // The undo-redo struct maintains the undo-redo bistack.
14    let mut undoredo: UndoRedo<HashMap<usize, char>> = UndoRedo::new();
15
16    // Push elements while recording the changes in an edit.
17    recorder.insert(1, 'A');
18    recorder.insert(2, 'B');
19    recorder.insert(3, 'C');
20
21    // Flush the recorder and commit the recorded edit of pushing 'A', 'B', 'C'
22    // into the undo-redo bistack.
23    undoredo.commit(recorder.flush());
24
25    // The pushed elements are now present in the collection.
26    assert!(*recorder.collection() == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
27
28    // Now undo the action.
29    undoredo.undo(&mut recorder);
30
31    // The collection is now empty; the action of pushing elements has been undone.
32    assert!(*recorder.collection() == HashMap::from([]));
33
34    // Now redo the action.
35    undoredo.redo(&mut recorder);
36
37    // The elements are back in the collection; the action has been redone.
38    assert!(*recorder.collection() == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
39
40    // Once you are done recording, you can dissolve the recorder to regain
41    // ownership and mutability over the recorded collection.
42    let (mut hashmap, ..) = recorder.dissolve();
43    assert!(hashmap == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
44}
Additional examples can be found in:
Source§

impl<K, V, C, EC> Recorder<K, V, C, EC>

Source

pub fn with_edit(collection: C, edit: Edit<EC>) -> Self

Create a new recorder owning and recording a collection to an already existing edit.

Source

pub fn collection(&self) -> &C

Returns a reference to the recorded collection.

Examples found in repository?
examples/btreeset.rs (line 26)
9fn main() {
10    let mut recorder: Recorder<char, (), BTreeSet<char>> = Recorder::new(BTreeSet::new());
11    let mut undoredo: UndoRedo<BTreeSet<char>> = UndoRedo::new();
12
13    recorder.insert('A', ());
14    undoredo.commit(recorder.flush());
15
16    recorder.insert('B', ());
17    // Inserting to a set is idempotent: repeating the same insert does nothing.
18    // It is, however, a logic error if the recorded collection is a multiset,
19    // e.g. `rstar::RTree`.
20    recorder.insert('B', ());
21    undoredo.commit(recorder.flush());
22
23    recorder.insert('C', ());
24    undoredo.commit(recorder.flush());
25
26    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B', 'C']));
27
28    undoredo.undo(&mut recorder);
29    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B']));
30
31    undoredo.undo(&mut recorder);
32    assert_eq!(*recorder.collection(), BTreeSet::from(['A']));
33
34    undoredo.redo(&mut recorder);
35    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B']));
36
37    undoredo.redo(&mut recorder);
38    assert_eq!(*recorder.collection(), BTreeSet::from(['A', 'B', 'C']));
39}
More examples
Hide additional examples
examples/stable_vec.rs (line 26)
8fn main() {
9    let mut recorder: Recorder<usize, char, StableVec<char>> = Recorder::new(StableVec::new());
10    let mut undoredo: UndoRedo<StableVec<char>> = UndoRedo::new();
11
12    recorder.push('A');
13    undoredo.commit(recorder.flush());
14
15    recorder.push('B');
16    recorder.push('B');
17    undoredo.commit(recorder.flush());
18
19    let key = recorder.push('X');
20    recorder.remove(&key);
21    recorder.push('C');
22    undoredo.commit(recorder.flush());
23
24    assert!(
25        recorder
26            .collection()
27            .values()
28            .copied()
29            .eq(['A', 'B', 'B', 'C'])
30    );
31
32    undoredo.undo(&mut recorder);
33    assert!(recorder.collection().values().copied().eq(['A', 'B', 'B']));
34
35    undoredo.undo(&mut recorder);
36    assert!(recorder.collection().values().copied().eq(['A']));
37
38    undoredo.redo(&mut recorder);
39    assert!(recorder.collection().values().copied().eq(['A', 'B', 'B']));
40
41    undoredo.redo(&mut recorder);
42    assert!(
43        recorder
44            .collection()
45            .values()
46            .copied()
47            .eq(['A', 'B', 'B', 'C'])
48    );
49}
examples/thunderdome.rs (line 24)
8fn main() {
9    let mut recorder: Recorder<Index, char, Arena<char>> = Recorder::new(Arena::new());
10    let mut undoredo: UndoRedo<Arena<char>> = UndoRedo::new();
11
12    recorder.push('A');
13    undoredo.commit(recorder.flush());
14
15    recorder.push('B');
16    recorder.push('B');
17    undoredo.commit(recorder.flush());
18
19    let key = recorder.push('X');
20    recorder.remove(&key);
21    recorder.push('C');
22    undoredo.commit(recorder.flush());
23
24    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
25    assert!(values == vec!['A', 'B', 'B', 'C']);
26
27    undoredo.undo(&mut recorder);
28    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
29    assert!(values == vec!['A', 'B', 'B']);
30
31    undoredo.undo(&mut recorder);
32    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
33    assert!(values == vec!['A']);
34
35    undoredo.redo(&mut recorder);
36    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
37    assert!(values == vec!['A', 'B', 'B']);
38
39    undoredo.redo(&mut recorder);
40    let (_, values): (Vec<_>, Vec<char>) = recorder.collection().clone().into_iter().unzip();
41    assert!(values == vec!['A', 'B', 'B', 'C']);
42}
examples/rstar.rs (line 22)
8fn main() {
9    let mut recorder: Recorder<(i32, i32), (), RTree<(i32, i32)>> = Recorder::new(RTree::new());
10    let mut undoredo: UndoRedo<RTree<(i32, i32)>> = UndoRedo::new();
11
12    recorder.insert((1, 1), ());
13    undoredo.commit(recorder.flush());
14
15    recorder.insert((2, 2), ());
16    undoredo.commit(recorder.flush());
17
18    recorder.insert((3, 3), ());
19    undoredo.commit(recorder.flush());
20
21    assert_eq!(
22        recorder.collection().iter().collect::<Vec<_>>(),
23        RTree::bulk_load(vec![(1, 1), (2, 2), (3, 3)])
24            .iter()
25            .collect::<Vec<_>>()
26    );
27
28    undoredo.undo(&mut recorder);
29    assert_eq!(
30        *recorder.collection().iter().collect::<Vec<_>>(),
31        RTree::bulk_load(vec![(1, 1), (2, 2)])
32            .iter()
33            .collect::<Vec<_>>()
34    );
35
36    undoredo.undo(&mut recorder);
37    assert_eq!(
38        *recorder.collection().iter().collect::<Vec<_>>(),
39        RTree::bulk_load(vec![(1, 1)]).iter().collect::<Vec<_>>()
40    );
41
42    undoredo.redo(&mut recorder);
43    assert_eq!(
44        *recorder.collection().iter().collect::<Vec<_>>(),
45        RTree::bulk_load(vec![(1, 1), (2, 2)])
46            .iter()
47            .collect::<Vec<_>>()
48    );
49
50    undoredo.redo(&mut recorder);
51    assert_eq!(
52        *recorder.collection().iter().collect::<Vec<_>>(),
53        RTree::bulk_load(vec![(1, 1), (2, 2), (3, 3)])
54            .iter()
55            .collect::<Vec<_>>()
56    );
57}
examples/basic_usage.rs (line 26)
9fn main() {
10    // The recorder records the ongoing changes to the recorded collection.
11    let mut recorder: Recorder<usize, char, HashMap<usize, char>> = Recorder::new(HashMap::new());
12
13    // The undo-redo struct maintains the undo-redo bistack.
14    let mut undoredo: UndoRedo<HashMap<usize, char>> = UndoRedo::new();
15
16    // Push elements while recording the changes in an edit.
17    recorder.insert(1, 'A');
18    recorder.insert(2, 'B');
19    recorder.insert(3, 'C');
20
21    // Flush the recorder and commit the recorded edit of pushing 'A', 'B', 'C'
22    // into the undo-redo bistack.
23    undoredo.commit(recorder.flush());
24
25    // The pushed elements are now present in the collection.
26    assert!(*recorder.collection() == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
27
28    // Now undo the action.
29    undoredo.undo(&mut recorder);
30
31    // The collection is now empty; the action of pushing elements has been undone.
32    assert!(*recorder.collection() == HashMap::from([]));
33
34    // Now redo the action.
35    undoredo.redo(&mut recorder);
36
37    // The elements are back in the collection; the action has been redone.
38    assert!(*recorder.collection() == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
39
40    // Once you are done recording, you can dissolve the recorder to regain
41    // ownership and mutability over the recorded collection.
42    let (mut hashmap, ..) = recorder.dissolve();
43    assert!(hashmap == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
44}
examples/rstared.rs (line 34)
11fn main() {
12    // A hashmap of 2D rectangles will be the underlying collection.
13    let rect_hashmap: HashMap<i32, Rectangle<(i32, i32)>> = HashMap::new();
14    // Wrap `RTreed` around the hashmap and then `Recorder` around it.
15    let mut recorder = Recorder::<
16        i32,
17        Rectangle<(i32, i32)>,
18        RTreed<i32, Rectangle<(i32, i32)>, HashMap<i32, Rectangle<(i32, i32)>>>,
19    >::new(RTreed::new(rect_hashmap));
20    let mut undoredo: UndoRedo<
21        RTreed<i32, Rectangle<(i32, i32)>, HashMap<i32, Rectangle<(i32, i32)>>>,
22    > = UndoRedo::new();
23
24    // Insert two rectangles, recording them in the R-tree.
25    recorder.insert(1, Rectangle::from_corners((0, 0), (1, 1)));
26    undoredo.commit(recorder.flush());
27
28    recorder.insert(2, Rectangle::from_corners((1, 1), (2, 2)));
29    undoredo.commit(recorder.flush());
30
31    // Locate the two rectangles in the R-tree.
32    assert_eq!(
33        recorder
34            .collection()
35            .rtree()
36            .locate_in_envelope(&AABB::from_corners((0, 0), (2, 2)))
37            .count(),
38        2
39    );
40
41    undoredo.undo(&mut recorder);
42
43    // After undo, there is now only one rectangle.
44    assert_eq!(
45        recorder
46            .collection()
47            .rtree()
48            .locate_in_envelope(&AABB::from_corners((0, 0), (2, 2)))
49            .count(),
50        1
51    );
52
53    undoredo.undo(&mut recorder);
54
55    // After another undo, there is no rectangles anymore.
56    assert_eq!(
57        recorder
58            .collection()
59            .rtree()
60            .locate_in_envelope(&AABB::from_corners((0, 0), (2, 2)))
61            .count(),
62        0
63    );
64
65    undoredo.redo(&mut recorder);
66
67    // After redo, we are back to one rectangle.
68    assert_eq!(
69        recorder
70            .collection()
71            .rtree()
72            .locate_in_envelope(&AABB::from_corners((0, 0), (2, 2)))
73            .count(),
74        1
75    );
76
77    undoredo.redo(&mut recorder);
78
79    // After another redo, we are back to two rectangles.
80    assert_eq!(
81        recorder
82            .collection()
83            .rtree()
84            .locate_in_envelope(&AABB::from_corners((0, 0), (2, 2)))
85            .count(),
86        2
87    );
88}
Source

pub fn dissolve(self) -> (C, Edit<EC>)

Dissolve the recorder, returning and ceding ownership of its recorded collection and edit.

Examples found in repository?
examples/basic_usage.rs (line 42)
9fn main() {
10    // The recorder records the ongoing changes to the recorded collection.
11    let mut recorder: Recorder<usize, char, HashMap<usize, char>> = Recorder::new(HashMap::new());
12
13    // The undo-redo struct maintains the undo-redo bistack.
14    let mut undoredo: UndoRedo<HashMap<usize, char>> = UndoRedo::new();
15
16    // Push elements while recording the changes in an edit.
17    recorder.insert(1, 'A');
18    recorder.insert(2, 'B');
19    recorder.insert(3, 'C');
20
21    // Flush the recorder and commit the recorded edit of pushing 'A', 'B', 'C'
22    // into the undo-redo bistack.
23    undoredo.commit(recorder.flush());
24
25    // The pushed elements are now present in the collection.
26    assert!(*recorder.collection() == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
27
28    // Now undo the action.
29    undoredo.undo(&mut recorder);
30
31    // The collection is now empty; the action of pushing elements has been undone.
32    assert!(*recorder.collection() == HashMap::from([]));
33
34    // Now redo the action.
35    undoredo.redo(&mut recorder);
36
37    // The elements are back in the collection; the action has been redone.
38    assert!(*recorder.collection() == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
39
40    // Once you are done recording, you can dissolve the recorder to regain
41    // ownership and mutability over the recorded collection.
42    let (mut hashmap, ..) = recorder.dissolve();
43    assert!(hashmap == HashMap::from([(1, 'A'), (2, 'B'), (3, 'C')]));
44}
Source§

impl<K: Clone, V: Clone, C: Get<K, Item = V> + Insert<K> + Remove<K, Item = V>, EC: Get<K, Item = V> + Insert<K, Item = V> + Remove<K>> Recorder<K, V, C, EC>

Source

pub fn update<F: FnOnce(Option<V>) -> Option<V>>(&mut self, key: K, f: F)

Remove an element, pass it through a closure, then insert it back.

Trait Implementations§

Source§

impl<K, V, C: Default, EC: Default> Default for Recorder<K, V, C, EC>

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl<K, V, C: Get<K, Item = V>, EC> Get<K> for Recorder<K, V, C, EC>

Source§

fn get(&self, key: &K) -> Option<&V>

Returns a reference to the value corresponding to the key.
Source§

impl<K: Clone, V: Clone, C: Get<K, Item = V> + Insert<K>, EC: Get<K, Item = V> + Insert<K>> Insert<K> for Recorder<K, V, C, EC>

Source§

fn insert(&mut self, key: K, value: V)

Insert a key-value pair into the collection.
Source§

impl<K, V, C, EC> Map for Recorder<K, V, C, EC>

Source§

type Item = V

Source§

impl<K: Clone, V: Clone, C: Push<K, Item = V>, EC: Insert<K, Item = V>> Push<K> for Recorder<K, V, C, EC>

Source§

fn push(&mut self, value: V) -> K

Insert a value into the collection without specifying a key, returning the key that was automatically generated.
Source§

impl<K: Clone, V: Clone, C: Remove<K, Item = V>, EC: Insert<K, Item = V> + Remove<K>> Remove<K> for Recorder<K, V, C, EC>

Source§

fn remove(&mut self, key: &K) -> Option<V>

Remove a key from the collection, returning the value at the key if the key was previously in the map.

Auto Trait Implementations§

§

impl<K, V, C, EC> Freeze for Recorder<K, V, C, EC>
where C: Freeze, EC: Freeze,

§

impl<K, V, C, EC> RefUnwindSafe for Recorder<K, V, C, EC>
where C: RefUnwindSafe, EC: RefUnwindSafe, K: RefUnwindSafe, V: RefUnwindSafe,

§

impl<K, V, C, EC> Send for Recorder<K, V, C, EC>
where C: Send, EC: Send, K: Send, V: Send,

§

impl<K, V, C, EC> Sync for Recorder<K, V, C, EC>
where C: Sync, EC: Sync, K: Sync, V: Sync,

§

impl<K, V, C, EC> Unpin for Recorder<K, V, C, EC>
where C: Unpin, EC: Unpin, K: Unpin, V: Unpin,

§

impl<K, V, C, EC> UnwindSafe for Recorder<K, V, C, EC>
where C: UnwindSafe, EC: UnwindSafe, K: UnwindSafe, V: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<K, V, C, EC> ApplyEdit<EC> for C
where K: Clone, V: Clone, C: Insert<K, Item = V> + Remove<K>, EC: Clone + IntoIter<K, Item = V, Key = K> + Keyed,

Source§

fn apply_edit(&mut self, edit: &Edit<EC>)

Apply the changes in an edit to a collection. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.