Struct Aur 

pub struct Aur<'a, T, S>(/* private fields */)
where
    T: Snapshot<Snapshot = S>;

Ur + Send + Sync

See also AurBuilder.

Sample code

use gur::prelude::*;
use gur::aur::{Aur, AurBuilder};
use gur::snapshot::Snapshot;

// Appication state
#[derive(Clone)]
struct MyState {
    data: String
}

// Implementing Snapshot trait
impl Snapshot for MyState {
    type Snapshot = String;
    fn to_snapshot(&self) -> Self::Snapshot {
        self.data.clone()
    }
    fn from_snapshot(snapshot: &Self::Snapshot) -> Self {
        MyState{ data: snapshot.clone() }
    }
}

fn main() {
    // Initialize
    let mut state = AurBuilder::new().build(MyState{ data: "My".to_string() });
    assert_eq!("My", state.data);

    // Change state
    state.edit(|mut state| { state.data += "State"; state });
    assert_eq!("MyState", state.data);

    // Undo
    state.undo();
    assert_eq!("My", state.data);

    // Redo
    state.redo();
    assert_eq!("MyState", state.data);
}

Information

Snapshot trait

Aur requires a type T implementing Snapshot. The trait specifies conversion between T and its snapshot object.

Acur may be more suitable for simple types. It requires Clone instead of Snapshot. See Acur for more detail.

Provided methods

Aur implements following undo-redo interfaces.

• IUndoRedo
• IEditA

See the pages to view method list.

Thread-safety

Aur implements Send and Sync.

Trait Implementations

impl<'a, T, S> Debug for Aur<'a, T, S>

where T: Snapshot<Snapshot = S> + Debug,

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

Formats the value using the given formatter.

impl<'a, T, S> Deref for Aur<'a, T, S>

where T: Snapshot<Snapshot = S>,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T, S> Display for Aur<'a, T, S>

where T: Snapshot<Snapshot = S> + Display,

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

Formats the value using the given formatter.

impl<'a, T, S> IEditA<'a> for Aur<'a, T, S>

where T: Snapshot<Snapshot = S>,

type State = T

A type of state managed in Self.

fn edit_if<F>(&mut self, command: F) -> Option<&T>

where F: Fn(T) -> Option<T> + Send + Sync + 'a,

Takes a closure and update the internal state. The closure consumes the current state and produces a new state or None. If the closure returns None, the internal state is not changed.

fn edit<F>(&mut self, command: F) -> &Self::State

where F: Fn(Self::State) -> Self::State + Send + Sync + 'a,

Takes a closure and update the internal state. The closure consumes the current state and produces a new state.

impl<'a, T, S> IUndoRedo for Aur<'a, T, S>

where T: Snapshot<Snapshot = S>,

type State = T

A type of state managed in Self.

fn into_inner(self) -> T

Returns the current state object, consuming the self.

fn capacity(&self) -> Option<usize>

Returns the maximum number of changes stored in the history.

fn undoable_count(&self) -> usize

Returns the number of versions older than current state in the history.

fn redoable_count(&self) -> usize

Returns the number of versions newer than current state in the history.

fn undo_multi(&mut self, count: usize) -> Option<&T>

Undo multiple steps. This method is more efficient than running self.undo() multiple times.

fn redo_multi(&mut self, count: usize) -> Option<&T>

Redo multiple steps. This method is more efficient than running self.redo() multiple times.

fn try_edit<F>(&mut self, command: F) -> Result<&T, Box<dyn Error>>

where F: FnOnce(T) -> Result<T, Box<dyn Error>>,

Takes a closure and update the internal state. The closure consumes the current state and produces a new state or an error. If the closure returns an error, the internal state is not changed.

fn undo(&mut self) -> Option<&Self::State>

Restores the previous state. Same as self.undo_multi(1).

fn redo(&mut self) -> Option<&Self::State>

Restores the next state. Same as self.redo_multi(1).

fn jump(&mut self, count: isize) -> Option<&Self::State>

Undo-redo bidirectionally. This is integrated method of undo_multi and redo_multi.