Combining Command, Observer, and Strategy Patterns in Rust for a Chat Application

Introduction

Welcome to the final lesson on Behavioral Patterns in Rust! 🎉 In this exciting conclusion, we will bring together the powerful tools you have mastered — the Command, Observer, and Strategy patterns — to design a simple but dynamic chat application. We'll see how these patterns collaborate in Rust to enable clean, efficient, and highly responsive software design. If you've been intrigued by the flexibility and modularity conferred by design patterns, you're in for a treat. Let's harness the power of Rust for a real-world application!

Recap of Behavioral Design Patterns

Before jumping into our application development, let's revisit the key behavioral design patterns we'll leverage: Command Pattern : By representing requests as objects, this pattern enables parameterization, queuing, and supports undoable operations — employing Rust's traits and structs to encapsulate actions. Observer Pattern : Establishes a one-to-many dependency so that changes in an object automatically trigger updates on its dependents, using Rust's traits and smart pointers for strong adherence to the ownership model. Strategy Pattern : Encapsulates a family of algorithms, allowing them to be interchangeable. In Rust, traits and generics allow clients to switch algorithms at runtime efficiently. Rust's rich type system and safety features enhance these patterns, enabling robust and thread-safe designs that accommodate complex problems with ease.

Designing the Chat Application

Our task is to build a chat application where users can send messages to a chat room, receiving notifications in the process. Here's how each pattern will contribute: Command Pattern : Commands will represent actions like sending messages. Observer Pattern : Users will subscribe to the chat room to get notifications. Strategy Pattern : We'll vary message processing (plain text vs. encrypted) dynamically.

Strategy Pattern: The MessageProcessor

For message processing flexibility, we implement the Strategy pattern using a MessageProcessor trait: Rust// Strategy Pattern pub trait MessageProcessor { fn process_message(&self, message: &str) -> String; } pub struct PlainTextProcessor; impl MessageProcessor for PlainTextProcessor { fn process_message(&self, message: &str) -> String { message.to_string() } } pub struct EncryptedProcessor; impl MessageProcessor for EncryptedProcessor { fn process_message(&self, message: &str) -> String { // Simple encryption: reversing the message message.chars().rev().collect() } }// Strategy Pattern pub trait MessageProcessor { fn process_message(&self, message: &str) -> String; } pub struct PlainTextProcessor; impl MessageProcessor for PlainTextProcessor { fn process_message(&self, message: &str) -> String { message.to_string() } } pub struct EncryptedProcessor; impl MessageProcessor for EncryptedProcessor { fn process_message(&self, message: &str) -> String { // Simple encryption: reversing the message message.chars().rev().collect() } } By creating different structs that implement the MessageProcessor trait, we can swap the message processing algorithm at runtime by simply changing the processor used. This flexibility allows the application to adapt to different requirements without changing its structure, demonstrating the Strategy pattern's ability to interchange algorithms dynamically.

Join the 1M+ learners on CodeSignal

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

Rust

// Strategy Pattern
pub trait MessageProcessor {
    fn process_message(&self, message: &str) -> String;
}

pub struct PlainTextProcessor;

impl MessageProcessor for PlainTextProcessor {
    fn process_message(&self, message: &str) -> String {
        message.to_string()
    }
}

pub struct EncryptedProcessor;

impl MessageProcessor for EncryptedProcessor {
    fn process_message(&self, message: &str) -> String {
        // Simple encryption: reversing the message
        message.chars().rev().collect()
    }
}

Rust

pub trait Observer {
    fn update(&self, message: &str);
}

pub struct User {
    pub name: String,
}

impl User {
    pub fn new(name: &str) -> Self {
        User {
            name: name.to_string(),
        }
    }
}

impl Observer for User {
    fn update(&self, message: &str) {
        println!("{} received message: {}", self.name, message);
    }
}

pub trait Observer {
    fn update(&self, message: &str);
}

pub struct User {
    pub name: String,
}

impl User {
    pub fn new(name: &str) -> Self {
        User {
            name: name.to_string(),
        }
    }
}

impl Observer for User {
    fn update(&self, message: &str) {
        println!("{} received message: {}", self.name, message);
    }
}

Rust

use std::collections::HashMap;

pub struct ChatRoom {
    observers: HashMap<String, Box<dyn Observer>>,
}

impl ChatRoom {
    pub fn new() -> Self {
        ChatRoom {
            observers: HashMap::new(),
        }
    }

    pub fn attach(&mut self, id: String, observer: Box<dyn Observer>) {
        self.observers.insert(id, observer);
    }

    pub fn detach(&mut self, id: &str) {
        self.observers.remove(id);
    }

    pub fn send_message(&self, message: &str) {
        self.display(message);
        self.notify(message);
    }

    fn display(&self, message: &str) {
        println!("ChatRoom displays: {}", message);
    }

    fn notify(&self, message: &str) {
        for observer in self.observers.values() {
            observer.update(message);
        }
    }
}

use std::collections::HashMap;

pub struct ChatRoom {
    observers: HashMap<String, Box<dyn Observer>>,
}

impl ChatRoom {
    pub fn new() -> Self {
        ChatRoom {
            observers: HashMap::new(),
        }
    }

    pub fn attach(&mut self, id: String, observer: Box<dyn Observer>) {
        self.observers.insert(id, observer);
    }

    pub fn detach(&mut self, id: &str) {
        self.observers.remove(id);
    }

    pub fn send_message(&self, message: &str) {
        self.display(message);
        self.notify(message);
    }

    fn display(&self, message: &str) {
        println!("ChatRoom displays: {}", message);
    }

    fn notify(&self, message: &str) {
        for observer in self.observers.values() {
            observer.update(message);
        }
    }
}

Rust

pub trait Command {
    fn execute(&self, chat_room: &mut ChatRoom);
}

pub trait Command {
    fn execute(&self, chat_room: &mut ChatRoom);
}

Rust

use crate::chat_room::ChatRoom;
use crate::message_processing::MessageProcessor;

pub struct SendMessageCommand {
    message: String,
    processor: Box<dyn MessageProcessor>,
}

impl SendMessageCommand {
    pub fn new(message: String, processor: Box<dyn MessageProcessor>) -> Self {
        SendMessageCommand { message, processor }
    }
}

impl Command for SendMessageCommand {
    fn execute(&self, chat_room: &mut ChatRoom) {
        let processed_message = self.processor.process_message(&self.message);
        chat_room.send_message(&processed_message);
    }
}

use crate::chat_room::ChatRoom;
use crate::message_processing::MessageProcessor;

pub struct SendMessageCommand {
    message: String,
    processor: Box<dyn MessageProcessor>,
}

impl SendMessageCommand {
    pub fn new(message: String, processor: Box<dyn MessageProcessor>) -> Self {
        SendMessageCommand { message, processor }
    }
}

impl Command for SendMessageCommand {
    fn execute(&self, chat_room: &mut ChatRoom) {
        let processed_message = self.processor.process_message(&self.message);
        chat_room.send_message(&processed_message);
    }
}

Rust

fn main() {
    let mut chat_room = ChatRoom::new();

    // Create and attach observers with unique IDs
    chat_room.attach("alice_id".to_string(), Box::new(User::new("Alice")));
    chat_room.attach("bob_id".to_string(), Box::new(User::new("Bob")));

    // Create commands
    let commands: Vec<Box<dyn Command>> = vec![
        Box::new(SendMessageCommand::new(
            "Hello, everyone!".to_string(),
            Box::new(EncryptedProcessor),
        )),
    ];

    // Execute commands
    for command in commands {
        command.execute(&mut chat_room);
    }

    // Detach Bob
    chat_room.detach("bob_id");

    // Send another message
    let another_command = Box::new(SendMessageCommand::new(
        "Bob has left the chat.".to_string(),
        Box::new(PlainTextProcessor),
    ));
    another_command.execute(&mut chat_room);
}

fn main() {
    let mut chat_room = ChatRoom::new();

    // Create and attach observers with unique IDs
    chat_room.attach("alice_id".to_string(), Box::new(User::new("Alice")));
    chat_room.attach("bob_id".to_string(), Box::new(User::new("Bob")));

    // Create commands
    let commands: Vec<Box<dyn Command>> = vec![
        Box::new(SendMessageCommand::new(
            "Hello, everyone!".to_string(),
            Box::new(EncryptedProcessor),
        )),
    ];

    // Execute commands
    for command in commands {
        command.execute(&mut chat_room);
    }

    // Detach Bob
    chat_room.detach("bob_id");

    // Send another message
    let another_command = Box::new(SendMessageCommand::new(
        "Bob has left the chat.".to_string(),
        Box::new(PlainTextProcessor),
    ));
    another_command.execute(&mut chat_room);
}

Rust

pub trait Observer {
    fn update(&self, message: &str);
}

pub struct User {
    pub name: String,
}

impl User {
    pub fn new(name: &str) -> Self {
        User {
            name: name.to_string(),
        }
    }
}

impl Observer for User {
    fn update(&self, message: &str) {
        println!("{} received message: {}", self.name, message);
    }
}

Rust

use std::collections::HashMap;

pub struct ChatRoom {
    observers: HashMap<String, Box<dyn Observer>>,
}

impl ChatRoom {
    pub fn new() -> Self {
        ChatRoom {
            observers: HashMap::new(),
        }
    }

    pub fn attach(&mut self, id: String, observer: Box<dyn Observer>) {
        self.observers.insert(id, observer);
    }

    pub fn detach(&mut self, id: &str) {
        self.observers.remove(id);
    }

    pub fn send_message(&self, message: &str) {
        self.display(message);
        self.notify(message);
    }

    fn display(&self, message: &str) {
        println!("ChatRoom displays: {}", message);
    }

    fn notify(&self, message: &str) {
        for observer in self.observers.values() {
            observer.update(message);
        }
    }
}

Rust

pub trait Command {
    fn execute(&self, chat_room: &mut ChatRoom);
}

Rust

use crate::chat_room::ChatRoom;
use crate::message_processing::MessageProcessor;

pub struct SendMessageCommand {
    message: String,
    processor: Box<dyn MessageProcessor>,
}

impl SendMessageCommand {
    pub fn new(message: String, processor: Box<dyn MessageProcessor>) -> Self {
        SendMessageCommand { message, processor }
    }
}

impl Command for SendMessageCommand {
    fn execute(&self, chat_room: &mut ChatRoom) {
        let processed_message = self.processor.process_message(&self.message);
        chat_room.send_message(&processed_message);
    }
}

Rust

fn main() {
    let mut chat_room = ChatRoom::new();

    // Create and attach observers with unique IDs
    chat_room.attach("alice_id".to_string(), Box::new(User::new("Alice")));
    chat_room.attach("bob_id".to_string(), Box::new(User::new("Bob")));

    // Create commands
    let commands: Vec<Box<dyn Command>> = vec![
        Box::new(SendMessageCommand::new(
            "Hello, everyone!".to_string(),
            Box::new(EncryptedProcessor),
        )),
    ];

    // Execute commands
    for command in commands {
        command.execute(&mut chat_room);
    }

    // Detach Bob
    chat_room.detach("bob_id");

    // Send another message
    let another_command = Box::new(SendMessageCommand::new(
        "Bob has left the chat.".to_string(),
        Box::new(PlainTextProcessor),
    ));
    another_command.execute(&mut chat_room);
}

Introduction

Recap of Behavioral Design Patterns

Designing the Chat Application

Strategy Pattern: The MessageProcessor

Join the 1M+ learners on CodeSignal

Observer Pattern: The Observer Trait and the User Struct

Observer Pattern: The ChatRoom Struct

Command Pattern: The Command Trait

Command Pattern: The SendMessageCommand Struct

Putting It All Together

Conclusion