Struct redo::History[][src]

pub struct History<R, C: Command<R>> { /* fields omitted */ }

A history of commands.

A history works like the Record but also provides branching, like vim's undo-tree.

Examples

#[derive(Debug)]
struct Add(char);

impl Command<String> for Add {
    type Error = Box<dyn error::Error>;

    fn apply(&mut self, s: &mut String) -> Result<(), Self::Error> {
        s.push(self.0);
        Ok(())
    }

    fn undo(&mut self, s: &mut String) -> Result<(), Self::Error> {
        self.0 = s.pop().ok_or("`s` is empty")?;
        Ok(())
    }
}

fn main() -> Result<(), Error<String, Add>> {
    let mut history = History::default();

    history.apply(Add('a'))?;
    history.apply(Add('b'))?;
    history.apply(Add('c'))?;
    assert_eq!(history.as_receiver(), "abc");

    let root = history.root();
    history.go_to(root, 1).unwrap()?;
    assert_eq!(history.as_receiver(), "a");

    let abc = history.apply(Add('f'))?.unwrap();
    history.apply(Add('g'))?;
    assert_eq!(history.as_receiver(), "afg");

    history.go_to(abc, 3).unwrap()?;
    assert_eq!(history.as_receiver(), "abc");
    Ok(())
}

Methods

impl<R, C: Command<R>> History<R, C>
[src]

Returns a new history.

Returns a builder for a history.

Reserves capacity for at least additional more commands.

Panics

Panics if the new capacity overflows usize.

Returns the capacity of the history.

Returns the number of commands in the current branch of the history.

Returns true if the current branch of the history is empty.

Returns the limit of the history.

Sets the limit of the history and returns the new limit.

If this limit is reached it will start popping of commands at the beginning of the history when new commands are applied. No limit is set by default which means it may grow indefinitely.

If limit < len the first commands will be removed until len == limit. However, if the current active command is going to be removed, the limit is instead adjusted to len - active so the active command is not removed.

Panics

Panics if limit is 0.

Sets how the signal should be handled when the state changes.

Returns true if the history can undo.

Returns true if the history can redo.

Marks the receiver as currently being in a saved or unsaved state.

Returns true if the receiver is in a saved state, false otherwise.

Returns the current branch.

Returns the position of the current command.

Removes all commands from the history without undoing them.

Pushes the command to the top of the history and executes its apply method.

Errors

If an error occur when executing apply the error is returned together with the command.

Calls the undo method for the active command and sets the previous one as the new active one.

Errors

If an error occur when executing undo the error is returned together with the command.

Calls the redo method for the active command and sets the next one as the new active one.

Errors

If an error occur when executing redo the error is returned together with the command.

Repeatedly calls undo or redo until the command in branch at cursor is reached.

Errors

If an error occur when executing undo or redo the error is returned together with the command.

Jump directly to the command in branch at cursor and executes its undo or redo method.

This method can be used if the commands store the whole state of the receiver, and does not require the commands in between to be called to get the same result. Use go_to otherwise.

Errors

If an error occur when executing undo or redo the error is returned together with the command.

Returns a reference to the receiver.

Returns a mutable reference to the receiver.

This method should only be used when doing changes that should not be able to be undone.

Consumes the history, returning the receiver.

impl<R, C: Command<R> + ToString> History<R, C>
[src]

Returns the string of the command which will be undone in the next call to undo.

Returns the string of the command which will be redone in the next call to redo.

Trait Implementations

impl<R: Debug, C: Debug + Command<R>> Debug for History<R, C>
[src]

Formats the value using the given formatter. Read more

impl<R: Default, C: Command<R>> Default for History<R, C>
[src]

Returns the "default value" for a type. Read more

impl<R, C: Command<R>> AsRef<R> for History<R, C>
[src]

Performs the conversion.

impl<R, C: Command<R>> AsMut<R> for History<R, C>
[src]

Performs the conversion.

impl<R, C: Command<R>> From<R> for History<R, C>
[src]

Performs the conversion.

impl<R, C: Command<R> + Display> Display for History<R, C>
[src]

Formats the value using the given formatter. Read more

Auto Trait Implementations

impl<R, C> Send for History<R, C> where
    C: Send,
    R: Send

impl<R, C> Sync for History<R, C> where
    C: Sync,
    R: Sync