Struct Acur 

pub struct Acur<'a, T: Clone>(/* private fields */);

Cur + Send + Sync

See also AcurBuilder.

Sample code

use gur::prelude::*;
use gur::acur::{Acur, AcurBuilder};

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

fn main() {
    // Initialize
    let mut state = AcurBuilder::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 by Clone

Unlike Aur, Acur takes snapshots by Clone. So Acur requires a type T implementing Clone instead of Snapshot.

Provided methods

Acur implements following undo-redo interfaces.

• IUndoRedo
• IEditA

See the pages to view method list.

Thread-safety

Acur implements Send and Sync.

Trait Implementations

impl<'a, T: Debug + Clone> Debug for Acur<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: Clone> Deref for Acur<'a, T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, T: Clone + Display> Display for Acur<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: Clone> IEditA<'a> for Acur<'a, T>

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: Clone> IUndoRedo for Acur<'a, T>

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.