Struct biodivine_sketchbook::app::state::_undo_stack::UndoStack

pub struct UndoStack {
    event_limit: usize,
    payload_limit: usize,
    current_payload_size: usize,
    undo_stack: VecDeque<UndoStackEntry>,
    redo_stack: VecDeque<UndoStackEntry>,
}

The stack that keeps track of all the events that can be reversed.

It has a “normal” Rust API, but it also implements SessionState so that parts of it can be accessed as an app state object through events.

Fields

event_limit: usize

The number of events this UndoStack is allowed to track. Beyond this limit, the stack will start dropping the oldest events.

payload_limit: usize

The number of bytes of payload that this UndoStack is allowed to store. Beyond this limit, the stack will start dropping the oldest events.

current_payload_size: usize

The approximate size of all payloads stored on the undo_stack.

Note that the redo_stack does not count towards this value, because entries only move there from the undo_stack (i.e. after the payload size check) and when we push to the undo_stack, the redo_stack is erased. Hence, assuming all invariants hold, undo_stack + redo_stack < limit, even if we just track the undo_stack.

undo_stack: VecDeque<UndoStackEntry>

redo_stack: VecDeque<UndoStackEntry>

Implementations

impl UndoStack

pub fn new(event_limit: usize, payload_limit: usize) -> UndoStack

pub fn can_undo(&self) -> bool

pub fn can_redo(&self) -> bool

pub fn clear(&mut self)

Remove all elements from the UndoStack.

pub fn undo_len(&self) -> usize

The number of events that can be un-done.

pub fn redo_len(&self) -> usize

The number of events that can be re-done.

pub fn do_action(&mut self, perform: UserAction, reverse: UserAction) -> bool

Notify the undo stack that a new action has been performed. This creates a new stack entry for this action. Furthermore, it erases any available “redo” actions.

Returns true if the events were successfully saved, or false if an error occurred, e.g. due to excessive payload size.

pub fn undo_action(&mut self) -> Option<UserAction>

Try to undo the current top of the undo stack. This action can be later re-done using Self::redo_action. Returns None if there is no action to undo, or the “reverse” UserAction originally supplied to Self::do_action.

pub fn redo_action(&mut self) -> Option<UserAction>

Try to redo the current top of the redo stack. This action can be later un-done using Self::undo_action. Returns None if there is no action to redo, or the “perform” UserAction originally supplied to Self::do_action.

fn drop_undo_event(&mut self) -> Option<UndoStackEntry>

Internal function to drop an UndoStackEntry from the undo_stack.

Trait Implementations

impl Clone for UndoStack

fn clone(&self) -> UndoStack

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for UndoStack

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for UndoStack

fn eq(&self, other: &UndoStack) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SessionState for UndoStack

fn perform_event( &mut self, _event: &Event, _at_path: &[&str], ) -> Result<Consumed, DynError>

Modify the session state using the provided event. The possible outcomes are described by Consumed.

fn refresh( &self, full_path: &[String], at_path: &[&str], ) -> Result<Event, DynError>

“Read” session state into an event without modifying it.

impl Eq for UndoStack

impl StructuralPartialEq for UndoStack