Welcome back! 🚀 We are embarking on an exciting journey into "Applying Design Patterns for Real-World Problems using Rust". This final course of the Mastering Design Patterns with Rust path will guide you in integrating all the design patterns you've encountered so far into real-world applications. In this first lesson, we will consider the Factory Method and Adapter patterns, demonstrating their utility by building an efficient and flexible smart home system. Get ready to enhance your coding toolkit and prepare to make your smart home management system more agile and future-proof. Let's dive in!

Before writing any code, it's vital to map out your design. This ensures the development of robust, scalable, and maintainable systems. Here’s how we plan to implement the Factory Method and Adapter design patterns in our smart home project:

1. Factory Method Pattern:

   • Purpose: To encapsulate object creation, allowing easier extension with minimal code changes.
   • Steps:
     • Define a trait (SmartDevice).
     • Create specific device structs (Thermostat, Light) implementing the trait.
     • Implement factory structs (ThermostatFactory, LightFactory) providing methods to create these devices.

2. Adapter Pattern:

   • Purpose: To allow incompatible interfaces to work seamlessly together.
   • Steps:
     • Implement a trait (SmartDevice) for adaptability.
     • Create adapter structs (ThermostatAdapter) adapting existing classes (HomeKitThermostat) to this trait.

Let’s start by setting up the foundational elements — our smart devices — before diving into design patterns. We’ll define a trait SmartDevice and implement the specific structs Thermostat and Light.

Rust
Copy to clipboard
1// Trait representing a smart device
2pub trait SmartDevice {
3    fn get_status(&self) -> String;
4}
5
6// Implementation for a Thermostat
7pub struct Thermostat;
8
9impl SmartDevice for Thermostat {
10    fn get_status(&self) -> String {
11        "Thermostat is set to 22°C".to_string()
12    }
13}
14
15// Implementation for a Light
16pub struct Light;
17
18impl SmartDevice for Light {
19    fn get_status(&self) -> String {
20        "Light is on".to_string()
21    }
22}

Now, let's integrate the Factory Method pattern.

The Factory Method pattern is a go-to solution for creating instances of smart devices in a scalable manner. This pattern allows us to define a trait for device creation, derive specific factories, and manage device instances efficiently.

We will define a trait DeviceFactory and implement concrete factory structs ThermostatFactory and LightFactory. These factories will manage the creation of different SmartDevice objects.

Rust
Copy to clipboard
1// Trait for creating smart devices
2pub trait DeviceFactory {
3    fn create_device(&self) -> Box<dyn SmartDevice>;
4}
5
6// Factory for creating Thermostat instances
7pub struct ThermostatFactory;
8
9impl DeviceFactory for ThermostatFactory {
10    fn create_device(&self) -> Box<dyn SmartDevice> {
11        Box::new(Thermostat)
12    }
13}
14
15// Factory for creating Light instances
16pub struct LightFactory;
17
18impl DeviceFactory for LightFactory {
19    fn create_device(&self) -> Box<dyn SmartDevice> {
20        Box::new(Light)
21    }
22}

Let’s put our Factory Method pattern into action by creating instances of the devices through factory structs and executing their functionalities.

Rust
Copy to clipboard
1fn main() {
2    let thermostat_factory = ThermostatFactory;
3    let light_factory = LightFactory;
4
5    let thermostat = thermostat_factory.create_device();
6    let light = light_factory.create_device();
7
8    println!("{}", thermostat.get_status());  // Output: Thermostat is set to 22°C
9    println!("{}", light.get_status());       // Output: Light is on
10}

To allow our smart home devices to adapt to diverse interfaces, we will utilize the Adapter pattern. This will enable existing classes to integrate seamlessly within our system. We’ll demonstrate this using an existing HomeKitThermostat class, adapted via ThermostatAdapter.

Rust
Copy to clipboard
1// Existing class from a third-party library
2pub struct HomeKitThermostat;
3
4impl HomeKitThermostat {
5    pub fn current_temperature(&self) -> String {
6        "Temperature is 22°C".to_string()
7    }
8}
9
10// Adapter adapting HomeKitThermostat to SmartDevice interface
11pub struct ThermostatAdapter {
12    pub homekit_thermostat: HomeKitThermostat,
13}
14
15impl SmartDevice for ThermostatAdapter {
16    fn get_status(&self) -> String {
17        self.homekit_thermostat.current_temperature()
18    }
19}

We will now test our adapter design by integrating it into the smart home system and verifying its functionality.

Rust
Copy to clipboard
1fn main() {
2    let homekit_thermostat = HomeKitThermostat;
3    let adapted_thermostat = ThermostatAdapter { homekit_thermostat };
4    
5    println!("{}", adapted_thermostat.get_status());  // Output: Temperature is 22°C
6}

By harnessing the power of the Factory Method and Adapter patterns in Rust, we've enhanced the modularity and adaptability of our smart home system. You've observed how factories can streamline device instantiation and how adapters can integrate pre-existing systems into new architectures. Embrace these patterns, and continue refining your design skills for real-world applications. Keep coding and let your designs shine! 🌟