Struct undo::history::History

pub struct History<A, S = Nop> { /* private fields */ }

A history tree of actions.

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

Examples

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

history.apply(&mut target, Push('a'));
history.apply(&mut target, Push('b'));
history.apply(&mut target, Push('c'));
let abc = history.branch();

history.go_to(&mut target, abc, 1);
history.apply(&mut target, Push('f'));
history.apply(&mut target, Push('g'));
assert_eq!(target, "afg");

history.go_to(&mut target, abc, 3);
assert_eq!(target, "abc");

Implementations

impl<A> History<A>

pub fn new() -> History<A>

Returns a new history.

Examples found in repository

examples/history.rs (line 28)

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

    history.apply(&mut target, Push('a'));
    history.apply(&mut target, Push('b'));
    history.apply(&mut target, Push('c'));
    assert_eq!(target, "abc");

    let abc_branch = history.branch();
    let abc_current = history.current();

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

    history.apply(&mut target, Push('d'));
    history.apply(&mut target, Push('e'));
    history.apply(&mut target, Push('f'));
    assert_eq!(target, "abdef");

    let abdef_branch = history.branch();
    let abdef_current = history.current();

    history.go_to(&mut target, abc_branch, abc_current);
    assert_eq!(target, "abc");

    history.go_to(&mut target, abdef_branch, abdef_current);
    assert_eq!(target, "abdef");

    println!("{}", history.display());
}

impl<A, S> History<A, S>

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

Returns a new history builder.

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

Reserves capacity for at least additional more actions.

Panics

Panics if the new capacity overflows usize.

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 actions 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 signal 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 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 branch(&self) -> usize

Returns the current branch.

Examples found in repository

examples/history.rs (line 36)

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

    history.apply(&mut target, Push('a'));
    history.apply(&mut target, Push('b'));
    history.apply(&mut target, Push('c'));
    assert_eq!(target, "abc");

    let abc_branch = history.branch();
    let abc_current = history.current();

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

    history.apply(&mut target, Push('d'));
    history.apply(&mut target, Push('e'));
    history.apply(&mut target, Push('f'));
    assert_eq!(target, "abdef");

    let abdef_branch = history.branch();
    let abdef_current = history.current();

    history.go_to(&mut target, abc_branch, abc_current);
    assert_eq!(target, "abc");

    history.go_to(&mut target, abdef_branch, abdef_current);
    assert_eq!(target, "abdef");

    println!("{}", history.display());
}

pub fn current(&self) -> usize

Returns the position of the current action.

Examples found in repository

examples/history.rs (line 37)

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

    history.apply(&mut target, Push('a'));
    history.apply(&mut target, Push('b'));
    history.apply(&mut target, Push('c'));
    assert_eq!(target, "abc");

    let abc_branch = history.branch();
    let abc_current = history.current();

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

    history.apply(&mut target, Push('d'));
    history.apply(&mut target, Push('e'));
    history.apply(&mut target, Push('f'));
    assert_eq!(target, "abdef");

    let abdef_branch = history.branch();
    let abdef_current = history.current();

    history.go_to(&mut target, abc_branch, abc_current);
    assert_eq!(target, "abc");

    history.go_to(&mut target, abdef_branch, abdef_current);
    assert_eq!(target, "abdef");

    println!("{}", history.display());
}

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

Returns a structure for configurable formatting of the history.

Examples found in repository

examples/history.rs (line 56)

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

    history.apply(&mut target, Push('a'));
    history.apply(&mut target, Push('b'));
    history.apply(&mut target, Push('c'));
    assert_eq!(target, "abc");

    let abc_branch = history.branch();
    let abc_current = history.current();

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

    history.apply(&mut target, Push('d'));
    history.apply(&mut target, Push('e'));
    history.apply(&mut target, Push('f'));
    assert_eq!(target, "abdef");

    let abdef_branch = history.branch();
    let abdef_current = history.current();

    history.go_to(&mut target, abc_branch, abc_current);
    assert_eq!(target, "abc");

    history.go_to(&mut target, abdef_branch, abdef_current);
    assert_eq!(target, "abdef");

    println!("{}", history.display());
}

pub fn actions(&self) -> impl Iterator<Item = &A>

Returns an iterator over the actions in the current branch.

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

Returns a queue.

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

Returns a checkpoint.

impl<A: Action, S: Slot> History<A, S>

pub fn apply(&mut self, target: &mut A::Target, action: A) -> A::Output

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

Examples found in repository

examples/history.rs (line 31)

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

    history.apply(&mut target, Push('a'));
    history.apply(&mut target, Push('b'));
    history.apply(&mut target, Push('c'));
    assert_eq!(target, "abc");

    let abc_branch = history.branch();
    let abc_current = history.current();

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

    history.apply(&mut target, Push('d'));
    history.apply(&mut target, Push('e'));
    history.apply(&mut target, Push('f'));
    assert_eq!(target, "abdef");

    let abdef_branch = history.branch();
    let abdef_current = history.current();

    history.go_to(&mut target, abc_branch, abc_current);
    assert_eq!(target, "abc");

    history.go_to(&mut target, abdef_branch, abdef_current);
    assert_eq!(target, "abdef");

    println!("{}", history.display());
}

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

Calls the Action::undo method for the active action and sets the previous one as the new active one.

Examples found in repository

examples/history.rs (line 39)

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

    history.apply(&mut target, Push('a'));
    history.apply(&mut target, Push('b'));
    history.apply(&mut target, Push('c'));
    assert_eq!(target, "abc");

    let abc_branch = history.branch();
    let abc_current = history.current();

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

    history.apply(&mut target, Push('d'));
    history.apply(&mut target, Push('e'));
    history.apply(&mut target, Push('f'));
    assert_eq!(target, "abdef");

    let abdef_branch = history.branch();
    let abdef_current = history.current();

    history.go_to(&mut target, abc_branch, abc_current);
    assert_eq!(target, "abc");

    history.go_to(&mut target, abdef_branch, abdef_current);
    assert_eq!(target, "abdef");

    println!("{}", history.display());
}

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

Calls the Action::redo method for the active action and sets the next one as the new active one.

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 actions from the history without undoing them.

pub fn go_to( &mut self, target: &mut A::Target, branch: usize, current: usize ) -> Vec<A::Output>

Repeatedly calls Action::undo or Action::redo until the action in branch at current is reached.

Examples found in repository

examples/history.rs (line 50)

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

    history.apply(&mut target, Push('a'));
    history.apply(&mut target, Push('b'));
    history.apply(&mut target, Push('c'));
    assert_eq!(target, "abc");

    let abc_branch = history.branch();
    let abc_current = history.current();

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

    history.apply(&mut target, Push('d'));
    history.apply(&mut target, Push('e'));
    history.apply(&mut target, Push('f'));
    assert_eq!(target, "abdef");

    let abdef_branch = history.branch();
    let abdef_current = history.current();

    history.go_to(&mut target, abc_branch, abc_current);
    assert_eq!(target, "abc");

    history.go_to(&mut target, abdef_branch, abdef_current);
    assert_eq!(target, "abdef");

    println!("{}", history.display());
}

impl<A: ToString, S> History<A, S>

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

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

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

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

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<A> Default for History<A>

fn default() -> History<A>

Returns the “default value” for a type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<A, S> Serialize for History<A, S>where A: 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.