Struct undo::Chain

pub struct Chain<R> { /* fields omitted */ }

A chain of merged commands.

Commands in a chain are all executed in the order they was merged in.

Examples

let mut record = Record::default();
let chain = Chain::with_capacity(2)
    .join(Add('a'))
    .join(Add('b'));
record.apply(chain)?;
assert_eq!(record.as_receiver(), "ab");
record.undo().unwrap()?;
assert_eq!(record.as_receiver(), "");
record.redo().unwrap()?;
assert_eq!(record.as_receiver(), "ab");

Methods

impl<R> Chain<R>

pub fn new() -> Chain<R>

Returns an empty command.

pub fn with_text(text: impl Into<String>) -> Chain<R>

Returns an empty command with the specified display text.

pub fn with_capacity(capacity: usize) -> Chain<R>

Returns an empty command with the specified capacity.

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

Reserves capacity for at least additional more commands in the chain.

Panics

Panics if the new capacity overflows usize.

pub fn capacity(&self) -> usize

Returns the capacity of the chain.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the chain as much as possible.

pub fn len(&self) -> usize

Returns the amount of commands in the chain.

pub fn is_empty(&self) -> bool

Returns true if no commands have been merged.

pub fn push(&mut self, command: impl Command<R> + 'static)

Merges the command with the chain.

pub fn join(self, command: impl Command<R> + 'static) -> Chain<R>

Merges the command with the chain and returns the chain.

pub fn set_merge(&mut self, merge: Merge)

Sets the merge behavior of the chain.

By default the merge behavior of the first command in the chain is used, and it merges if the chain is empty.

pub fn set_text(&mut self, text: impl Into<String>)

Sets the display text for the chain.

By default the display text will be the display text for every command in the chain.

Trait Implementations

impl<R> Command<R> for Chain<R>

fn apply(&mut self, receiver: &mut R) -> Result

Applies the command on the receiver and returns Ok if everything went fine, and Err if something went wrong.

fn undo(&mut self, receiver: &mut R) -> Result

Restores the state of the receiver as it was before the command was applied and returns Ok if everything went fine, and Err if something went wrong.

fn redo(&mut self, receiver: &mut R) -> Result

Reapplies the command on the receiver and return Ok if everything went fine, and Err if something went wrong.

fn merge(&self) -> Merge

Used for automatic merging of commands.

fn is_dead(&self) -> bool

Says if the command is dead.

impl<R, C: Command<R> + 'static> Extend<C> for Chain<R>

fn extend<T: IntoIterator<Item = C>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

impl<R> Default for Chain<R>

fn default() -> Self

Returns the "default value" for a type.

impl<R> IntoIterator for Chain<R>

type Item = Box<dyn Command<R>>

The type of the elements being iterated over.

type IntoIter = IntoIter<Self::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<R> Debug for Chain<R>

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

Formats the value using the given formatter.

impl<R> Display for Chain<R>

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

Formats the value using the given formatter.

impl<R, C: Command<R> + 'static> FromIterator<C> for Chain<R>

fn from_iter<T: IntoIterator<Item = C>>(commands: T) -> Self

Creates a value from an iterator.