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

Observer Pattern: The ChatRoom Struct

Our ChatRoom struct acts as the subject, managing observers:

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);
        }
    }
}

In this implementation, ChatRoom maintains a list of observers in a HashMap. It provides methods to attach and detach observers dynamically. When a message is sent via send_message, it displays the message and notifies all observers by calling their update methods. This demonstrates how the ChatRoom acts as the subject in the Observer pattern, notifying users of new messages.

Putting It All Together

Finally, we bring all patterns together:

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);
}

In this main function:

We create a new ChatRoom instance.
We attach User observers (Alice and Bob) to the ChatRoom.
We create a list of commands, in this case, a SendMessageCommand that sends an encrypted message.
We execute the commands, which process and send the messages to the chat room.
We detach Bob from the chat room.
We send another message using a PlainTextProcessor.

This integration demonstrates the cohesiveness and power of combining Rust's behavioral design patterns into an interactive application. The Command pattern manages actions, the Observer pattern handles the subscribers, and the Strategy pattern allows dynamic selection of message processing algorithms.

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