homework: remove names

smart-house/src/house.rs

@@ -3,21 +3,12 @@ use std::collections::HashMap;
 
 #[derive(Debug)]
 pub struct House {
-    address: String,
     rooms: HashMap<String, Room>,
 }
 
 impl House {
-    pub fn new(address: impl AsRef<str>, rooms: Box<[Room]>) -> Self {
-        let rooms = rooms.into_iter().map(|r| (r.get_name().to_string(), r)).collect();
-        Self {
-            address: address.as_ref().to_string(),
-            rooms,
-        }
-    }
-
-    pub fn get_address(&self) -> &str {
-        &self.address
+    pub fn new(rooms: HashMap<String, Room>) -> Self {
+        Self { rooms }
     }
 
     pub fn get_room(&self, key: &str) -> Option<&Room> {
@@ -28,28 +19,28 @@ impl House {
         self.rooms.get_mut(key)
     }
 
-    pub fn insert_room(&mut self, room: Room) -> Option<Room> {
-        self.rooms.insert(room.get_name().to_string(), room)
+    pub fn insert_room(&mut self, name: &str, room: Room) -> Option<Room> {
+        self.rooms.insert(name.to_string(), room)
     }
 
     pub fn remove_room(&mut self, key: &str) -> Option<Room> {
         self.rooms.remove(key)
     }
 
-    pub fn get_device(&self, room: &str, device: &str) -> Result<&Device, Error> {
-        let Some(room) = self.get_room(room) else {
-            return Err(Error::new(format!("no room named '{}' found", room)));
+    pub fn get_device(&self, room_name: &str, device_name: &str) -> Result<&Device, Error> {
+        let Some(room) = self.get_room(room_name) else {
+            return Err(Error::new(format!("no room named '{}' found", room_name)));
         };
-        let Some(device) = room.get_device(device) else {
-            return Err(Error::new(format!("no device named '{}' found in room '{}'", device, room.get_name())));
+        let Some(device) = room.get_device(device_name) else {
+            return Err(Error::new(format!("no device named '{}' found in room '{}'", device_name, room_name)));
         };
         Ok(device)
     }
 
     pub fn print_status(&self) {
-        println!("HOUSE '{}':", self.address);
-        println!("{}", "=".repeat(32));
-        for (_, room) in self.rooms.iter() {
+        for (room_name, room) in self.rooms.iter() {
+            println!("{}:", room_name);
+            println!("{}", "-".repeat(32));
             room.print_status();
             println!();
         }
@@ -63,42 +54,53 @@ mod tests {
 
     fn create_test_house() -> House {
         House::new(
-            "Best street, 777",
-            Box::new([
-                Room::new(
-                    "main",
-                    Box::new([
-                        Thermometer::new("ThermA", 20.0).into(),
-                        PowerSocket::new("PSocA", 12.34, false).into(),
-                        PowerSocket::new("PSocB", 10.01, true).into(),
-                    ]),
+            [
+                (
+                    "main".to_string(),
+                    Room::new(
+                        [
+                            ("ThermA".to_string(), Thermometer::new(20.0).into()),
+                            ("PSocA".to_string(), PowerSocket::new(12.34, false).into()),
+                            ("PSocB".to_string(), PowerSocket::new(10.01, true).into()),
+                        ]
+                        .into_iter()
+                        .collect(),
+                    ),
                 ),
-                Room::new(
-                    "bedroom",
-                    Box::new([PowerSocket::new("PSocC", 11.11, true).into(), Thermometer::new("ThermB", 17.99).into()]),
+                (
+                    "bedroom".to_string(),
+                    Room::new(
+                        [
+                            ("PSocC".to_string(), PowerSocket::new(11.11, true).into()),
+                            ("ThermB".to_string(), Thermometer::new(17.99).into()),
+                        ]
+                        .into_iter()
+                        .collect(),
+                    ),
                 ),
-            ]),
+            ]
+            .into_iter()
+            .collect(),
         )
     }
 
     #[test]
     fn smoke_test() {
         let mut house = create_test_house();
+        assert_eq!(house.rooms.len(), 2);
         house.print_status();
-        assert_eq!(house.address, "Best street, 777");
-        assert_eq!(house.get_address(), "Best street, 777");
 
         assert_eq!(
             format!("{}", house.get_room("main").unwrap().get_device("ThermA").unwrap().display()),
-            "DEV:ThermA[ 20.0 ]"
+            "DEV:Thermometer[ 20.0 ]"
         );
         assert_eq!(
             format!("{}", house.get_room("main").unwrap().get_device("PSocA").unwrap().display()),
-            "DEV:PSocA[ OFF : 0.0 ]"
+            "DEV:PowerSocket[ OFF : 0.0 ]"
         );
         assert_eq!(
             format!("{}", house.get_room("bedroom").unwrap().get_device("PSocC").unwrap().display()),
-            "DEV:PSocC[ ON : 11.1 ]"
+            "DEV:PowerSocket[ ON : 11.1 ]"
         );
 
         let Device::PowerSocket(powers_socket) = house.get_room_mut("main").unwrap().get_device_mut("PSocA").unwrap() else {
@@ -108,7 +110,7 @@ mod tests {
 
         assert_eq!(
             format!("{}", house.get_room("main").unwrap().get_device("PSocA").unwrap().display()),
-            "DEV:PSocA[ ON : 12.3 ]"
+            "DEV:PowerSocket[ ON : 12.3 ]"
         );
     }
 
@@ -121,15 +123,14 @@ mod tests {
     #[test]
     fn test_add_remove() {
         let mut house = create_test_house();
-        let room = Room::new("empty", Box::new([]));
+        let room = Room::new(HashMap::new());
 
-        let result = house.insert_room(room);
+        let result = house.insert_room("empty", room);
         assert!(result.is_none());
         assert_eq!(house.rooms.len(), 3);
 
         let Some(result) = house.remove_room("bedroom") else { unreachable!() };
-        assert_eq!(result.get_name(), "bedroom");
-        assert_eq!(house.rooms.len(), 2);
+        assert_eq!(result.get_device("ThermB").unwrap().display().to_string(), "DEV:Thermometer[ 18.0 ]");
     }
 
     #[test]
@@ -143,6 +144,6 @@ mod tests {
         assert_eq!(result.unwrap_err().to_string(), "no device named 'dummy' found in room 'main'");
 
         let result = house.get_device("main", "ThermA");
-        assert_eq!(result.unwrap().get_name(), "ThermA");
+        assert_eq!(result.unwrap().display().to_string(), "DEV:Thermometer[ 20.0 ]");
     }
 }