Introduction to the Composite Pattern in Rust

Introduction

Welcome to the second lesson of our "Structural Patterns in Rust" course! 🎉 In our previous lesson, we explored the Adapter Pattern, which helps incompatible interfaces work together seamlessly. Today, we'll dive into another fundamental structural pattern: the Composite Pattern . The Composite Pattern enables us to build complex structures by composing objects into tree-like hierarchies representing part-whole relationships. This pattern allows us to treat individual objects and compositions of objects uniformly. It's particularly useful in scenarios like file systems, where directories contain files and other directories, forming a nested structure. Let's explore how to implement this pattern in Rust using a file system example.

Understanding the Composite Pattern

Imagine a file system where directories can contain both files and other directories. This structure naturally forms a tree, with directories acting as composite nodes that can hold leaf nodes (files) or other composite nodes (directories). Here's how such a file system hierarchy might look: root ├── file1.txt ├── file2.txt └── sub_dir ├── file3.txt └── nested_dir └── file4.txt In this example: Files (Leaf Nodes): Individual files like file1.txt, file2.txt, file3.txt, and file4.txt are the indivisible elements of the hierarchy. Directories (Composite Nodes): Directories like root, sub_dir, and nested_dir can contain files and other directories, allowing us to build a nested, hierarchical structure.

Defining the `FileSystem` Trait

To model this structure in Rust, we start by defining a trait that provides a common interface for both files and directories: Rust// The FileSystem trait - defines common operations for composite and leaf nodes pub trait FileSystem { fn display(&self, depth: usize); fn get_name(&self) -> &str; } The FileSystem trait declares two methods: display: Used to print the structure. The depth parameter helps us represent the hierarchy when printing: each level of depth increases the indentation, making it clear which files or directories are nested within others. get_name: Returns the name of the file or directory, useful for operations like removing entries.

Join the 1M+ learners on CodeSignal

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

Creating Composite Components: The `Directory` Struct

Now, we'll create the Directory struct that can contain files and other directories:

Rust

// Composite node - can contain other FileSystem components
pub struct Directory {
    name: String,
    // Vector of trait objects allows storing any type that implements FileSystem
    entries: Vec<Box<dyn FileSystem>>,
}

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

    // Composite operation: allows building the tree structure
    pub fn add(&mut self, entry: Box<dyn FileSystem>) {
        self.entries.push(entry);
    }

    // Remove an entry by name
    pub fn remove(&mut self, name: &str) {
        self.entries.retain(|entry| entry.get_name() != name);
    }
}

// Implement FileSystem trait for the Directory struct
impl FileSystem for Directory {
    fn display(&self, depth: usize) {
        println!("{}+ Directory: {}", "  ".repeat(depth), self.name);
        for entry in &self.entries {
            entry.display(depth + 1);
        }
    }

    fn get_name(&self) -> &str {
        &self.name
    }
}

// Composite node - can contain other FileSystem components
pub struct Directory {
    name: String,
    // Vector of trait objects allows storing any type that implements FileSystem
    entries: Vec<Box<dyn FileSystem>>,
}

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

    // Composite operation: allows building the tree structure
    pub fn add(&mut self, entry: Box<dyn FileSystem>) {
        self.entries.push(entry);
    }

    // Remove an entry by name
    pub fn remove(&mut self, name: &str) {
        self.entries.retain(|entry| entry.get_name() != name);
    }
}

// Implement FileSystem trait for the Directory struct
impl FileSystem for Directory {
    fn display(&self, depth: usize) {
        println!("{}+ Directory: {}", "  ".repeat(depth), self.name);
        for entry in &self.entries {
            entry.display(depth + 1);
        }
    }

    fn get_name(&self) -> &str {
        &self.name
    }
}

The Directory struct acts as a composite node:

The entries vector holds Box<dyn FileSystem>, allowing us to store any type that implements the FileSystem trait (both File and Directory).
The add method lets us add new entries to the directory.
The remove method allows us to remove an entry by its name.
We use Box<dyn FileSystem> to enable dynamic dispatch, allowing us to treat different types uniformly at runtime.

Putting It All Together

Let's see the Composite Pattern in action in the main function, demonstrating how we instantiate and manage our file directory structure: