[−][src]Crate redo
Provides undo-redo functionality with static dispatch and manual command merging.
It is an implementation of the command pattern, where all modifications are done by creating objects of commands that applies the modifications. All commands knows how to undo the changes it applies, and by using the provided data structures it is easy to apply, undo, and redo changes made to a target. Both linear and non-linear undo-redo functionality is provided through the Record and History data structures.
Contents
- Command provides the base functionality for all commands.
- Record provides linear undo-redo functionality.
- History provides non-linear undo-redo functionality that allows you to jump between different branches.
- Queue wraps a Record or History and extends them with queue functionality.
- Checkpoint wraps a Record or History and extends them with checkpoint functionality.
- Configurable display formatting is provided when the
display
feature is enabled. - Time stamps and time travel is provided when the
chrono
feature is enabled. - Serialization and deserialization is provided when the
serde
feature is enabled. - The library can be used as
no_std
by default.
Concepts
- Commands can be merged into a single command by implementing the merge method on the command. This allows smaller commands to be used to build more complex operations, or smaller incremental changes to be merged into larger changes that can be undone and redone in a single step.
- The target can be marked as being saved to disk and the data-structures can track the saved state and tell the user when it changes.
- The amount of changes being tracked can be configured by the user so only the
n
most recent changes are stored.
Examples
Add this to Cargo.toml
:
[dependencies]
redo = "0.39"
And this to main.rs
:
use redo::{Command, Record}; struct Add(char); impl Command for Add { type Target = String; type Error = &'static str; fn apply(&mut self, s: &mut String) -> redo::Result<Add> { s.push(self.0); Ok(()) } fn undo(&mut self, s: &mut String) -> redo::Result<Add> { self.0 = s.pop().ok_or("`s` is empty")?; Ok(()) } } fn main() -> redo::Result<Add> { let mut record = Record::default(); record.apply(Add('a'))?; record.apply(Add('b'))?; record.apply(Add('c'))?; assert_eq!(record.as_target(), "abc"); record.undo().unwrap()?; record.undo().unwrap()?; record.undo().unwrap()?; assert_eq!(record.as_target(), ""); record.redo().unwrap()?; record.redo().unwrap()?; record.redo().unwrap()?; assert_eq!(record.as_target(), "abc"); Ok(()) }
Structs
Checkpoint | A checkpoint wrapper. |
Display | Configurable display formatting of structures. |
History | A history of commands. |
HistoryBuilder | Builder for a History. |
Queue | A command queue wrapper. |
Record | A record of commands. |
RecordBuilder | Builder for a record. |
Enums
Merge | Says if the command have been merged with another command. |
Signal | The signal sent when the record, the history, or the target changes. |
Traits
Command | Base functionality for all commands. |
Type Definitions
Result | A specialized Result type for undo-redo operations. |