Struct History

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

A history tree of Edit commands.

Unlike Record which maintains a linear undo history, History maintains an undo tree containing every edit made to the target.

See this example for an interactive view of the history tree.

Examples

let mut target = String::new();
let mut history = History::new();

history.edit(&mut target, Add('a'));
history.edit(&mut target, Add('b'));
history.edit(&mut target, Add('c'));
let abc = history.head();

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

// Instead of discarding 'b' and 'c', a new branch is created.
history.edit(&mut target, Add('f'));
history.edit(&mut target, Add('g'));
assert_eq!(target, "afg");

// We can now switch back to the original branch.
history.go_to(&mut target, abc);
assert_eq!(target, "abc");

Implementations

impl<E> History<E>

pub fn new() -> History<E>

Returns a new history.

impl<E, S> History<E, S>

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

Returns a new history builder.

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

Reserves capacity for at least additional more edits.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

pub fn capacity(&self) -> usize

Returns the capacity of the history.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the history as much as possible.

pub fn len(&self) -> usize

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

pub fn is_empty(&self) -> bool

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

pub fn limit(&self) -> usize

Returns the limit of the history.

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

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

pub fn saved(&self) -> Option<At>

Return the position of the saved state.

pub fn can_undo(&self) -> bool

Returns true if the history can undo.

pub fn can_redo(&self) -> bool

Returns true if the history can redo.

pub fn head(&self) -> At

Returns the current position in the history.

pub fn next_branch_head(&self) -> Option<At>

Returns the head of the next branch in the history.

This will be the first edit that was stored in the branch. This can be used in combination with History::go_to to go to the next branch.

pub fn prev_branch_head(&self) -> Option<At>

Returns the head of the previous branch in the history.

This will be the first edit that was stored in the branch. This can be used in combination with History::go_to to go to the previous branch.

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

Returns the entry at the index in the current root branch.

Use History::get_branch if you want to get entry from other branches.

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

Returns an iterator over the entries in the current root branch.

pub fn get_branch(&self, id: usize) -> Option<&Branch<E>>

Returns the branch with the given id.

pub fn branches(&self) -> impl Iterator<Item = (usize, &Branch<E>)>

Returns an iterator over the branches in the history.

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 history.

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

pub fn set_saved(&mut self)

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

pub fn clear_saved(&mut self)

Clears the saved state of the target.

pub fn clear(&mut self)

Removes all edits from the history without undoing them.

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

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

Pushes the Edit to the top of the history 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, at: At) -> Vec<E::Output>

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

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

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

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

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

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

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<E> Default for History<E>

fn default() -> History<E>

Returns the “default value” for a type.

impl<'de, E, S> Deserialize<'de> for History<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 History<E, S>> for Display<'a, E, S>

fn from(history: &'a History<E, S>) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(history: &'a mut History<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 History<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.