Struct undo::record::Record

pub struct Record<E, S = ()> { /* private fields */ }

A linear record of Edit 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 Event. The user can give the record a function that is called each time the state changes by using the Builder.

When adding a new edit command to the record the previously undone commands will be discarded. If you want to keep all edits you can use History instead.

Examples

let mut target = String::new();
let mut record = Record::new();

record.edit(&mut target, Add('a'));
record.edit(&mut target, Add('b'));
record.edit(&mut target, Add('c'));
assert_eq!(target, "abc");

record.undo(&mut target);
record.undo(&mut target);
record.undo(&mut target);
assert_eq!(target, "");

record.redo(&mut target);
record.redo(&mut target);
assert_eq!(target, "ab");

// 'c' will be discarded.
record.edit(&mut target, Add('d'));
assert_eq!(target, "abd");

Implementations

impl<E> Record<E>

pub fn new() -> Record<E>

Returns a new record.

impl<E, S> Record<E, S>

pub fn builder() -> Builder<E, S>

Returns a new record builder.

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

Reserves capacity for at least additional more edits.

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 edits 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: S) -> Option<S>

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

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

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 saved(&self) -> Option<usize>

Returns the index of the saved state.

pub fn head(&self) -> usize

Returns the current index in the record.

pub fn get_entry(&self, index: usize) -> Option<&Entry<E>>

Returns the entry at the index.

pub fn entries(&self) -> impl Iterator<Item = &Entry<E>>

Returns an iterator over the entries.

pub fn queue(&mut self) -> Queue<'_, E, S>

Returns a queue.

pub fn checkpoint(&mut self) -> Checkpoint<'_, E, S>

Returns a checkpoint.

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

Returns a structure for configurable formatting of the record.

impl<E, S: Slot> Record<E, S>

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

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

pub fn clear(&mut self)

Removes all edits from the record without undoing them.

impl<E: Edit, S: Slot> Record<E, S>

pub fn edit(&mut self, target: &mut E::Target, edit: E) -> E::Output

Pushes the edit on top of the record and executes its Edit::edit method.

pub fn undo(&mut self, target: &mut E::Target) -> Option<E::Output>

Calls the Edit::undo method for the active edit and sets the previous one as the new active one.

pub fn redo(&mut self, target: &mut E::Target) -> Option<E::Output>

Calls the Edit::redo method for the active edit and sets the next one as the new active one.

pub fn revert(&mut self, target: &mut E::Target) -> Vec<E::Output>

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

pub fn go_to(&mut self, target: &mut E::Target, index: usize) -> Vec<E::Output>

Repeatedly calls Edit::undo or Edit::redo until the edit at index is reached.

impl<E: Display, S> Record<E, S>

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

Returns the string of the edit which will be undone in the next call to Record::undo.

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

Returns the string of the edit which will be redone in the next call to Record::redo.

Trait Implementations

impl<E: Clone, S: Clone> Clone for Record<E, S>

fn clone(&self) -> Record<E, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug, S: Debug> Debug for Record<E, S>

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

Formats the value using the given formatter.

impl<E> Default for Record<E>

fn default() -> Record<E>

Returns the “default value” for a type.

impl<'de, E, S> Deserialize<'de> for Record<E, S>where E: Deserialize<'de>, S: 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, E, S> From<&'a Record<E, S>> for Display<'a, E, S>

fn from(record: &'a Record<E, S>) -> Self

Converts to this type from the input type.

impl<'a, E, S> From<&'a mut Record<E, S>> for Checkpoint<'a, E, S>

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

Converts to this type from the input type.

impl<'a, E, S> From<&'a mut Record<E, S>> for Queue<'a, E, S>

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

Converts to this type from the input type.

impl<E, F> From<History<E, F>> for Record<E, F>

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

Converts to this type from the input type.

impl<E, S> From<Record<E, S>> for History<E, S>

fn from(record: Record<E, S>) -> Self

Converts to this type from the input type.

impl<E, S> Serialize for Record<E, S>where E: Serialize, S: Serialize,

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

Serialize this value into the given Serde serializer.