Struct CompositeCommand 

pub struct CompositeCommand {
    pub stack_id: u64,
    /* private fields */
}

A composite command that groups multiple commands as one.

This allows treating a sequence of commands as a single unit for undo/redo operations. When a composite command is undone or redone, all its contained commands are undone or redone in the appropriate order.

Example

use common::undo_redo::CompositeCommand;
let mut composite = CompositeCommand::new();
composite.add_command(Box::new(Command1::new()));
composite.add_command(Box::new(Command2::new()));
// Now composite can be treated as a single command

Fields

stack_id: u64

Implementations

impl CompositeCommand

pub fn new(stack_id: Option<u64>) -> Self

Creates a new empty composite command.

pub fn labeled(stack_id: Option<u64>, label: Option<UndoLabel>) -> Self

A composite that names itself.

A group’s constituent labels are the wrong answer for a menu — a three-entity capture would read “Undo update” after the least interesting of its parts. The caller who opened the group is the only one who knows what the group was, so it says so here.

pub fn add_command(&mut self, command: Box<dyn UndoRedoCommand>)

Adds a command to this composite.

Commands are executed, undone, and redone in the order they are added.

pub fn is_empty(&self) -> bool

Returns true if this composite contains no commands.

pub fn set_label(&mut self, label: Option<UndoLabel>)

Name this group after the fact — for a caller that only learns what the group was once its parts have run.

Trait Implementations

impl Debug for CompositeCommand

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

Formats the value using the given formatter.

impl UndoRedoCommand for CompositeCommand

fn label(&self) -> Option<UndoLabel>

The group’s own name, never a constituent’s — see CompositeCommand::labeled.

fn undo(&mut self) -> Result<()>

Undoes the command, reverting its effects

fn redo(&mut self) -> Result<()>

Redoes the command, reapplying its effects

fn as_any(&self) -> &dyn Any

Returns the type ID of this command for type checking.

fn can_merge(&self, _other: &dyn UndoRedoCommand) -> bool

Returns true if this command can be merged with the other command.

fn merge(&mut self, _other: &dyn UndoRedoCommand) -> bool

Merges this command with the other command. Returns true if the merge was successful.