Struct redo::Stack

pub struct Stack<R, C: Command<R>> { /* fields omitted */ }

The command stack.

The stack is the simplest data structure and works by pushing and popping off commands that modifies the receiver. Unlike the record, it does not have a special state that can be used for callbacks.

Examples

use redo::{Command, Error, Stack};

#[derive(Debug)]
struct Add(char);

impl Command<String> for Add {
    type Err = &'static str;

    fn exec(&mut self, s: &mut String) -> Result<(), &'static str> {
        s.push(self.0);
        Ok(())
    }

    fn undo(&mut self, s: &mut String) -> Result<(), &'static str> {
        self.0 = s.pop().ok_or("`String` is unexpectedly empty")?;
        Ok(())
    }
}

fn foo() -> Result<(), Error<String, Add>> {
    let mut stack = Stack::default();

    stack.push(Add('a'))?;
    stack.push(Add('b'))?;
    stack.push(Add('c'))?;

    assert_eq!(stack.as_receiver(), "abc");

    let c = stack.pop().unwrap()?;
    let b = stack.pop().unwrap()?;
    let a = stack.pop().unwrap()?;

    assert_eq!(stack.as_receiver(), "");

    stack.push(a)?;
    stack.push(b)?;
    stack.push(c)?;

    assert_eq!(stack.into_receiver(), "abc");

    Ok(())
}

Methods

impl<R, C: Command<R>> Stack<R, C>

pub fn new<T: Into<R>>(receiver: T) -> Stack<R, C>

Creates a new stack.

pub fn len(&self) -> usize

Returns the number of commands in the stack.

pub fn is_empty(&self) -> bool

Returns true if the stack is empty.

pub fn clear(&mut self)

Removes all commands from the stack without undoing them.

This resets the stack back to its initial state while leaving the receiver unmodified.

pub fn push(&mut self, cmd: C) -> Result<(), Error<R, C>>

Pushes the command on the stack and executes its exec method. The command is merged with the previous top command if merge does not return None.

Errors

If an error occur when executing redo or merging commands, the error is returned together with the command.

pub fn pop(&mut self) -> Option<Result<C, Error<R, C>>>

Calls the top commands undo method and pops it off the stack. Returns None if the stack is empty.

Errors

If an error occur when executing undo the error is returned together with the command.

pub fn as_receiver(&self) -> &R

Returns a reference to the receiver.

pub fn into_receiver(self) -> R

Consumes the stack, returning the receiver.

Trait Implementations

impl<R: Clone, C: Clone + Command<R>> Clone for Stack<R, C>

fn clone(&self) -> Stack<R, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug, C: Debug + Command<R>> Debug for Stack<R, C>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<R: Eq, C: Eq + Command<R>> Eq for Stack<R, C>

impl<R: PartialEq, C: PartialEq + Command<R>> PartialEq for Stack<R, C>

fn eq(&self, __arg_0: &Stack<R, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Stack<R, C>) -> bool

This method tests for !=.

impl<R: Hash, C: Hash + Command<R>> Hash for Stack<R, C>

fn hash<__HRC: Hasher>(&self, __arg_0: &mut __HRC)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<R: Ord, C: Ord + Command<R>> Ord for Stack<R, C>

fn cmp(&self, __arg_0: &Stack<R, C>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<R: PartialOrd, C: PartialOrd + Command<R>> PartialOrd for Stack<R, C>

fn partial_cmp(&self, __arg_0: &Stack<R, C>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, __arg_0: &Stack<R, C>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, __arg_0: &Stack<R, C>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, __arg_0: &Stack<R, C>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, __arg_0: &Stack<R, C>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<R: Default, C: Command<R>> Default for Stack<R, C>

fn default() -> Stack<R, C>

Returns the "default value" for a type.

impl<R, C: Command<R>> AsRef<R> for Stack<R, C>

fn as_ref(&self) -> &R

Performs the conversion.

impl<R, C: Command<R>> From<R> for Stack<R, C>

fn from(receiver: R) -> Self

Performs the conversion.

impl<R, C: Command<R> + Display> Display for Stack<R, C>

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

Formats the value using the given formatter.