Struct redo::Record

pub struct Record<R, C: Command<R>> { /* private fields */ }

A record of commands.

The record can roll the receivers state backwards and forwards by using the undo and redo methods. In addition, the record can notify the user about changes to the stack or the receiver through signal. The user can give the record a function that is called each time the state changes by using the builder.

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() -> redo::Result<String, Add> {
    let mut record = Record::default();
    record.apply(Add('a'))?;
    record.apply(Add('b'))?;
    record.apply(Add('c'))?;
    assert_eq!(record.as_receiver(), "abc");
    record.undo().unwrap()?;
    record.undo().unwrap()?;
    record.undo().unwrap()?;
    assert_eq!(record.as_receiver(), "");
    record.redo().unwrap()?;
    record.redo().unwrap()?;
    record.redo().unwrap()?;
    assert_eq!(record.as_receiver(), "abc");
    Ok(())
}

Implementations

impl<R, C: Command<R>> Record<R, C>

pub fn new(receiver: impl Into<R>) -> Record<R, C>

Returns a new record.

pub fn builder() -> RecordBuilder<R, C>

Returns a builder for a record.

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more commands.

Panics

Panics if the new capacity overflows usize.

pub fn capacity(&self) -> usize

Returns the capacity of the record.

pub fn len(&self) -> usize

Returns the number of commands in the record.

pub fn is_empty(&self) -> bool

Returns true if the record is empty.

pub fn limit(&self) -> usize

Returns the limit of the record.

pub fn set_limit(&mut self, limit: usize) -> usize

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

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

If 0 < 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.

pub fn connect(&mut self, f: impl FnMut(Signal) + Send + Sync + 'static)

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

pub fn can_undo(&self) -> bool

Returns true if the record can undo.

pub fn can_redo(&self) -> bool

Returns true if the record can redo.

pub fn set_saved(&mut self, saved: bool)

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

pub fn is_saved(&self) -> bool

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

pub fn revert(&mut self) -> Option<Result<R, C>>

Revert the changes done to the receiver since the saved state.

pub fn cursor(&self) -> usize

Returns the position of the current command.

pub fn clear(&mut self)

Removes all commands from the record without undoing them.

pub fn apply(&mut self, command: C) -> Result<R, C>

Pushes the command on top of the record and executes its apply method.

Errors

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

pub fn undo(&mut self) -> Option<Result<R, C>>

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.

pub fn redo(&mut self) -> Option<Result<R, C>>

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

Errors

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

pub fn go_to(&mut self, cursor: usize) -> Option<Result<R, C>>

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

Errors

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

pub fn checkpoint(&mut self) -> Checkpoint<'_, Record<R, C>, C>

Returns a checkpoint.

pub fn queue(&mut self) -> Queue<'_, Record<R, C>, C>

Returns a queue.

pub fn as_receiver(&self) -> &R

Returns a reference to the receiver.

pub fn as_mut_receiver(&mut self) -> &mut R

Returns a mutable reference to the receiver.

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

pub fn into_receiver(self) -> R

Consumes the record, returning the receiver.

pub fn commands(&self) -> impl Iterator<Item = &C>

Returns an iterator over the commands in the record.

impl<R, C: Command<R> + ToString> Record<R, C>

pub fn to_undo_string(&self) -> Option<String>

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

pub fn to_redo_string(&self) -> Option<String>

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

pub fn display(&self) -> Display<'_, Self>

Returns a structure for configurable formatting of the record.

Trait Implementations

impl<R, C: Command<R>> AsMut<R> for Record<R, C>

fn as_mut(&mut self) -> &mut R

Converts this type into a mutable reference of the (usually inferred) input type.

impl<R, C: Command<R>> AsRef<R> for Record<R, C>

fn as_ref(&self) -> &R

Converts this type into a shared reference of the (usually inferred) input type.

impl<R: Debug, C: Command<R> + Debug> Debug for Record<R, C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Default, C: Command<R>> Default for Record<R, C>

fn default() -> Record<R, C>

Returns the “default value” for a type.

impl<R, C: Command<R> + Display> Display for Record<R, C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R, C: Command<R>> From<History<R, C>> for Record<R, C>

fn from(history: History<R, C>) -> Record<R, C>

Converts to this type from the input type.

impl<R, C: Command<R>> From<R> for Record<R, C>

fn from(receiver: R) -> Record<R, C>

Converts to this type from the input type.

impl<R, C: Command<R>> From<Record<R, C>> for History<R, C>

fn from(record: Record<R, C>) -> Self

Converts to this type from the input type.