add Room struct

practice/.gitignore

@@ -1 +0,0 @@
-/target/

practice/Cargo.lock

@@ -1,7 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "practice"
-version = "0.0.0"

practice/Cargo.toml

@@ -1,6 +0,0 @@
-[package]
-name = "practice"
-version = "0.0.0"
-edition = "2024"
-
-[dependencies]

practice/src/bin/a_compare.rs

@@ -1,21 +0,0 @@
-// Напиúите функøиĀ compare<T: PartialOrd>(a: T, b: T) -> T, котораā:
-// ● Возвраûает наиболþúий из двух аргументов (a или b).
-// ● Исполþзуйте трейт PartialOrd длā сравнениā.
-
-#![allow(clippy::approx_constant)]
-
-fn compare<T>(a: T, b: T) -> T
-where
-    T: PartialOrd,
-{
-    if a >= b { a } else { b }
-}
-
-fn main() {
-    println!("{}", compare(5, 10)); // 10
-    println!("{}", compare('a', 'z')); // z
-
-    // Также работает с другими типами, реализующими PartialOrd
-    println!("{}", compare(3.14, 2.71)); // 3.14
-    println!("{}", compare("apple", "banana")); // "banana"
-}

practice/src/bin/b_pair.rs

@@ -1,35 +0,0 @@
-// Создайте структуру Pair<T, U> с двумā полāми разнýх типов:
-// ● Реализуйте метод new(first: T, second: U) -> Self.
-// ● Добавþте метод swap(self) -> Pair<U, T>, которýй менāет местами знаùениā полей.
-
-#![allow(clippy::approx_constant)]
-
-#[derive(Debug)]
-struct Pair<T, U> {
-    first: T,
-    second: U,
-}
-
-impl<T, U> Pair<T, U> {
-    // Создаем новую пару
-    fn new(first: T, second: U) -> Self {
-        Self { first, second }
-    }
-
-    // Меняем местами значения
-    fn swap(self) -> Pair<U, T> {
-        Pair::new(self.second, self.first)
-    }
-}
-
-fn main() {
-    let pair = Pair::new(42, "hello");
-    let swapped = pair.swap();
-
-    println!("{:?}", swapped); // Pair("hello", 42)
-
-    // Дополнительный пример с другими типами
-    let float_str_pair = Pair::new(3.14, "pi");
-    let swapped_pair = float_str_pair.swap();
-    println!("{:?}", swapped_pair); // Pair("pi", 3.14)
-}

practice/src/bin/c_area.rs

@@ -1,64 +0,0 @@
-// 1. Определите типаж Area с методом area(&self) -> f64.
-// 2. Реализуйте его длā структур Circle (с полем radius: f64) и Square (с полем side: f64).
-// 3. Напишите обобщенную функцию print_area<T: Area>(shape: T), которая печатает площадь фигуру.
-
-// Определяем типаж Area
-trait Area {
-    fn area(&self) -> f64;
-}
-
-// Структура Circle
-struct Circle {
-    radius: f64,
-}
-
-// Реализация Area для Circle
-impl Area for Circle {
-    fn area(&self) -> f64 {
-        std::f64::consts::PI * self.radius * self.radius
-    }
-}
-
-// Структура Square
-struct Square {
-    side: f64,
-}
-
-// Реализация Area для Square
-impl Area for Square {
-    fn area(&self) -> f64 {
-        self.side * self.side
-    }
-}
-
-// Обобщённая функция для вывода площади
-fn print_area(area: impl Area) {
-    println!("Area: {}", area.area())
-}
-
-fn main() {
-    let circle = Circle { radius: 5.0 };
-    let square = Square { side: 10.0 };
-
-    print_area(circle); // Area: 78.53981633974483
-    print_area(square); // Area: 100
-
-    // Можно добавить больше фигур, реализующих Area
-    let rectangle = Rectangle {
-        width: 4.0,
-        height: 6.0,
-    };
-    print_area(rectangle); // Area: 24
-}
-
-// Дополнительная структура для демонстрации расширяемости
-struct Rectangle {
-    width: f64,
-    height: f64,
-}
-
-impl Area for Rectangle {
-    fn area(&self) -> f64 {
-        self.width * self.height
-    }
-}

practice/src/bin/d_wrapper.rs

@@ -1,37 +0,0 @@
-// Создайте структуру Wrapper<T> с одним полем value: T:
-// ● Реализуйте метод map<U, F>(self, f: F) -> Wrapper<U>, где F: FnOnce(T) -> U.
-// ● Метод должен применāтþ функøиĀ f к value и возвраûатþ новýй Wrapper с резулþтатом.
-
-#![allow(clippy::approx_constant)]
-
-struct Wrapper<T> {
-    value: T,
-}
-
-impl<T> Wrapper<T> {
-    // Создаем новый Wrapper
-    fn new(value: T) -> Self {
-        Self { value }
-    }
-
-    // Применяем функцию к значению и возвращаем новый Wrapper
-    fn map<U>(self, f: impl FnOnce(T) -> U) -> Wrapper<U> {
-        Wrapper::new(f(self.value))
-    }
-}
-
-fn main() {
-    // Пример из задания
-    let w = Wrapper { value: 42 };
-    let w2 = w.map(|x| x.to_string());
-    println!("{}", w2.value); // "42"
-
-    // Дополнительные примеры
-    let w3 = Wrapper::<f64>::new(3.14);
-    let w4 = w3.map(|x| x.floor() as i32);
-    println!("{}", w4.value); // 3
-
-    let w5 = Wrapper::new("hello");
-    let w6 = w5.map(|s| s.len());
-    println!("{}", w6.value); // 5
-}

practice/src/bin/e_summary.rs

@@ -1,59 +0,0 @@
-// 1. Создайте типаж Summary с методом summarize(&self) -> String.
-// 2. Реализуйте его длā:
-// ○ Vec<T> (где T: ToString), метод должен соединять элементы через запятую.
-// ○ HashMap<K, V> (где K: ToString, V: ToString), метод должен выводить пары key:value.
-// 3. Напиúите функøиĀ print_summary<T: Summary>(item: T), которая печатает результат summarize().
-
-use std::collections::HashMap;
-
-// Определяем типаж Summary
-trait Summary {
-    fn summarize(&self) -> String;
-}
-
-// Реализация для Vec<T> где T: ToString
-impl<T: ToString> Summary for Vec<T> {
-    fn summarize(&self) -> String {
-        self.iter()
-            .map(|v| v.to_string())
-            .collect::<Vec<String>>()
-            .join(",")
-            .to_string()
-    }
-}
-
-// Реализация для HashMap<K, V> где K: ToString, V: ToString
-impl<K: ToString, V: ToString> Summary for HashMap<K, V> {
-    fn summarize(&self) -> String {
-        self.iter()
-            .map(|(k, v)| format!("{}:{}", k.to_string(), v.to_string()))
-            .collect::<Vec<String>>()
-            .join(", ")
-    }
-}
-
-// Обобщённая функция для вывода сводки
-fn print_summary(summary: impl Summary) {
-    println!("{}", summary.summarize())
-}
-
-fn main() {
-    // Пример с вектором
-    let vec = vec![1, 2, 3];
-    print_summary(vec); // "1, 2, 3"
-
-    // Пример с HashMap
-    let mut map = HashMap::new();
-    map.insert("name", "Alice");
-    map.insert("age", "30");
-    print_summary(map); // "name:Alice, age:30" (порядок может отличаться)
-
-    // Дополнительный пример с разными типами
-    let words = vec!["hello", "world"];
-    print_summary(words); // "hello, world"
-
-    let mut scores = HashMap::new();
-    scores.insert("math", 95);
-    scores.insert("science", 90);
-    print_summary(scores); // "math:95, science:90"
-}

practice/src/bin/f_largest_by_key.rs

@@ -1,55 +0,0 @@
-// Напиúите обобщенную функцию largest_by_key<T, F, K>(list: &[T], key: F) -> Option<&T>, где:
-// ● F: Fn(&T) -> K,
-// ● K: PartialOrd.
-// Функция должна возвращать элемент с максимальным значением key(item).
-
-fn largest_by_key<T, K: PartialOrd>(list: &[T], key: impl Fn(&T) -> K) -> Option<&T> {
-    let l_len = list.len();
-    if l_len < 1 {
-        return None;
-    } else if l_len == 1 {
-        return Some(&list[0]);
-    }
-    let mut max = &list[0];
-    let mut max_key = key(max);
-    for element in &list[1..] {
-        let element_key = key(element);
-        if element_key > max_key {
-            (max, max_key) = (element, element_key);
-        }
-    }
-    Some(max)
-}
-
-fn main() {
-    // Пример из задания
-    let words = ["apple", "banana", "cherry"];
-    let longest = largest_by_key(&words, |s| s.len());
-    println!("{:?}", longest); // Some("banana")
-
-    // Дополнительные примеры
-    let numbers = [1, 42, 3, 100, 5];
-    let largest_num = largest_by_key(&numbers, |&n| n);
-    println!("{:?}", largest_num); // Some(100)
-
-    struct Person {
-        name: String,
-        age: u32,
-    }
-    let people = [
-        Person {
-            name: "Alice".to_string(),
-            age: 30,
-        },
-        Person {
-            name: "Bob".to_string(),
-            age: 25,
-        },
-        Person {
-            name: "Charlie".to_string(),
-            age: 35,
-        },
-    ];
-    let oldest = largest_by_key(&people, |p| p.age);
-    println!("Oldest: {:?}", oldest.map(|p| &p.name)); // Some("Charlie")
-}

practice/src/bin/g_draw.rs

@@ -1,44 +0,0 @@
-// Определяем типаж Draw
-trait Draw {
-    fn draw(&self);
-}
-
-// Структура Circle
-struct Circle;
-
-// Реализация Draw для Circle
-impl Draw for Circle {
-    fn draw(&self) {
-        println!("Drawing circle")
-    }
-}
-
-// Структура Square
-struct Square;
-
-// Реализация Draw для Square
-impl Draw for Square {
-    fn draw(&self) {
-        println!("Drawing square")
-    }
-}
-
-fn main() {
-    // Создаем гетерогенную коллекцию фигур
-    let shapes: Vec<Box<dyn Draw>> = vec![Box::new(Circle), Box::new(Square)];
-
-    // Рисуем все фигуры
-    for shape in shapes {
-        shape.draw();
-    }
-
-    // Добавим еще фигур динамически
-    let mut more_shapes: Vec<Box<dyn Draw>> = Vec::new();
-    more_shapes.push(Box::new(Circle));
-    more_shapes.push(Box::new(Square));
-
-    println!("\nЕще фигуры:");
-    for shape in more_shapes {
-        shape.draw();
-    }
-}

practice/src/bin/h_plugins.rs

@@ -1,53 +0,0 @@
-use std::time::SystemTime;
-
-// Определяем типаж Plugin
-trait Plugin {
-    fn execute(&self) -> String;
-}
-
-// Плагин приветствия
-struct GreetPlugin;
-
-impl Plugin for GreetPlugin {
-    fn execute(&self) -> String {
-        "Hello, world!".to_string()
-    }
-}
-
-// Плагин времени
-struct TimePlugin;
-
-impl Plugin for TimePlugin {
-    fn execute(&self) -> String {
-        let now = SystemTime::now()
-            .duration_since(SystemTime::UNIX_EPOCH)
-            .unwrap();
-
-        let seconds = now.as_secs();
-        let minutes = seconds / 60;
-        let hours = (minutes / 60) % 24;
-        let minutes = minutes % 60;
-
-        format!("Current time: {:02}:{:02}", hours, minutes)
-    }
-}
-
-fn main() {
-    // Создаем коллекцию плагинов
-    let plugins = Vec::<Box<dyn Plugin>>::with_capacity(2);
-
-    // Выполняем все плагины
-    for plugin in plugins {
-        println!("{}", plugin.execute());
-    }
-
-    // Дополнительный пример с динамическим добавлением
-    let mut dynamic_plugins: Vec<Box<dyn Plugin>> = Vec::new();
-    dynamic_plugins.push(Box::new(GreetPlugin));
-    dynamic_plugins.push(Box::new(TimePlugin));
-
-    println!("\nDynamic execution:");
-    for plugin in dynamic_plugins {
-        println!("{}", plugin.execute());
-    }
-}

practice/src/bin/i_dyn_parser.rs

@@ -1,70 +0,0 @@
-// Определяем типаж Parser
-trait Parser {
-    fn parse(&self, input: &str) -> Result<String, String>;
-}
-
-
-
-// Парсер JSON
-struct JsonParser;
-
-impl Parser for JsonParser {
-    fn parse(&self, input: &str) -> Result<String, String> {
-        if input.trim().starts_with('{') && input.trim().ends_with('}') {
-            Ok("Parsed JSON".to_string())
-        } else {
-            Err("Invalid JSON format".to_string())
-        }
-    }
-}
-
-// Парсер CSV
-struct CsvParser;
-
-impl Parser for CsvParser {
-    fn parse(&self, input: &str) -> Result<String, String> {
-        if input.contains(',') {
-            Ok("Parsed CSV".to_string())
-        } else {
-            Err("Invalid CSV format".to_string())
-        }
-    }
-}
-
-// Функция для обработки данных парсером
-fn parse_data(parser: &dyn Parser, input: &str) -> Result<String, String> {
-    parser.parse(input)
-}
-
-
-
-fn main() {
-    // Пример использования JSON парсера
-    let json_parser = JsonParser;
-    let result = parse_data(&json_parser, r#"{ "name": "Alice" }"#);
-    println!("{:?}", result); // Ok("Parsed JSON")
-
-    // Пример использования CSV парсера
-    let csv_parser = CsvParser;
-    let result = parse_data(&csv_parser, "name,age,location");
-    println!("{:?}", result); // Ok("Parsed CSV")
-
-    // Пример обработки ошибок
-    let invalid_json = parse_data(&json_parser, "not a json");
-    println!("{:?}", invalid_json); // Err("Invalid JSON format")
-
-    let invalid_csv = parse_data(&csv_parser, "no commas here");
-    println!("{:?}", invalid_csv); // Err("Invalid CSV format")
-
-    // Динамический выбор парсера
-    let parsers: Vec<&dyn Parser> = vec![&json_parser, &csv_parser];
-    for parser in parsers {
-        println!("Testing parser:");
-        let test_input = if parser.parse("{").is_ok() {
-            r#"{ "test": "value" }"#
-        } else {
-            "field1,field2,field3"
-        };
-        println!("{:?}", parser.parse(test_input));
-    }
-}

practice/src/bin/j_sort_strategy.rs

@@ -1,89 +0,0 @@
-// Определяем типаж стратегии сортировки
-trait SortStrategy {
-    fn sort(&self, data: &mut [i32]);
-}
-
-
-// Реализация пузырьковой сортировки
-struct BubbleSort;
-
-impl SortStrategy for BubbleSort {
-    fn sort(&self, data: &mut [i32]) {
-        let len = data.len();
-        for i in 0..len {
-            for j in 0..len - i - 1 {
-                if data[j] > data[j + 1] {
-                    data.swap(j, j + 1);
-                }
-            }
-        }
-    }
-}
-
-// Реализация быстрой сортировки
-struct QuickSort;
-
-impl SortStrategy for QuickSort {
-    fn sort(&self, data: &mut [i32]) {
-        if data.len() <= 1 {
-            return;
-        }
-
-        let pivot = data.len() / 2;
-        let mut i = 0;
-        let mut j = data.len() - 1;
-
-        loop {
-            while data[i] < data[pivot] {
-                i += 1;
-            }
-            while data[j] > data[pivot] {
-                j -= 1;
-            }
-
-            if i >= j {
-                break;
-            }
-
-            data.swap(i, j);
-            i += 1;
-            j -= 1;
-        }
-
-        self.sort(&mut data[..i]);
-        self.sort(&mut data[i..]);
-    }
-}
-
-// Функция для применения стратегии сортировки
-fn sort_data(strategy: &dyn SortStrategy, data: &mut [i32]) {
-    strategy.sort(data)
-}
-
-
-
-fn main() {
-    // Тестируем пузырьковую сортировку
-    let mut data1 = [3, 1, 2, 5, 4];
-    let bubble = Box::new(BubbleSort);
-    sort_data(&*bubble, &mut data1);
-    println!("Bubble sort: {:?}", data1); // [1, 2, 3, 4, 5]
-
-    // Тестируем быструю сортировку
-    let mut data2 = [7, 3, 9, 2, 1];
-    let quick = Box::new(QuickSort);
-    sort_data(&*quick, &mut data2);
-    println!("Quick sort: {:?}", data2); // [1, 2, 3, 7, 9]
-
-    // Динамический выбор стратегии
-    let strategies: Vec<Box<dyn SortStrategy>> = vec![
-        Box::new(BubbleSort),
-        Box::new(QuickSort),
-    ];
-
-    for strategy in strategies {
-        let mut test_data = [5, 2, 4, 1, 3];
-        strategy.sort(&mut test_data);
-        println!("Sorted: {:?}", test_data);
-    }
-}

practice/src/bin/k_dyn_logger.rs

@@ -1,91 +0,0 @@
-// Уровни логирования
-#[derive(Debug, PartialEq, PartialOrd, Copy, Clone)]
-enum LogLevel {
-    Error,
-    Warn,
-    Info,
-    Debug,
-}
-
-// Типаж Logger
-trait Logger {
-    fn log(&self, message: &str);
-    fn level(&self) -> LogLevel;
-}
-
-// Логгер в консоль
-struct ConsoleLogger {
-    level: LogLevel,
-}
-
-impl ConsoleLogger {
-    fn new(level: LogLevel) -> Self {
-        ConsoleLogger { level }
-    }
-}
-
-impl Logger for ConsoleLogger {
-    fn log(&self, message: &str) {
-        println!("[Console] {}", message);
-    }
-
-    fn level(&self) -> LogLevel {
-        self.level
-    }
-}
-
-// Логгер в файл (упрощенная реализация)
-struct FileLogger {
-    level: LogLevel,
-    file_path: String,
-}
-
-impl FileLogger {
-    fn new(level: LogLevel, file_path: &str) -> Self {
-        FileLogger {
-            level,
-            file_path: file_path.to_string(),
-        }
-    }
-}
-
-impl Logger for FileLogger {
-    fn log(&self, message: &str) {
-        println!("[File: {}] {}", self.file_path, message);
-        // В реальной реализации здесь была бы запись в файл
-    }
-
-    fn level(&self) -> LogLevel {
-        self.level
-    }
-}
-
-// Функция для логирования сообщения с проверкой уровня
-fn log_message(logger: &dyn Logger, message: &str) {
-    if logger.level() >= LogLevel::Info {  // Пример: логируем только Info и выше
-        logger.log(message);
-    }
-}
-
-fn main() {
-    // Создаем логгеры
-    let console_logger = Box::new(ConsoleLogger::new(LogLevel::Info));
-    let file_logger = Box::new(FileLogger::new(LogLevel::Debug, "app.log"));
-
-    // Логируем сообщения
-    log_message(&*console_logger, "Application started");
-    log_message(&*file_logger, "Debug information");
-
-    // Сообщение, которое не будет залогировано (уровень ниже Info)
-    log_message(&*console_logger, "Trace information");
-
-    // Динамический выбор логгера
-    let loggers: Vec<Box<dyn Logger>> = vec![
-        Box::new(ConsoleLogger::new(LogLevel::Warn)),
-        Box::new(FileLogger::new(LogLevel::Error, "errors.log")),
-    ];
-
-    for logger in loggers {
-        log_message(&*logger, "Testing logger");
-    }
-}

practice/src/bin/l_event_handler.rs

@@ -1,80 +0,0 @@
-use std::collections::HashMap;
-
-// Определяем типаж обработчика событий
-trait EventHandler {
-    fn handle(&self, event: &str);
-}
-
-// Обработчик для отправки email
-struct EmailHandler;
-
-impl EventHandler for EmailHandler {
-    fn handle(&self, event: &str) {
-        println!("EmailHandler handling event '{}'", event)
-    }
-}
-
-// Обработчик для сохранения в базу данных
-struct DatabaseHandler;
-
-impl EventHandler for DatabaseHandler {
-    fn handle(&self, event: &str) {
-        println!("DatabaseHandler handling event '{}'", event)
-    }
-}
-
-// Обработчик для логирования
-struct LogHandler;
-
-impl EventHandler for LogHandler {
-    fn handle(&self, event: &str) {
-        println!("LogHandler handling event '{}'", event)
-    }
-}
-
-fn main() {
-    // Создаем реестр обработчиков событий
-    let mut handlers: HashMap<String, Box<dyn EventHandler>> = HashMap::new();
-
-    // Регистрируем обработчики
-    handlers.insert("email".to_string(), Box::new(EmailHandler));
-    handlers.insert("database".to_string(), Box::new(DatabaseHandler));
-    handlers.insert("log".to_string(), Box::new(LogHandler));
-
-    // Обрабатываем события
-    if let Some(handler) = handlers.get("email") {
-        handler.handle("New user registration");
-    }
-
-    if let Some(handler) = handlers.get("database") {
-        handler.handle("User data update");
-    }
-
-    // Динамическая обработка нескольких событий
-    let events = vec![
-        ("email", "Password reset requested"),
-        ("database", "Order completed"),
-        ("log", "System started"),
-        ("unknown", "This won't be processed"), // Не будет обработано
-    ];
-
-    for (event_type, event_data) in events {
-        if let Some(handler) = handlers.get(event_type) {
-            handler.handle(event_data);
-        } else {
-            println!("No handler registered for event type: {}", event_type);
-        }
-    }
-
-    // Добавление нового обработчика во время выполнения
-    struct NotificationHandler;
-
-    impl EventHandler for NotificationHandler {
-        fn handle(&self, event: &str) {
-            println!("Sending push notification: '{}'", event);
-        }
-    }
-
-    handlers.insert("notification".to_string(), Box::new(NotificationHandler));
-    handlers["notification"].handle("New message received");
-}

practice/src/main.rs

@@ -1,3 +0,0 @@
-fn main() {
-    println!("Hello, world!");
-}

smart-house/README.md

@@ -35,19 +35,19 @@
     - [x] Можно получить ссылку на устройство по указанному индексу.
     - [x] Можно получить мутабельную ссылку на устройство по указанному индексу.
     - [x] Выводить в стандартный вывод отчёт о всех устройствах в комнате.
-- [x] Опишите тип: умный дом, содержащий массив комнат. Тип должен предоставлять следующий функционал:
-    - [x] Конструктор, принимающий массив комнат.
-    - [x] Можно получить ссылку на комнату по указанному индексу.
-    - [x] Можно получить мутабельную ссылку на комнату по указанному индексу.
-    - [x] Выводить в стандартный вывод отчёт о всех комнатах.
+- [ ] Опишите тип: умный дом, содержащий массив комнат. Тип должен предоставлять следующий функционал:
+    - [ ] Конструктор, принимающий массив комнат.
+    - [ ] Можно получить ссылку на комнату по указанному индексу.
+    - [ ] Можно получить мутабельную ссылку на комнату по указанному индексу.
+    - [ ] Выводить в стандартный вывод отчёт о всех комнатах.
 - Размеры массивов можно выбрать произвольно.
 - В случае, если указан индекс, выходящий за пределы массива, приложение должно аварийно завершаться (макрос `panic!()`).
 
 Для примера использования:
 
-- [x] Реализована в виде bin крейта.
-- [x] Создайте экземпляр умного дома и выведете отчёт о его содержимом.
-- [x] Для уже созданного экземпляра дома выключите умную розетку в одной из комнат. Снова выведите отчёт.
+- [ ] Реализована в виде bin крейта.
+- [ ] Создайте экземпляр умного дома и выведете отчёт о его содержимом.
+- [ ] Для уже созданного экземпляра дома выключите умную розетку в одной из комнат. Снова выведите отчёт.
 
 **Критерии оценки**:
 

smart-house/src/device.rs

@@ -1,55 +1,14 @@
-use std::fmt::Display;
+#![allow(unused)]
 
-pub enum Device {
-    Thermometer(super::Thermometer),
-    PowerSocket(super::PowerSocket),
+mod power_socket;
+mod thermometer;
+
+pub trait Device {
+    fn print_status(&self);
+    fn as_any(&self) -> &dyn Any;
+    fn as_mut_any(&mut self) -> &mut dyn Any;
 }
 
-impl Device {
-    pub fn display(&self) -> impl Display {
-        match self {
-            Device::Thermometer(thermometer) => {
-                format!("DEV:{}", thermometer.display())
-            }
-            Device::PowerSocket(power_socket) => {
-                format!("DEV:{}", power_socket.display())
-            }
-        }
-    }
-
-    pub fn print_status(&self) {
-        println!("{}", self.display());
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{PowerSocket, Thermometer};
-
-    #[test]
-    fn smoke_test() {
-        let dev_thermometer = Device::Thermometer(Thermometer::new(20.1));
-        let dev_power_socket = Device::PowerSocket(PowerSocket::new(11.2, false));
-
-        dev_thermometer.print_status();
-        dev_power_socket.print_status();
-
-        let Device::Thermometer(thermometer) = dev_thermometer else { unreachable!() };
-        let Device::PowerSocket(power_socket) = dev_power_socket else {
-            unreachable!()
-        };
-
-        assert_eq!(format!("{}", thermometer.display()), "Thermometer[ 20.1 ]");
-        assert_eq!(format!("{}", power_socket.display()), "PowerSocket[ OFF : 0.0 ]");
-    }
-
-    #[test]
-    fn display_test() {
-        let dev_thermometer = Device::Thermometer(Thermometer::new(20.1));
-        let dev_power_socket = Device::PowerSocket(PowerSocket::new(11.2, false));
-
-        assert_eq!(format!("{}", dev_thermometer.display()), "DEV:Thermometer[ 20.1 ]");
-        assert_eq!(format!("{}", dev_power_socket.display()), "DEV:PowerSocket[ OFF : 0.0 ]");
-    }
-}
+pub use power_socket::PowerSocket;
+use std::any::Any;
+pub use thermometer::Thermometer;

smart-house/src/device/power_socket.rs

@@ -1,3 +1,7 @@
+#![allow(unused)]
+
+use crate::device::Device;
+use std::any::Any;
 use std::fmt::Display;
 
 pub struct PowerSocket {
@@ -28,6 +32,20 @@ impl PowerSocket {
     }
 }
 
+impl Device for PowerSocket {
+    fn print_status(&self) {
+        println!("{}", self.display())
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn as_mut_any(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

smart-house/src/device/thermometer.rs

@@ -1,3 +1,6 @@
+#![allow(unused)]
+
+use std::any::Any;
 use std::fmt::Display;
 
 pub struct Thermometer {
@@ -18,6 +21,20 @@ impl Thermometer {
     }
 }
 
+impl super::Device for Thermometer {
+    fn print_status(&self) {
+        println!("{}", self.display())
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn as_mut_any(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

smart-house/src/house.rs

@@ -1,91 +1 @@
-use crate::Room;
 
-pub struct House {
-    address: String,
-    rooms: Box<[Room]>,
-}
-
-impl House {
-    pub fn new(address: impl AsRef<str>, rooms: Box<[Room]>) -> Self {
-        Self {
-            address: address.as_ref().to_string(),
-            rooms,
-        }
-    }
-
-    fn check_bounds(&self, idx: usize) {
-        if idx >= self.rooms.len() {
-            panic!("Index is out of bounds")
-        }
-    }
-
-    pub fn get_room(&self, idx: usize) -> &Room {
-        self.check_bounds(idx);
-        &self.rooms[idx]
-    }
-
-    pub fn get_room_mut(&mut self, idx: usize) -> &mut Room {
-        self.check_bounds(idx);
-        &mut self.rooms[idx]
-    }
-
-    pub fn print_status(&self) {
-        println!("HOUSE '{}':", self.address);
-        println!("{}", "=".repeat(32));
-        for d in self.rooms.iter() {
-            d.print_status();
-            println!();
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{Device, PowerSocket, Thermometer};
-
-    fn create_test_house() -> House {
-        House::new(
-            "Best street, 777",
-            Box::new([
-                Room::new(
-                    "main",
-                    Box::new([
-                        Device::Thermometer(Thermometer::new(20.0)),
-                        Device::PowerSocket(PowerSocket::new(12.34, false)),
-                        Device::PowerSocket(PowerSocket::new(10.01, true)),
-                    ]),
-                ),
-                Room::new(
-                    "bedroom",
-                    Box::new([Device::PowerSocket(PowerSocket::new(11.11, true)), Device::Thermometer(Thermometer::new(17.99))]),
-                ),
-            ]),
-        )
-    }
-
-    #[test]
-    fn smoke_test() {
-        let mut house = create_test_house();
-        house.print_status();
-        assert_eq!(house.address, "Best street, 777");
-
-        assert_eq!(format!("{}", house.get_room(0).get_device(0).display()), "DEV:Thermometer[ 20.0 ]");
-        assert_eq!(format!("{}", house.get_room(0).get_device(1).display()), "DEV:PowerSocket[ OFF : 0.0 ]");
-        assert_eq!(format!("{}", house.get_room(1).get_device(0).display()), "DEV:PowerSocket[ ON : 11.1 ]");
-
-        let Device::PowerSocket(powers_socket) = house.get_room_mut(0).get_device_mut(1) else {
-            unreachable!()
-        };
-        powers_socket.set_on(true);
-
-        assert_eq!(format!("{}", house.get_room(0).get_device(1).display()), "DEV:PowerSocket[ ON : 12.3 ]");
-    }
-
-    #[test]
-    #[should_panic(expected = "Index is out of bounds")]
-    fn panic_test() {
-        let house = create_test_house();
-        house.check_bounds(2);
-    }
-}

smart-house/src/lib.rs

@@ -1,11 +1,3 @@
 mod device;
 mod house;
-mod power_socket;
 mod room;
-mod thermometer;
-
-pub use device::Device;
-pub use house::House;
-pub use power_socket::PowerSocket;
-pub use room::Room;
-pub use thermometer::Thermometer;

smart-house/src/main.rs

@@ -1,38 +1 @@
-use smart_house::{Device, House, PowerSocket, Room, Thermometer};
-
-fn main() {
-    let mut house = House::new(
-        "A house of dream",
-        Box::new([
-            Room::new(
-                "Hall",
-                Box::new([Device::PowerSocket(PowerSocket::new(9.5, true)), Device::Thermometer(Thermometer::new(20.1))]),
-            ),
-            Room::new(
-                "Main",
-                Box::new([
-                    Device::PowerSocket(PowerSocket::new(11.2, true)),
-                    Device::Thermometer(Thermometer::new(24.5)),
-                    Device::PowerSocket(PowerSocket::new(10.4, true)),
-                ]),
-            ),
-            Room::new(
-                "Bedroom",
-                Box::new([Device::Thermometer(Thermometer::new(19.3)), Device::PowerSocket(PowerSocket::new(12.1, true))]),
-            ),
-        ]),
-    );
-
-    house.print_status();
-
-    print!("# Switching off a power socket in Hall... ");
-    let Device::PowerSocket(power_socket) = house.get_room_mut(0).get_device_mut(0) else {
-        println!("FAILED!");
-        return;
-    };
-    power_socket.set_on(false);
-    println!("SUCCESS");
-    println!();
-
-    house.print_status();
-}
+fn main() {}

smart-house/src/room.rs

@@ -1,80 +1,77 @@
-use crate::Device;
+#![allow(unused)]
+use crate::device::Device;
 
-pub struct Room {
+struct Room<'a> {
     name: String,
-    devices: Box<[Device]>,
+    devices: &'a mut [Box<dyn Device>],
 }
 
-impl Room {
-    pub fn new(name: impl AsRef<str>, devices: Box<[Device]>) -> Self {
+impl<'a> Room<'a> {
+    pub fn new(name: impl AsRef<str>, devices: &'a mut [Box<dyn Device>]) -> Self {
         Self {
             name: name.as_ref().to_string(),
             devices,
         }
     }
 
-    fn check_bounds(&self, idx: usize) {
+    pub fn get(&'a self, idx: usize) -> &'a dyn Device {
         if idx >= self.devices.len() {
             panic!("Index is out of bounds")
         }
+        self.devices[idx].as_ref()
     }
 
-    pub fn get_device(&self, idx: usize) -> &Device {
-        self.check_bounds(idx);
-        &self.devices[idx]
+    pub fn get_mut(&'a mut self, idx: usize) -> &'a mut dyn Device {
+        if idx >= self.devices.len() {
+            panic!("Index is out of bounds")
+        }
+        self.devices[idx].as_mut()
     }
 
-    pub fn get_device_mut(&mut self, idx: usize) -> &mut Device {
-        self.check_bounds(idx);
-        &mut self.devices[idx]
-    }
-
-    pub fn print_status(&self) {
-        println!("ROOM '{}':", self.name);
-        println!("{}", "-".repeat(24));
+    pub fn print(&self) {
+        println!("{}", "=".repeat(16));
+        println!("{}:", self.name);
+        println!("{}", "-".repeat(16));
         for d in self.devices.iter() {
             d.print_status();
         }
+        println!("{}", "=".repeat(16));
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{PowerSocket, Thermometer};
+    use crate::device::{PowerSocket, Thermometer};
+    use std::fmt::format;
+    use std::mem;
 
     #[test]
     fn smoke_test() {
-        let devices = Box::new([
-            Device::PowerSocket(PowerSocket::new(12.34, false)),
-            Device::Thermometer(Thermometer::new(21.56)),
-        ]);
-        let mut room = Room::new("test_room", devices);
+        let mut devices = Box::new([Box::new(PowerSocket::new(12.34, false)) as Box<dyn Device>, Box::new(Thermometer::new(21.56))]);
+        let mut room = Room::new("test_room", &mut *devices);
         assert_eq!(room.name, "test_room");
-        room.print_status();
+        room.print();
 
-        assert_eq!(format!("{}", room.get_device(0).display()), "DEV:PowerSocket[ OFF : 0.0 ]");
-        assert_eq!(format!("{}", room.get_device(1).display()), "DEV:Thermometer[ 21.6 ]");
+        assert_eq!(
+            format!("{}", room.get(0).as_any().downcast_ref::<PowerSocket>().unwrap().display()),
+            "PowerSocket[ OFF : 0.0 ]"
+        );
+        assert_eq!(
+            format!("{}", room.get(1).as_any().downcast_ref::<Thermometer>().unwrap().display()),
+            "Thermometer[ 21.6 ]"
+        );
 
-        let Device::PowerSocket(power_socket) = room.get_device_mut(0) else {
-            unreachable!()
-        };
-        power_socket.set_on(true);
+        room.get_mut(0).as_mut_any().downcast_mut::<PowerSocket>().unwrap().set_on(true);
 
-        assert_eq!(format!("{}", room.get_device(0).display()), "DEV:PowerSocket[ ON : 12.3 ]");
-        assert_eq!(format!("{}", room.get_device(1).display()), "DEV:Thermometer[ 21.6 ]");
+        // room.print(); // TODO satisfy compiler
     }
 
     #[test]
     #[should_panic(expected = "Index is out of bounds")]
     fn panic_test() {
-        let room = Room::new(
-            "test_room",
-            Box::new([
-                Device::PowerSocket(PowerSocket::new(12.34, false)),
-                Device::Thermometer(Thermometer::new(21.56)),
-            ]),
-        );
-        room.check_bounds(2);
+        let mut devices = [Box::new(PowerSocket::new(12.34, false)) as Box<dyn Device>, Box::new(Thermometer::new(21.56))];
+        let mut room = Room::new("test_room", &mut devices);
+        room.get(2);
     }
 }