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.

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:

Copy to clipboard
1root
2├── file1.txt
3├── file2.txt
4└── sub_dir
5    ├── file3.txt
6    └── nested_dir
7        └── 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.

To model this structure in Rust, we start by defining a trait that provides a common interface for both files and directories:

Rust
Copy to clipboard
1// The FileSystem trait - defines common operations for composite and leaf nodes
2pub trait FileSystem {
3    fn display(&self, depth: usize);
4    fn get_name(&self) -> &str;
5}

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.

The next step involves defining a File struct to represent individual files in our file system:

Rust
Copy to clipboard
1// Leaf node in the composite pattern
2pub struct File {
3    name: String,
4}
5
6impl File {
7    pub fn new(name: &str) -> Self {
8        File {
9            name: name.to_string(),
10        }
11    }
12}
13
14// Implement FileSystem trait for the File struct
15impl FileSystem for File {
16    fn display(&self, depth: usize) {
17        println!("{}- File: {}", "  ".repeat(depth), self.name);
18    }
19
20    fn get_name(&self) -> &str {
21        &self.name
22    }
23}

The File struct is a leaf node. It implements the FileSystem trait by providing the display method, which prints its name with appropriate indentation, and get_name, which returns its name.

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

Rust
Copy to clipboard
1// Composite node - can contain other FileSystem components
2pub struct Directory {
3    name: String,
4    // Vector of trait objects allows storing any type that implements FileSystem
5    entries: Vec<Box<dyn FileSystem>>,
6}
7
8impl Directory {
9    pub fn new(name: &str) -> Self {
10        Directory {
11            name: name.to_string(),
12            entries: Vec::new(),
13        }
14    }
15
16    // Composite operation: allows building the tree structure
17    pub fn add(&mut self, entry: Box<dyn FileSystem>) {
18        self.entries.push(entry);
19    }
20
21    // Remove an entry by name
22    pub fn remove(&mut self, name: &str) {
23        self.entries.retain(|entry| entry.get_name() != name);
24    }
25}
26
27// Implement FileSystem trait for the Directory struct
28impl FileSystem for Directory {
29    fn display(&self, depth: usize) {
30        println!("{}+ Directory: {}", "  ".repeat(depth), self.name);
31        for entry in &self.entries {
32            entry.display(depth + 1);
33        }
34    }
35
36    fn get_name(&self) -> &str {
37        &self.name
38    }
39}

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.

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

Rust
Copy to clipboard
1fn main() {
2    // Create files
3    let file1 = File::new("file1.txt");
4    let file2 = File::new("file2.txt");
5    let file3 = File::new("file3.txt");
6    let file4 = File::new("file4.txt");
7
8    // Create directories
9    let mut nested_dir = Directory::new("nested_dir");
10    nested_dir.add(Box::new(file4));
11
12    let mut sub_dir = Directory::new("sub_dir");
13    sub_dir.add(Box::new(file3));
14    sub_dir.add(Box::new(nested_dir));
15
16    let mut root = Directory::new("root");
17    root.add(Box::new(file1));
18    root.add(Box::new(file2));
19    root.add(Box::new(sub_dir));
20
21    // Display the file system
22    root.display(0);
23
24    // Expected output:
25    // + Directory: root
26    //   - File: file1.txt
27    //   - File: file2.txt
28    //   + Directory: sub_dir
29    //     - File: file3.txt
30    //     + Directory: nested_dir
31    //       - File: file4.txt
32
33    // Remove file2.txt from root
34    root.remove("file2.txt");
35
36    // Display the file system after removal
37    println!("\nAfter removing file2.txt:");
38    root.display(0);
39
40    // Expected output:
41    // + Directory: root
42    //   - File: file1.txt
43    //   + Directory: sub_dir
44    //     - File: file3.txt
45    //     + Directory: nested_dir
46    //       - File: file4.txt
47}

In this example:

• We create File instances representing individual files.
• We create Directory instances representing directories that can contain files and other directories.
• We build the file system hierarchy by adding files and directories to directories using the add method.
• We display the entire file system using the display method.
• We remove file2.txt from the root directory using the enhanced remove method.
• We display the file system again to see the effect of the removal.

The Composite Pattern in Rust offers a powerful way to work with complex hierarchical structures. By implementing the pattern in a file system context, we've seen how to:

• Treat individual and composite objects uniformly: Both File and Directory implement the FileSystem trait, allowing us to interact with them through a common interface.
• Represent hierarchical relationships: The display method and depth parameter help us visualize the nested structure.
• Use trait objects effectively: Box<dyn FileSystem> enables us to store different types in the same collection and perform dynamic dispatch.
• Enhance methods for realism: By modifying the remove method to accept a name parameter, we make our implementation more practical.

Whether you're modeling file systems, GUI components, or organizational structures, mastering the Composite Pattern will empower you to build sophisticated systems with elegance and precision. 🎯