Undo

An undo/redo library with dynamic dispatch, state handling and automatic command merging.

About

It uses the [Command Pattern] where the user implements the UndoCmd trait for each command.

The UndoStack has two states, clean and dirty. The stack is clean when no more commands can be redone, otherwise it is dirty. When it's state changes to either dirty or clean, it calls the user defined method set in [on_state_change]. This is useful if you want to trigger some event when the state changes, eg. enabling and disabling undo and redo buttons.

It also supports automatic merging of commands with the same id.

Redo vs Undo

| | Redo | Undo | |-----------------|------------------|-----------------| | Dispatch | [Static] | [Dynamic] | | State Handling | Yes | Yes | | Command Merging | Manual | Auto |

Both supports command merging but undo will automatically merge commands with the same id, while in redo you need to implement the merge method yourself.

Examples

```rust use undo::{self, UndoCmd, UndoStack};

[derive(Clone, Copy, Debug)]

struct PopCmd { vec: *mut Vec, e: Option, }

impl UndoCmd for PopCmd { fn redo(&mut self) -> undo::Result { self.e = unsafe { let ref mut vec = *self.vec; vec.pop() }; Ok(()) }

fn undo(&mut self) -> undo::Result {
    unsafe {
        let ref mut vec = *self.vec;
        vec.push(self.e.unwrap());
    }
    Ok(())
}

}

fn foo() -> undo::Result { let mut vec = vec![1, 2, 3]; let mut stack = UndoStack::new(); let cmd = PopCmd { vec: &mut vec, e: None };

stack.push(cmd)?;
stack.push(cmd)?;
stack.push(cmd)?;

assert!(vec.is_empty());

stack.undo()?;
stack.undo()?;
stack.undo()?;

assert_eq!(vec.len(), 3);
Ok(())

} ```