Struct redo::record::Record

pub struct Record<C: Command, F = fn(_: Signal)> { /* fields omitted */ }

A record of commands.

The record can roll the targets 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 target through signal. The user can give the record a function that is called each time the state changes by using the builder.

Examples

let mut record = Record::default();
record.apply(Add('a'))?;
record.apply(Add('b'))?;
record.apply(Add('c'))?;
assert_eq!(record.target(), "abc");
record.undo()?;
record.undo()?;
record.undo()?;
assert_eq!(record.target(), "");
record.redo()?;
record.redo()?;
record.redo()?;
assert_eq!(record.target(), "abc");

Implementations

impl<C: Command> Record<C>

pub fn new(target: C::Target) -> Record<C>

Returns a new record.

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

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 shrink_to_fit(&mut self)

Shrinks the capacity of the record as much as possible.

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 connect(&mut self, slot: F) -> Option<F>

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

The previous slot is returned if it exists.

pub fn disconnect(&mut self) -> Option<F>

Removes and returns the slot if it exists.

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 is_saved(&self) -> bool

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

pub fn current(&self) -> usize

Returns the position of the current command.

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

Returns a queue.

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

Returns a checkpoint.

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

Returns a structure for configurable formatting of the record.

pub fn target(&self) -> &C::Target

Returns a reference to the target.

pub fn target_mut(&mut self) -> &mut C::Target

Returns a mutable reference to the target.

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

pub fn into_target(self) -> C::Target

Consumes the record, returning the target.

impl<C: Command, F: FnMut(Signal)> Record<C, F>

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

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

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

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

pub fn clear(&mut self)

Removes all commands from the record without undoing them.

pub fn apply(&mut self, command: C) -> Result<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.

pub fn undo(&mut self) -> Result<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.

pub fn redo(&mut self) -> Result<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.

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

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

Errors

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

pub fn time_travel(&mut self, to: &DateTime<impl TimeZone>) -> Option<Result<C>>

Go back or forward in the record to the command that was made closest to the datetime provided.

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

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

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

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

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

Trait Implementations

impl<C: Clone + Command, F: Clone> Clone for Record<C, F> where
    C::Target: Clone, 

fn clone(&self) -> Record<C, F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Command, F> Debug for Record<C, F> where
    C: Debug,
    C::Target: Debug, 

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

Formats the value using the given formatter.

impl<C: Command> Default for Record<C> where
    C::Target: Default, 

fn default() -> Record<C>

Returns the “default value” for a type.

impl<'de, C: Command, F> Deserialize<'de> for Record<C, F> where
    C: Command + Deserialize<'de>,
    C::Target: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a, C: Command, F> From<&'a Record<C, F>> for Display<'a, C, F>

fn from(record: &'a Record<C, F>) -> Self

Performs the conversion.

impl<'a, C: Command, F> From<&'a mut Record<C, F>> for Queue<'a, C, F>

fn from(record: &'a mut Record<C, F>) -> Self

Performs the conversion.

impl<'a, C: Command, F> From<&'a mut Record<C, F>> for Checkpoint<'a, C, F>

fn from(record: &'a mut Record<C, F>) -> Self

Performs the conversion.

impl<C: Command, F: FnMut(Signal)> From<History<C, F>> for Record<C, F>

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

Performs the conversion.

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

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

Performs the conversion.

impl<C: Command, F> Serialize for Record<C, F> where
    C: Command + Serialize,
    C::Target: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.