Behavioral Patterns in Rust: Exploring the Command Pattern

Introduction

Welcome to the "Behavioral Patterns in Rust" course! In software development, behavioral patterns focus on how objects interact and communicate to achieve flexibility and efficiency within your codebase. These patterns play a crucial role in creating maintainable and scalable systems by defining structured ways for objects to collaborate. In this lesson, we'll dive into the Command Pattern, a pivotal design pattern that empowers you to craft modular and reusable code. By encapsulating requests as objects, the Command Pattern is particularly handy in scenarios like building smart home systems or gaming engines, where managing and executing dynamic operations efficiently is key. Let's embark on this journey to unravel its potential!

Understanding the Command Pattern

The Command Pattern simplifies the encapsulation of requests as objects, enabling you to manage operations flexibly and efficiently. This pattern, rooted in behavioral design principles, allows you to parameterize commands, implement undoable operations, and queue or log requests. The core advantage lies in decoupling the initiator of a command from the executor, enhancing modularity and scalability. Key benefits of employing the Command Pattern include: Sender and Receiver Decoupling : The sender of a request operates independently from the receiver, promoting loose coupling. Undo/Redo Functionalities : It supports reversing operations by storing command states. Batch Operations : Commands can be queued, logged, or scheduled for streamlined processing.

Components of the Command Pattern

Let's explore the essential components of the Command Pattern : Command : A trait defining a method for executing actions. Concrete Commands : Implementations of the Command trait that bind actions to specific objects. Receiver : The entity that performs the actual action when a command is invoked. Invoker : The component responsible for executing commands. Client : The application that creates commands, associates them with receivers, and manages invocations. Each component plays a pivotal role in creating a flexible and adaptable system, decoupling object interaction seamlessly.

Defining the Command Trait

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Rust

pub trait Command {
    fn execute(&self, light: &mut Light);
    fn undo(&self, light: &mut Light);
}

pub trait Command {
    fn execute(&self, light: &mut Light);
    fn undo(&self, light: &mut Light);
}

Rust

pub struct LightOnCommand;

impl LightOnCommand {
    pub fn new() -> Self {
        LightOnCommand
    }
}

impl Command for LightOnCommand {
    fn execute(&self, light: &mut Light) {
        light.on();
    }

    fn undo(&self, light: &mut Light) {
        light.off();
        println!("Undo: Light turned off.");
    }
}

pub struct LightOnCommand;

impl LightOnCommand {
    pub fn new() -> Self {
        LightOnCommand
    }
}

impl Command for LightOnCommand {
    fn execute(&self, light: &mut Light) {
        light.on();
    }

    fn undo(&self, light: &mut Light) {
        light.off();
        println!("Undo: Light turned off.");
    }
}

Rust

pub struct LightOffCommand;

impl LightOffCommand {
    pub fn new() -> Self {
        LightOffCommand
    }
}

impl Command for LightOffCommand {
    fn execute(&self, light: &mut Light) {
        light.off();
    }

    fn undo(&self, light: &mut Light) {
        light.on();
        println!("Undo: Light turned on.");
    }
}

pub struct LightOffCommand;

impl LightOffCommand {
    pub fn new() -> Self {
        LightOffCommand
    }
}

impl Command for LightOffCommand {
    fn execute(&self, light: &mut Light) {
        light.off();
    }

    fn undo(&self, light: &mut Light) {
        light.on();
        println!("Undo: Light turned on.");
    }
}

Rust

pub struct Light {
    is_on: bool,
}

impl Light {
    pub fn new() -> Self {
        Light { is_on: false }
    }

    pub fn on(&mut self) {
        if !self.is_on {
            self.is_on = true;
            println!("Light is on.");
        }
    }

    pub fn off(&mut self) {
        if self.is_on {
            self.is_on = false;
            println!("Light is off.");
        }
    }
}

pub struct Light {
    is_on: bool,
}

impl Light {
    pub fn new() -> Self {
        Light { is_on: false }
    }

    pub fn on(&mut self) {
        if !self.is_on {
            self.is_on = true;
            println!("Light is on.");
        }
    }

    pub fn off(&mut self) {
        if self.is_on {
            self.is_on = false;
            println!("Light is off.");
        }
    }
}

Rust

pub struct RemoteControl {
    history: Vec<Box<dyn Command>>,
}

impl RemoteControl {
    pub fn new() -> Self {
        RemoteControl { history: Vec::new() }
    }

    pub fn press_button(&mut self, command: Box<dyn Command>, light: &mut Light) {
        command.execute(light);
        self.history.push(command);
    }

    pub fn undo_button(&mut self, light: &mut Light) {
        if let Some(command) = self.history.pop() {
            command.undo(light);
        } else {
            println!("No commands to undo.");
        }
    }
}

pub struct RemoteControl {
    history: Vec<Box<dyn Command>>,
}

impl RemoteControl {
    pub fn new() -> Self {
        RemoteControl { history: Vec::new() }
    }

    pub fn press_button(&mut self, command: Box<dyn Command>, light: &mut Light) {
        command.execute(light);
        self.history.push(command);
    }

    pub fn undo_button(&mut self, light: &mut Light) {
        if let Some(command) = self.history.pop() {
            command.undo(light);
        } else {
            println!("No commands to undo.");
        }
    }
}

Rust

fn main() {
    let mut light = Light::new();
    let mut remote = RemoteControl::new();

    remote.press_button(Box::new(LightOnCommand::new()), &mut light);
    remote.press_button(Box::new(LightOffCommand::new()), &mut light);

    // Undo commands
    remote.undo_button(&mut light);
    remote.undo_button(&mut light);
}

fn main() {
    let mut light = Light::new();
    let mut remote = RemoteControl::new();

    remote.press_button(Box::new(LightOnCommand::new()), &mut light);
    remote.press_button(Box::new(LightOffCommand::new()), &mut light);

    // Undo commands
    remote.undo_button(&mut light);
    remote.undo_button(&mut light);
}

Rust

pub trait Command {
    fn execute(&self, light: &mut Light);
    fn undo(&self, light: &mut Light);
}

Rust

pub struct LightOnCommand;

impl LightOnCommand {
    pub fn new() -> Self {
        LightOnCommand
    }
}

impl Command for LightOnCommand {
    fn execute(&self, light: &mut Light) {
        light.on();
    }

    fn undo(&self, light: &mut Light) {
        light.off();
        println!("Undo: Light turned off.");
    }
}

Rust

pub struct LightOffCommand;

impl LightOffCommand {
    pub fn new() -> Self {
        LightOffCommand
    }
}

impl Command for LightOffCommand {
    fn execute(&self, light: &mut Light) {
        light.off();
    }

    fn undo(&self, light: &mut Light) {
        light.on();
        println!("Undo: Light turned on.");
    }
}

Rust

pub struct Light {
    is_on: bool,
}

impl Light {
    pub fn new() -> Self {
        Light { is_on: false }
    }

    pub fn on(&mut self) {
        if !self.is_on {
            self.is_on = true;
            println!("Light is on.");
        }
    }

    pub fn off(&mut self) {
        if self.is_on {
            self.is_on = false;
            println!("Light is off.");
        }
    }
}

Rust

pub struct RemoteControl {
    history: Vec<Box<dyn Command>>,
}

impl RemoteControl {
    pub fn new() -> Self {
        RemoteControl { history: Vec::new() }
    }

    pub fn press_button(&mut self, command: Box<dyn Command>, light: &mut Light) {
        command.execute(light);
        self.history.push(command);
    }

    pub fn undo_button(&mut self, light: &mut Light) {
        if let Some(command) = self.history.pop() {
            command.undo(light);
        } else {
            println!("No commands to undo.");
        }
    }
}

Rust

fn main() {
    let mut light = Light::new();
    let mut remote = RemoteControl::new();

    remote.press_button(Box::new(LightOnCommand::new()), &mut light);
    remote.press_button(Box::new(LightOffCommand::new()), &mut light);

    // Undo commands
    remote.undo_button(&mut light);
    remote.undo_button(&mut light);
}

Introduction

Understanding the Command Pattern

Components of the Command Pattern

Defining the Command Trait

Join the 1M+ learners on CodeSignal

Concrete Commands with Undo Capability

Defining the Receiver Component

Implementing the Invoker: Orchestrating Commands

Putting It All Together

Conclusion