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 - 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.

Creating Individual Components: The `File` Struct

Join the 1M+ learners on CodeSignal

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

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

Rust

// Leaf node in the composite pattern
pub struct File {
    name: String,
}

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

// Implement FileSystem trait for the File struct
impl FileSystem for File {
    fn display(&self, depth: usize) {
        println!("{}- File: {}", "  ".repeat(depth), self.name);
    }

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

// Leaf node in the composite pattern
pub struct File {
    name: String,
}

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

// Implement FileSystem trait for the File struct
impl FileSystem for File {
    fn display(&self, depth: usize) {
        println!("{}- File: {}", "  ".repeat(depth), self.name);
    }

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

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

Rust

fn main() {
    // Create files
    let file1 = File::new("file1.txt");
    let file2 = File::new("file2.txt");
    let file3 = File::new("file3.txt");
    let file4 = File::new("file4.txt");

    // Create directories
    let mut nested_dir = Directory::new("nested_dir");
    nested_dir.add(Box::new(file4));

    let mut sub_dir = Directory::new("sub_dir");
    sub_dir.add(Box::new(file3));
    sub_dir.add(Box::new(nested_dir));

    let mut root = Directory::new("root");
    root.add(Box::new(file1));
    root.add(Box::new(file2));
    root.add(Box::new(sub_dir));

    // Display the file system
    root.display(0);

    // Expected output:
    // + Directory: root
    //   - File: file1.txt
    //   - File: file2.txt
    //   + Directory: sub_dir
    //     - File: file3.txt
    //     + Directory: nested_dir
    //       - File: file4.txt

    // Remove file2.txt from root
    root.remove("file2.txt");

    // Display the file system after removal
    println!("\nAfter removing file2.txt:");
    root.display(0);

    // Expected output:
    // + Directory: root
    //   - File: file1.txt
    //   + Directory: sub_dir
    //     - File: file3.txt
    //     + Directory: nested_dir
    //       - File: file4.txt
}

fn main() {
    // Create files
    let file1 = File::new("file1.txt");
    let file2 = File::new("file2.txt");
    let file3 = File::new("file3.txt");
    let file4 = File::new("file4.txt");

    // Create directories
    let mut nested_dir = Directory::new("nested_dir");
    nested_dir.add(Box::new(file4));

    let mut sub_dir = Directory::new("sub_dir");
    sub_dir.add(Box::new(file3));
    sub_dir.add(Box::new(nested_dir));

    let mut root = Directory::new("root");
    root.add(Box::new(file1));
    root.add(Box::new(file2));
    root.add(Box::new(sub_dir));

    // Display the file system
    root.display(0);

    // Expected output:
    // + Directory: root
    //   - File: file1.txt
    //   - File: file2.txt
    //   + Directory: sub_dir
    //     - File: file3.txt
    //     + Directory: nested_dir
    //       - File: file4.txt

    // Remove file2.txt from root
    root.remove("file2.txt");

    // Display the file system after removal
    println!("\nAfter removing file2.txt:");
    root.display(0);

    // Expected output:
    // + Directory: root
    //   - File: file1.txt
    //   + Directory: sub_dir
    //     - File: file3.txt
    //     + Directory: nested_dir
    //       - File: file4.txt
}

Rust

// Leaf node in the composite pattern
pub struct File {
    name: String,
}

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

// Implement FileSystem trait for the File struct
impl FileSystem for File {
    fn display(&self, depth: usize) {
        println!("{}- File: {}", "  ".repeat(depth), self.name);
    }

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

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

Rust

fn main() {
    // Create files
    let file1 = File::new("file1.txt");
    let file2 = File::new("file2.txt");
    let file3 = File::new("file3.txt");
    let file4 = File::new("file4.txt");

    // Create directories
    let mut nested_dir = Directory::new("nested_dir");
    nested_dir.add(Box::new(file4));

    let mut sub_dir = Directory::new("sub_dir");
    sub_dir.add(Box::new(file3));
    sub_dir.add(Box::new(nested_dir));

    let mut root = Directory::new("root");
    root.add(Box::new(file1));
    root.add(Box::new(file2));
    root.add(Box::new(sub_dir));

    // Display the file system
    root.display(0);

    // Expected output:
    // + Directory: root
    //   - File: file1.txt
    //   - File: file2.txt
    //   + Directory: sub_dir
    //     - File: file3.txt
    //     + Directory: nested_dir
    //       - File: file4.txt

    // Remove file2.txt from root
    root.remove("file2.txt");

    // Display the file system after removal
    println!("\nAfter removing file2.txt:");
    root.display(0);

    // Expected output:
    // + Directory: root
    //   - File: file1.txt
    //   + Directory: sub_dir
    //     - File: file3.txt
    //     + Directory: nested_dir
    //       - File: file4.txt
}

Introduction

Understanding the Composite Pattern

Defining the `FileSystem` Trait

Creating Individual Components: The `File` Struct

Join the 1M+ learners on CodeSignal

Creating Composite Components: The `Directory` Struct

Putting It All Together

Conclusion