subscribers - done

smart-house/README.md

@@ -168,3 +168,46 @@
 Запуск примера умного дома:
 
     cargo run --bin mocks_example
+
+## ДЗ 2026-03-05
+
+Паттерны в умном доме
+
+### Цель:
+
+Делаем код умного дома более удобным с использованием различных паттернов.
+
+### Срок:
+
+Сдать до: **2026-04-01**
+
+### Описание/Пошаговая инструкция выполнения домашнего задания:
+
+Реализовать билдер для умного дома, позволяющий инициализировать объект умного дома в [таком стиле](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=5d0527e4684f726d54dc375829d983f4).
+
+- [x] До добавления первой комнаты, билдер запрещает добавлять устройства. Это должно контролироваться компилятором.
+
+Реализовать компоновщик для построения отчёта об объектах умного дома в [таком стиле](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=c07dfc726e8ccbccdcc2d88a79d3f190).
+
+- [x] Использовать статический полиморфизм (дженерики).
+- [x] Вызов метода report() должен выводить в терминал отчёт обо всех добавленных объектах.
+
+Добавить возможность добавления callback-ов в объект комнаты, которые срабатывают при добавлении новых устройств в комнату (паттерн Observer).
+
+- [x] Использовать динамический полиморфизм (трейт-объекты).
+- [x] Можно передавать как объект-subscriber, так и [замыкание](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=06e9dc9bcce297d1e80a22d7e9338ee8).
+
+Добавить example-ы, демонстрирующие новый функционал.
+
+**Критерии оценки:**
+
+- Package успешно собирается.
+- Приложение-пример успешно выполняется.
+- Команды cargo clippy и cargo fmt --check не выводят ошибок и предупреждений.
+- Присутствуют и успешно выполняются модульные тесты.
+
+### Демонстационные примеры
+
+- `src/bin/house_builder.rs` - билдер для умного дома
+- `src/bin/reporter.rs` - компоновщик для построения отчета
+- `src/bin/subscribers.rs` - добавление коллбеков в объект комнаты

smart-house/src/bin/house_builder.rs

@@ -0,0 +1,11 @@
+use smart_house::{HouseBuilder, PowerSocket, PrintStatus, Thermometer};
+
+fn main() {
+    let house = HouseBuilder::new()
+        .add_room("Main")
+        .add_device("PSockA", PowerSocket::stub(12.0, false))
+        .add_room("Hall")
+        .add_device("ThermA", Thermometer::stub(18.5))
+        .build();
+    house.print_status();
+}

smart-house/src/bin/mocks_example.rs

@@ -7,7 +7,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let dev = house.get_room_mut("Main").unwrap().get_device_mut("PSocA").unwrap();
     if let Device::PowerSocket(psoc) = dev {
-        psoc.set_on(!psoc.is_on());
+        psoc.set_on(!psoc.is_on().unwrap()).unwrap();
     }
 
     house.print_status();

smart-house/src/bin/power_socket_client.rs

@@ -10,7 +10,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("{}", power_socket.display());
 
     std::thread::sleep(Duration::from_secs(2));
-    power_socket.set_on(!power_socket.is_on());
+    power_socket.set_on(!power_socket.is_on().unwrap()).unwrap();
 
     println!("{}", power_socket0.display());
     println!("{}", power_socket.display());

smart-house/src/bin/reporter.rs

@@ -0,0 +1,17 @@
+use smart_house::{HouseBuilder, PowerSocket, Reporter, Thermometer};
+
+fn main() {
+    let house = HouseBuilder::new()
+        .add_room("Main")
+        .add_device("PSockB", PowerSocket::stub(12.0, false))
+        .add_room("Hall")
+        .add_device("ThermB", Thermometer::stub(18.5))
+        .build();
+
+    Reporter::new()
+        .add_reportable(house.get_room("Main").unwrap())
+        .add_reportable(house.get_device("Main", "PSockB").unwrap())
+        .add_reportable(house.get_room("Hall").unwrap())
+        .add_reportable(house.get_device("Hall", "ThermB").unwrap())
+        .report();
+}

smart-house/src/bin/stubs_example.rs

@@ -60,7 +60,7 @@ fn switch_off_power_socket_in_hall_demo(house: &mut House) {
         println!("FAILED!");
         return;
     };
-    power_socket.set_on(false);
+    power_socket.set_on(false).unwrap();
     println!("SUCCESS");
     house.print_status();
 }

smart-house/src/bin/subscribers.rs

@@ -0,0 +1,22 @@
+use smart_house::{Device, PowerSocket, Room, Subscriber};
+
+fn main() {
+    let mut room = Room::default();
+
+    room.subscribe(MySubscriber::default());
+
+    room.subscribe(|dev: &Device| {
+        println!("device added: {}", dev.display());
+    });
+
+    room.insert_device("", PowerSocket::stub(12.0, false).into());
+}
+
+#[derive(Default)]
+struct MySubscriber {}
+
+impl Subscriber for MySubscriber {
+    fn on_event(&mut self, dev: &Device) {
+        println!("DEVICE ADDED: {}", dev.display());
+    }
+}

smart-house/src/builders.rs

@@ -0,0 +1,53 @@
+use crate::{Device, House, Room};
+use std::collections::HashMap;
+
+pub struct HouseBuilder {
+    rooms: HashMap<String, Room>,
+}
+
+impl HouseBuilder {
+    pub fn new() -> Self {
+        Self { rooms: HashMap::new() }
+    }
+
+    pub fn add_room(self, name: &str) -> RoomBuilder {
+        RoomBuilder {
+            parent: self,
+            name: name.to_string(),
+            devices: HashMap::new(),
+        }
+    }
+
+    pub fn build(self) -> House {
+        House::new(self.rooms)
+    }
+}
+
+impl Default for HouseBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub struct RoomBuilder {
+    parent: HouseBuilder,
+    name: String,
+    devices: HashMap<String, Device>,
+}
+
+impl RoomBuilder {
+    pub fn add_device(mut self, name: &str, device: impl Into<Device>) -> Self {
+        self.devices.insert(name.to_string(), device.into());
+        self
+    }
+
+    pub fn add_room(mut self, name: &str) -> RoomBuilder {
+        self.parent.rooms.insert(self.name, Room::new(self.devices));
+        self.parent.add_room(name)
+    }
+
+    pub fn build(mut self) -> House {
+        self.parent.rooms.insert(self.name, Room::new(self.devices));
+        self.parent.build()
+    }
+}

smart-house/src/device.rs

@@ -1,5 +1,6 @@
 use crate::PrintStatus;
 use std::fmt::Display;
+use std::io::Write;
 
 #[derive(Debug)]
 pub enum Device {
@@ -33,8 +34,8 @@ impl From<super::PowerSocket> for Device {
 }
 
 impl PrintStatus for Device {
-    fn print_status(&self) {
-        println!("{}", self.display());
+    fn print_status_into(&self, out: &mut dyn Write) -> Result<(), std::io::Error> {
+        out.write_fmt(format_args!("{}", self.display()))
     }
 }
 

smart-house/src/house.rs

@@ -1,5 +1,6 @@
 use crate::{Device, Error, PrintStatus, Room};
 use std::collections::HashMap;
+use std::io::Write;
 
 #[derive(Debug)]
 pub struct House {
@@ -39,13 +40,15 @@ impl House {
 }
 
 impl PrintStatus for House {
-    fn print_status(&self) {
+    fn print_status_into(&self, out: &mut dyn Write) -> Result<(), std::io::Error> {
         for (room_name, room) in self.rooms.iter() {
-            println!("{}:", room_name);
-            println!("{}", "-".repeat(32));
-            room.print_status();
+            out.write_fmt(format_args!("{}:", room_name))?;
+            out.write_fmt(format_args!("{}", "-".repeat(32)))?;
+            room.print_status_into(out)?;
+            out.write_fmt(format_args!("\n"))?;
             println!();
         }
+        Ok(())
     }
 }
 
@@ -108,7 +111,7 @@ mod tests {
         let Device::PowerSocket(powers_socket) = house.get_room_mut("main").unwrap().get_device_mut("PSocA").unwrap() else {
             unreachable!()
         };
-        powers_socket.set_on(true);
+        powers_socket.set_on(true).unwrap();
 
         assert_eq!(
             format!("{}", house.get_room("main").unwrap().get_device("PSocA").unwrap().display()),

smart-house/src/lib.rs

@@ -4,13 +4,19 @@ mod house;
 mod power_socket;
 #[macro_use]
 mod room;
+mod builders;
 mod print_status;
+mod reporter;
+mod subscriber;
 mod thermometer;
 
+pub use builders::{HouseBuilder, RoomBuilder};
 pub use device::Device;
 pub use error::Error;
 pub use house::House;
 pub use power_socket::PowerSocket;
 pub use print_status::PrintStatus;
+pub use reporter::Reporter;
 pub use room::Room;
+pub use subscriber::Subscriber;
 pub use thermometer::Thermometer;

smart-house/src/power_socket.rs

@@ -1,6 +1,5 @@
 use std::cell::RefCell;
 use std::fmt::{Debug, Display};
-use std::io;
 use std::io::{Read, Write};
 use std::net::{SocketAddr, TcpStream};
 use std::time::Duration;
@@ -17,35 +16,50 @@ impl PowerSocket {
         }
     }
 
-    pub fn connect(addr: &str) -> Result<Self, io::Error> {
+    pub fn connect(addr: &str) -> Result<Self, std::io::Error> {
         let handle = PowerSocketClient::new(addr)?;
         Ok(Self { handle: Box::new(handle) })
     }
 
-    pub fn is_on(&self) -> bool {
+    pub fn is_on(&self) -> Result<bool, std::io::Error> {
         self.handle.is_on()
     }
 
-    pub fn set_on(&mut self, on: bool) {
+    pub fn set_on(&mut self, on: bool) -> Result<(), std::io::Error> {
         self.handle.set_on(on)
     }
 
-    pub fn get_power(&self) -> f32 {
+    pub fn get_power(&self) -> Result<f32, std::io::Error> {
         self.handle.get_power()
     }
 
     pub fn display(&self) -> impl Display {
-        let state = if self.is_on() { "ON" } else { "OFF" };
-        format!("PowerSocket[ {} : {:02.1} ]", state, self.get_power())
+        const ERR: &str = "PowerSocket[ ERR ]";
+        let power = match self.get_power() {
+            Ok(power) => power,
+            Err(e) => {
+                eprintln!("error on get power: {:?}", e);
+                return ERR.to_string();
+            }
+        };
+        let on = match self.is_on() {
+            Ok(state) => state,
+            Err(e) => {
+                eprintln!("error on get state: {:?}", e);
+                return ERR.to_string();
+            }
+        };
+        let state = if on { "ON" } else { "OFF" };
+        format!("PowerSocket[ {} : {:02.1} ]", state, power)
     }
 }
 
 trait PowerSocketHandle: Debug {
-    fn is_on(&self) -> bool;
+    fn is_on(&self) -> Result<bool, std::io::Error>;
 
-    fn set_on(&mut self, on: bool);
+    fn set_on(&mut self, on: bool) -> Result<(), std::io::Error>;
 
-    fn get_power(&self) -> f32;
+    fn get_power(&self) -> Result<f32, std::io::Error>;
 }
 
 #[derive(Debug)]
@@ -61,16 +75,17 @@ impl PowerSocketStub {
 }
 
 impl PowerSocketHandle for PowerSocketStub {
-    fn is_on(&self) -> bool {
-        self.on
+    fn is_on(&self) -> Result<bool, std::io::Error> {
+        Ok(self.on)
     }
 
-    fn set_on(&mut self, on: bool) {
-        self.on = on
+    fn set_on(&mut self, on: bool) -> Result<(), std::io::Error> {
+        self.on = on;
+        Ok(())
     }
 
-    fn get_power(&self) -> f32 {
-        if self.on { self.power_rate } else { 0.0 }
+    fn get_power(&self) -> Result<f32, std::io::Error> {
+        Ok(if self.on { self.power_rate } else { 0.0 })
     }
 }
 
@@ -82,8 +97,8 @@ struct PowerSocketClient {
 }
 
 impl PowerSocketClient {
-    fn new(addr: &str) -> Result<Self, io::Error> {
-        let addr: SocketAddr = addr.parse().map_err(io::Error::other)?;
+    fn new(addr: &str) -> Result<Self, std::io::Error> {
+        let addr: SocketAddr = addr.parse().map_err(std::io::Error::other)?;
         let stream = TcpStream::connect_timeout(&addr, TIMEOUT)?;
         stream.set_write_timeout(Some(TIMEOUT))?;
         stream.set_read_timeout(Some(TIMEOUT))?;
@@ -97,28 +112,44 @@ const CMD_TURN_OFF: u8 = 3;
 const CMD_GET_POWER: u8 = 4;
 
 impl PowerSocketHandle for PowerSocketClient {
-    fn is_on(&self) -> bool {
+    fn is_on(&self) -> Result<bool, std::io::Error> {
         let mut buf = [CMD_GET_ON; 1];
-        self.stream.borrow_mut().write_all(&buf).expect("CMD_GET_ON request should be sent");
-        self.stream.borrow_mut().read_exact(&mut buf).expect("CMD_GET_ON response should be received");
-        !matches!(buf, [0])
-    }
-
-    fn set_on(&mut self, on: bool) {
-        let cmd = if on { CMD_TURN_ON } else { CMD_TURN_OFF };
-        let mut buf = [cmd; 1];
-        self.stream.borrow_mut().write_all(&buf).expect("change state request should be sent");
-        self.stream.borrow_mut().read_exact(&mut buf).expect("change state response should be received");
-    }
-
-    fn get_power(&self) -> f32 {
-        let mut buf = [CMD_GET_POWER; 4];
-        self.stream.borrow_mut().write_all(&buf[0..1]).expect("CMD_GET_POWER request should be sent");
+        self.stream
+            .borrow_mut()
+            .write_all(&buf)
+            .map_err(|e| std::io::Error::other(format!("CMD_GET_ON request error: {:?}", e)))?;
         self.stream
             .borrow_mut()
             .read_exact(&mut buf)
-            .expect("CMD_GET_POWER response should be received");
-        f32::from_le_bytes(buf)
+            .map_err(|e| std::io::Error::other(format!("CMD_GET_ON response error: {:?}", e)))?;
+        Ok(!matches!(buf, [0]))
+    }
+
+    fn set_on(&mut self, on: bool) -> Result<(), std::io::Error> {
+        let cmd = if on { CMD_TURN_ON } else { CMD_TURN_OFF };
+        let mut buf = [cmd; 1];
+        self.stream
+            .borrow_mut()
+            .write_all(&buf)
+            .map_err(|e| std::io::Error::other(format!("change state request error: {:?}", e)))?;
+        self.stream
+            .borrow_mut()
+            .read_exact(&mut buf)
+            .map_err(|e| std::io::Error::other(format!("change state response error: {:?}", e)))?;
+        Ok(())
+    }
+
+    fn get_power(&self) -> Result<f32, std::io::Error> {
+        let mut buf = [CMD_GET_POWER; 4];
+        self.stream
+            .borrow_mut()
+            .write_all(&buf[0..1])
+            .map_err(|e| std::io::Error::other(format!("CMD_GET_POWER request error: {:?}", e)))?;
+        self.stream
+            .borrow_mut()
+            .read_exact(&mut buf)
+            .map_err(|e| std::io::Error::other(format!("CMD_GET_POWER response error: {:?}", e)))?;
+        Ok(f32::from_le_bytes(buf))
     }
 }
 
@@ -129,12 +160,12 @@ mod tests {
     #[test]
     fn smoke_test() {
         let mut power_socket = PowerSocket::stub(12.4, false);
-        assert!(!power_socket.is_on());
-        assert_eq!(power_socket.get_power(), 0.0);
+        assert!(!power_socket.is_on().unwrap());
+        assert_eq!(power_socket.get_power().unwrap(), 0.0);
 
-        power_socket.set_on(true);
-        assert!(power_socket.is_on());
-        assert_eq!(power_socket.get_power(), 12.4);
+        power_socket.set_on(true).unwrap();
+        assert!(power_socket.is_on().unwrap());
+        assert_eq!(power_socket.get_power().unwrap(), 12.4);
     }
 
     #[test]

smart-house/src/print_status.rs

@@ -1,3 +1,9 @@
 pub trait PrintStatus {
-    fn print_status(&self);
+    fn print_status_into(&self, out: &mut dyn std::io::Write) -> Result<(), std::io::Error>;
+
+    fn print_status(&self) {
+        if let Err(e) = self.print_status_into(&mut std::io::stdout()) {
+            eprintln!("Unexpected print error: {:?}", e);
+        }
+    }
 }

smart-house/src/reporter.rs

@@ -0,0 +1,30 @@
+use crate::PrintStatus;
+
+pub struct Reporter<'a> {
+    reportables: Vec<&'a dyn PrintStatus>,
+}
+
+impl<'a> Reporter<'a> {
+    pub fn new() -> Self {
+        Self { reportables: Vec::new() }
+    }
+
+    pub fn add_reportable<T: PrintStatus>(mut self, reportable: &'a T) -> Self {
+        self.reportables.push(reportable);
+        self
+    }
+
+    pub fn report(&self) {
+        println!("{}", "=".repeat(16));
+        for reportable in &self.reportables {
+            reportable.print_status();
+            println!("\n{}", "=".repeat(16));
+        }
+    }
+}
+
+impl<'a> Default for Reporter<'a> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

smart-house/src/room.rs

@@ -1,14 +1,19 @@
-use crate::{Device, PrintStatus};
+use crate::{Device, PrintStatus, Subscriber};
 use std::collections::HashMap;
+use std::fmt::{Debug, Formatter};
+use std::io::Write;
 
-#[derive(Debug)]
 pub struct Room {
     devices: HashMap<String, Device>,
+    subscribers: Vec<Box<dyn Subscriber>>,
 }
 
 impl Room {
     pub fn new(devices: HashMap<String, Device>) -> Self {
-        Self { devices }
+        Self {
+            devices,
+            subscribers: Vec::new(),
+        }
     }
 
     pub fn get_device(&self, name: &str) -> Option<&Device> {
@@ -20,20 +25,43 @@ impl Room {
     }
 
     pub fn insert_device(&mut self, name: &str, device: Device) -> Option<Device> {
+        for subscriber in &mut self.subscribers {
+            subscriber.on_event(&device);
+        }
         self.devices.insert(name.to_string(), device)
     }
 
     pub fn remove_device(&mut self, name: &str) -> Option<Device> {
         self.devices.remove(name)
     }
+
+    pub fn subscribe(&mut self, subscriber: impl Subscriber + 'static) {
+        self.subscribers.push(Box::new(subscriber));
+    }
 }
 
 impl PrintStatus for Room {
-    fn print_status(&self) {
+    fn print_status_into(&self, out: &mut dyn Write) -> Result<(), std::io::Error> {
         for (name, device) in self.devices.iter() {
-            print!("{} => ", name);
-            device.print_status();
+            out.write_fmt(format_args!("{} => ", name))?;
+            device.print_status_into(out)?;
         }
+        Ok(())
+    }
+}
+
+impl Debug for Room {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Room")
+            .field("devices", &self.devices)
+            .field("subscribers.len()", &self.subscribers.len())
+            .finish()
+    }
+}
+
+impl Default for Room {
+    fn default() -> Self {
+        Room::new(HashMap::new())
     }
 }
 
@@ -70,7 +98,7 @@ mod tests {
         let Device::PowerSocket(power_socket) = room.get_device_mut("PSoc").unwrap() else {
             unreachable!()
         };
-        power_socket.set_on(true);
+        power_socket.set_on(true).unwrap();
 
         assert_eq!(format!("{}", room.get_device("PSoc").unwrap().display()), "DEV:PowerSocket[ ON : 12.3 ]");
         assert_eq!(format!("{}", room.get_device("Therm").unwrap().display()), "DEV:Thermometer[ 21.6 ]");
@@ -92,7 +120,7 @@ mod tests {
         let Some(Device::Thermometer(removed)) = room.remove_device("Therm") else {
             unreachable!()
         };
-        assert_eq!(removed.get_temperature(), 21.56);
+        assert_eq!(removed.get_temperature().unwrap(), 21.56);
         assert_eq!(room.devices.len(), 2);
     }
 }

smart-house/src/subscriber.rs

@@ -0,0 +1,14 @@
+use crate::Device;
+
+pub trait Subscriber {
+    fn on_event(&mut self, device: &Device);
+}
+
+impl<F> Subscriber for F
+where
+    F: Fn(&Device),
+{
+    fn on_event(&mut self, value: &Device) {
+        self(value)
+    }
+}

smart-house/src/thermometer.rs

@@ -21,17 +21,24 @@ impl Thermometer {
         Ok(Self { handle: Box::new(handle) })
     }
 
-    pub fn get_temperature(&self) -> f32 {
+    pub fn get_temperature(&self) -> Result<f32, std::io::Error> {
         self.handle.get_temperature()
     }
 
     pub fn display(&self) -> impl Display {
-        format!("Thermometer[ {:02.1} ]", self.get_temperature())
+        let output = self.get_temperature();
+        match output {
+            Ok(v) => format!("Thermometer[ {:02.1} ]", v),
+            Err(e) => {
+                eprintln!("error fetching temperature: {:?}", e);
+                "Thermometer[ ERR ]".to_string()
+            }
+        }
     }
 }
 
 trait ThermometerHandle: Debug {
-    fn get_temperature(&self) -> f32;
+    fn get_temperature(&self) -> Result<f32, std::io::Error>;
 }
 
 #[derive(Debug)]
@@ -46,8 +53,8 @@ impl ThermometerHandleStub {
 }
 
 impl ThermometerHandle for ThermometerHandleStub {
-    fn get_temperature(&self) -> f32 {
-        self.temperature
+    fn get_temperature(&self) -> Result<f32, std::io::Error> {
+        Ok(self.temperature)
     }
 }
 
@@ -91,8 +98,8 @@ impl ThermometerClient {
 }
 
 impl ThermometerHandle for ThermometerClient {
-    fn get_temperature(&self) -> f32 {
-        f32::from_le_bytes(self.value.load(Ordering::Relaxed).to_le_bytes())
+    fn get_temperature(&self) -> Result<f32, std::io::Error> {
+        Ok(f32::from_le_bytes(self.value.load(Ordering::Relaxed).to_le_bytes()))
     }
 }
 
@@ -103,7 +110,7 @@ mod tests {
     #[test]
     fn smoke_test() {
         let thermometer = Thermometer::stub(20.0);
-        assert_eq!(thermometer.get_temperature(), 20.0);
+        assert_eq!(thermometer.get_temperature().unwrap(), 20.0);
     }
 
     #[test]