homework: use hash map and implement Debug trait

practice/.gitignore

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

practice/Cargo.lock

@@ -0,0 +1,7 @@
+# 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

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

practice/src/bin/a_compare.rs

@@ -0,0 +1,21 @@
+// Напиúите функøиĀ 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

@@ -0,0 +1,35 @@
+// Создайте структуру 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

@@ -0,0 +1,64 @@
+// 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

@@ -0,0 +1,37 @@
+// Создайте структуру 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

@@ -0,0 +1,59 @@
+// 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

@@ -0,0 +1,55 @@
+// Напиúите обобщенную функцию 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

@@ -0,0 +1,44 @@
+// Определяем типаж 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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,70 @@
+// Определяем типаж 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

@@ -0,0 +1,89 @@
+// Определяем типаж стратегии сортировки
+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

@@ -0,0 +1,91 @@
+// Уровни логирования
+#[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

@@ -0,0 +1,80 @@
+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/bin/m_node.rs

@@ -0,0 +1,45 @@
+use std::cell::RefCell;
+use std::rc::{Rc, Weak};
+
+#[derive(Debug)]
+struct Node {
+    value: i32,
+    parent: RefCell<Option<Weak<Node>>>,                            // <-- weak ref to parent
+    children: RefCell<Vec<Rc<Node>>>,
+}
+
+impl Node {
+    fn new(value: i32) -> Rc<Self> {
+        Rc::new(Self {
+            value,
+            parent: Default::default(),
+            children: Default::default(),
+        })
+    }
+
+    fn set_parent(&self, parent: Rc<Node>) {
+        *self.parent.borrow_mut() = Some(Rc::downgrade(&parent));   // <-- create weak ref to parent
+    }
+
+    fn add_child(self: &Rc<Self>, child: Rc<Node>) {
+        child.set_parent(self.clone());
+        self.children.borrow_mut().push(child);
+    }
+}
+
+impl Drop for Node {
+    fn drop(&mut self) {
+        println!(
+            "Dropping node with value {} and {} children",
+            self.value,
+            self.children.borrow().len()
+        );
+    }
+}
+
+fn main() {
+    let tree = Node::new(1);
+    tree.add_child(Node::new(3));
+    tree.add_child(Node::new(5));
+    println!("Finishing program now");
+}

practice/src/main.rs

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

smart-house/README.md

@@ -35,19 +35,71 @@
     - [x] Можно получить ссылку на устройство по указанному индексу.
     - [x] Можно получить мутабельную ссылку на устройство по указанному индексу.
     - [x] Выводить в стандартный вывод отчёт о всех устройствах в комнате.
-- [ ] Опишите тип: умный дом, содержащий массив комнат. Тип должен предоставлять следующий функционал:
-    - [ ] Конструктор, принимающий массив комнат.
-    - [ ] Можно получить ссылку на комнату по указанному индексу.
-    - [ ] Можно получить мутабельную ссылку на комнату по указанному индексу.
-    - [ ] Выводить в стандартный вывод отчёт о всех комнатах.
+- [x] Опишите тип: умный дом, содержащий массив комнат. Тип должен предоставлять следующий функционал:
+    - [x] Конструктор, принимающий массив комнат.
+    - [x] Можно получить ссылку на комнату по указанному индексу.
+    - [x] Можно получить мутабельную ссылку на комнату по указанному индексу.
+    - [x] Выводить в стандартный вывод отчёт о всех комнатах.
 - Размеры массивов можно выбрать произвольно.
 - В случае, если указан индекс, выходящий за пределы массива, приложение должно аварийно завершаться (макрос `panic!()`).
 
 Для примера использования:
 
-- [ ] Реализована в виде bin крейта.
-- [ ] Создайте экземпляр умного дома и выведете отчёт о его содержимом.
-- [ ] Для уже созданного экземпляра дома выключите умную розетку в одной из комнат. Снова выведите отчёт.
+- [x] Реализована в виде bin крейта.
+- [x] Создайте экземпляр умного дома и выведете отчёт о его содержимом.
+- [x] Для уже созданного экземпляра дома выключите умную розетку в одной из комнат. Снова выведите отчёт.
+
+**Критерии оценки**:
+
+- Package успешно собирается.
+- Приложение-пример успешно выполняется и выводит отчёт о доме.
+- Команды cargo clippy и cargo fmt --check не выводят ошибок и предупреждений.
+- Присутствуют и успешно выполняются модульные тесты.
+
+## ДЗ 2026-01-20
+
+Дорабатываем умный дом
+
+### Цель:
+
+Дорабатываем функционал умного дома, используя возможности стандартной библиотеки.
+
+### Срок:
+
+Сдать до: **2026-02-11**
+
+### Описание/Пошаговая инструкция выполнения домашнего задания:
+
+Добавить обработку ошибок:
+- [x] Заменить паники на возврат Option в методах получения комнаты по ключу.
+- [x] Заменить паники на возврат Option в методах получения устройства по ключу.
+
+Доработать хранение объектов:
+- [x] Заменить массивы устройств и комнат на ассоциативные коллекции из std. В качестве ключей использовать строки.
+- [x] Реализовать трейт Debug на всех типах.
+- [ ] Добавить возможность динамически добавлять/удалять устройства в комнату.
+- [ ] Добавить возможность динамически добавлять/удалять комнату в дом.
+- [ ] Добавить в тип умного дома метод, позволяющий сразу получить ссылку на умное устройство. Метод принимает имя комнаты
+      и имя устройства. В случае, если устройство или комната не найдены, возвращать тип ошибки, сообщающий, что именно
+      произошло. Тип ошибки должен реализовывать трейт `std::error::Error`.
+- [ ] Добавить реализации трейта `From`, позволяющие преобразовывать объекты умной розетки и умного термометра в объект
+      умного устройства.
+- [ ] Написать макрос для упрощенного создания комнаты, принимающий пары вида (ключ, объект умной розетки) или (ключ,
+      объект умного термометра) и возвращающий объект комнаты, содержащей все перечисленные устройства с
+      соответствующими ключами.
+
+Доработать формирование отчёта:
+- [ ] Вынести метод формирования отчёта в трейт и реализовать его на всех типах, которые возвращают отчёт: умное устройство,
+      комната, дом.
+
+Привести тесты в соответствие с новым функционалом.
+
+Доработать приложение-пример:
+- [ ] Продемонстрировать возможность динамического добавления/удаления комнат.
+- [ ] Продемонстрировать возможность динамического добавления/удаления устройств.
+- [ ] Добавить функцию, которая принимает любой объект, умеющий выводить отчёт. Вывести с её помощью отчёты о доме,
+      отдельной комнате, отдельном устройстве.
+- [ ] Продемонстрировать возможность обработки ошибок.
 
 **Критерии оценки**:
 

smart-house/src/device.rs

@@ -1,14 +1,63 @@
-#![allow(unused)]
+use std::fmt::Display;
 
-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;
+#[derive(Debug)]
+pub enum Device {
+    Thermometer(super::Thermometer),
+    PowerSocket(super::PowerSocket),
 }
 
-pub use power_socket::PowerSocket;
-use std::any::Any;
-pub use thermometer::Thermometer;
+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());
+    }
+
+    pub fn get_name(&self) -> &str {
+        match self {
+            Device::Thermometer(thermometer) => thermometer.get_name(),
+            Device::PowerSocket(power_socket) => power_socket.get_name(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{PowerSocket, Thermometer};
+
+    #[test]
+    fn smoke_test() {
+        let dev_thermometer = Device::Thermometer(Thermometer::new("Therm", 20.1));
+        let dev_power_socket = Device::PowerSocket(PowerSocket::new("PSoc", 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()), "Therm[ 20.1 ]");
+        assert_eq!(format!("{}", power_socket.display()), "PSoc[ OFF : 0.0 ]");
+    }
+
+    #[test]
+    fn display_test() {
+        let dev_thermometer = Device::Thermometer(Thermometer::new("Therm", 20.1));
+        let dev_power_socket = Device::PowerSocket(PowerSocket::new("PSoc", 11.2, false));
+
+        assert_eq!(format!("{}", dev_thermometer.display()), "DEV:Therm[ 20.1 ]");
+        assert_eq!(format!("{}", dev_power_socket.display()), "DEV:PSoc[ OFF : 0.0 ]");
+    }
+}

smart-house/src/device/thermometer.rs

@@ -1,54 +0,0 @@
-#![allow(unused)]
-
-use std::any::Any;
-use std::fmt::Display;
-
-pub struct Thermometer {
-    temperature: f32,
-}
-
-impl Thermometer {
-    pub fn new(temperature: f32) -> Self {
-        Self { temperature }
-    }
-
-    pub fn get_temperature(&self) -> f32 {
-        self.temperature
-    }
-
-    pub fn display(&self) -> impl Display {
-        format!("Thermometer[ {:02.1} ]", self.get_temperature())
-    }
-}
-
-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::*;
-
-    #[test]
-    fn smoke_test() {
-        let thermometer = Thermometer::new(20.0);
-        assert_eq!(thermometer.temperature, 20.0);
-        assert_eq!(thermometer.get_temperature(), 20.0);
-    }
-
-    #[test]
-    fn display_test() {
-        assert_eq!(format!("{}", Thermometer::new(19.550).display()), "Thermometer[ 19.5 ]");
-        assert_eq!(format!("{}", Thermometer::new(19.551).display()), "Thermometer[ 19.6 ]");
-    }
-}

smart-house/src/house.rs

@@ -1 +1,105 @@
+use crate::Room;
+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 get_room(&self, key: &str) -> Option<&Room> {
+        self.rooms.get(key)
+    }
+
+    pub fn get_room_mut(&mut self, key: &str) -> Option<&mut Room> {
+        self.rooms.get_mut(key)
+    }
+
+    pub fn print_status(&self) {
+        println!("HOUSE '{}':", self.address);
+        println!("{}", "=".repeat(32));
+        for (_, room) in self.rooms.iter() {
+            room.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("ThermA", 20.0)),
+                        Device::PowerSocket(PowerSocket::new("PSocA", 12.34, false)),
+                        Device::PowerSocket(PowerSocket::new("PSocB", 10.01, true)),
+                    ]),
+                ),
+                Room::new(
+                    "bedroom",
+                    Box::new([
+                        Device::PowerSocket(PowerSocket::new("PSocC", 11.11, true)),
+                        Device::Thermometer(Thermometer::new("ThermB", 17.99)),
+                    ]),
+                ),
+            ]),
+        )
+    }
+
+    #[test]
+    fn smoke_test() {
+        let mut house = create_test_house();
+        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 ]"
+        );
+        assert_eq!(
+            format!("{}", house.get_room("main").unwrap().get_device("PSocA").unwrap().display()),
+            "DEV:PSocA[ OFF : 0.0 ]"
+        );
+        assert_eq!(
+            format!("{}", house.get_room("bedroom").unwrap().get_device("PSocC").unwrap().display()),
+            "DEV:PSocC[ ON : 11.1 ]"
+        );
+
+        let Device::PowerSocket(powers_socket) = house.get_room_mut("main").unwrap().get_device_mut("PSocA").unwrap() else {
+            unreachable!()
+        };
+        powers_socket.set_on(true);
+
+        assert_eq!(
+            format!("{}", house.get_room("main").unwrap().get_device("PSocA").unwrap().display()),
+            "DEV:PSocA[ ON : 12.3 ]"
+        );
+    }
+
+    #[test]
+    fn check_out_of_bounds() {
+        let house = create_test_house();
+        assert!(house.get_room("absent").is_none());
+    }
+}

smart-house/src/lib.rs

@@ -1,3 +1,11 @@
 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 +1,44 @@
-fn main() {}
+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("PSocA", 9.5, true)),
+                    Device::Thermometer(Thermometer::new("ThermA", 20.1)),
+                ]),
+            ),
+            Room::new(
+                "Main",
+                Box::new([
+                    Device::PowerSocket(PowerSocket::new("PSocB", 11.2, true)),
+                    Device::Thermometer(Thermometer::new("ThermB", 24.5)),
+                    Device::PowerSocket(PowerSocket::new("PSocC", 10.4, true)),
+                ]),
+            ),
+            Room::new(
+                "Bedroom",
+                Box::new([
+                    Device::Thermometer(Thermometer::new("ThermC", 19.3)),
+                    Device::PowerSocket(PowerSocket::new("PSocD", 12.1, true)),
+                ]),
+            ),
+        ]),
+    );
+
+    house.print_status();
+
+    print!("# Switching off a power socket in Hall... ");
+    let Device::PowerSocket(power_socket) = house.get_room_mut("Hall").unwrap().get_device_mut("PSocA").unwrap() else {
+        println!("FAILED!");
+        return;
+    };
+    power_socket.set_on(false);
+    println!("SUCCESS");
+    println!();
+
+    house.print_status();
+}

smart-house/src/power_socket.rs

@@ -1,17 +1,23 @@
-#![allow(unused)]
-
-use crate::device::Device;
-use std::any::Any;
 use std::fmt::Display;
 
+#[derive(Debug)]
 pub struct PowerSocket {
+    name: String,
     power_rate: f32,
     on: bool,
 }
 
 impl PowerSocket {
-    pub fn new(power_rate: f32, on: bool) -> Self {
-        Self { power_rate, on }
+    pub fn new(name: impl AsRef<str>, power_rate: f32, on: bool) -> Self {
+        Self {
+            name: name.as_ref().to_string(),
+            power_rate,
+            on,
+        }
+    }
+
+    pub fn get_name(&self) -> &str {
+        &self.name
     }
 
     pub fn is_on(&self) -> bool {
@@ -28,21 +34,7 @@ impl PowerSocket {
 
     pub fn display(&self) -> impl Display {
         let state = if self.is_on() { "ON" } else { "OFF" };
-        format!("PowerSocket[ {} : {:02.1} ]", state, self.get_power())
-    }
-}
-
-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
+        format!("{}[ {} : {:02.1} ]", self.get_name(), state, self.get_power())
     }
 }
 
@@ -52,7 +44,7 @@ mod tests {
 
     #[test]
     fn smoke_test() {
-        let mut power_socket = PowerSocket::new(12.4, false);
+        let mut power_socket = PowerSocket::new("PowerSocket", 12.4, false);
         assert_eq!(power_socket.power_rate, 12.4);
         assert!(!power_socket.on);
         assert!(!power_socket.is_on());
@@ -65,8 +57,8 @@ mod tests {
 
     #[test]
     fn display_test() {
-        assert_eq!(format!("{}", PowerSocket::new(11.549, false).display()), "PowerSocket[ OFF : 0.0 ]");
-        assert_eq!(format!("{}", PowerSocket::new(11.549, true).display()), "PowerSocket[ ON : 11.5 ]");
-        assert_eq!(format!("{}", PowerSocket::new(11.550, true).display()), "PowerSocket[ ON : 11.6 ]");
+        assert_eq!(format!("{}", PowerSocket::new("PS_1", 11.549, false).display()), "PS_1[ OFF : 0.0 ]");
+        assert_eq!(format!("{}", PowerSocket::new("PS_2", 11.549, true).display()), "PS_2[ ON : 11.5 ]");
+        assert_eq!(format!("{}", PowerSocket::new("PS_3", 11.550, true).display()), "PS_3[ ON : 11.6 ]");
     }
 }

smart-house/src/room.rs

@@ -1,77 +1,79 @@
-#![allow(unused)]
-use crate::device::Device;
+use crate::Device;
+use std::collections::HashMap;
 
-struct Room<'a> {
+#[derive(Debug)]
+pub struct Room {
     name: String,
-    devices: &'a mut [Box<dyn Device>],
+    devices: HashMap<String, Device>,
 }
 
-impl<'a> Room<'a> {
-    pub fn new(name: impl AsRef<str>, devices: &'a mut [Box<dyn Device>]) -> Self {
+impl Room {
+    pub fn new(name: impl AsRef<str>, devices: Box<[Device]>) -> Self {
+        let devices = devices.into_iter().map(|d| (d.get_name().to_string(), d)).collect();
         Self {
             name: name.as_ref().to_string(),
             devices,
         }
     }
 
-    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_name(&self) -> &str {
+        &self.name
     }
 
-    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(&self, key: &str) -> Option<&Device> {
+        self.devices.get(key)
     }
 
-    pub fn print(&self) {
-        println!("{}", "=".repeat(16));
-        println!("{}:", self.name);
-        println!("{}", "-".repeat(16));
-        for d in self.devices.iter() {
-            d.print_status();
+    pub fn get_device_mut(&mut self, key: &str) -> Option<&mut Device> {
+        self.devices.get_mut(key)
+    }
+
+    pub fn print_status(&self) {
+        println!("ROOM '{}':", self.name);
+        println!("{}", "-".repeat(24));
+        for (_, device) in self.devices.iter() {
+            device.print_status();
         }
-        println!("{}", "=".repeat(16));
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::device::{PowerSocket, Thermometer};
-    use std::fmt::format;
-    use std::mem;
+    use crate::{PowerSocket, Thermometer};
 
     #[test]
     fn smoke_test() {
-        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);
+        let devices = Box::new([
+            Device::PowerSocket(PowerSocket::new("PSoc", 12.34, false)),
+            Device::Thermometer(Thermometer::new("Therm", 21.56)),
+        ]);
+        let mut room = Room::new("test_room", devices);
         assert_eq!(room.name, "test_room");
-        room.print();
+        assert_eq!(room.get_name(), "test_room");
+        room.print_status();
 
-        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 ]"
-        );
+        assert_eq!(format!("{}", room.get_device("PSoc").unwrap().display()), "DEV:PSoc[ OFF : 0.0 ]");
+        assert_eq!(format!("{}", room.get_device("Therm").unwrap().display()), "DEV:Therm[ 21.6 ]");
 
-        room.get_mut(0).as_mut_any().downcast_mut::<PowerSocket>().unwrap().set_on(true);
+        let Device::PowerSocket(power_socket) = room.get_device_mut("PSoc").unwrap() else {
+            unreachable!()
+        };
+        power_socket.set_on(true);
 
-        // room.print(); // TODO satisfy compiler
+        assert_eq!(format!("{}", room.get_device("PSoc").unwrap().display()), "DEV:PSoc[ ON : 12.3 ]");
+        assert_eq!(format!("{}", room.get_device("Therm").unwrap().display()), "DEV:Therm[ 21.6 ]");
     }
 
     #[test]
-    #[should_panic(expected = "Index is out of bounds")]
-    fn panic_test() {
-        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);
+    fn check_out_of_bounds() {
+        let room = Room::new(
+            "test_room",
+            Box::new([
+                Device::PowerSocket(PowerSocket::new("PSoc", 12.34, false)),
+                Device::Thermometer(Thermometer::new("Therm", 21.56)),
+            ]),
+        );
+        assert!(room.get_device("dummy").is_none());
     }
 }

smart-house/src/thermometer.rs

@@ -0,0 +1,48 @@
+use std::fmt::Display;
+
+#[derive(Debug)]
+pub struct Thermometer {
+    name: String,
+    temperature: f32,
+}
+
+impl Thermometer {
+    pub fn new(name: impl AsRef<str>, temperature: f32) -> Self {
+        Self {
+            name: name.as_ref().to_string(),
+            temperature,
+        }
+    }
+
+    pub fn get_name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn get_temperature(&self) -> f32 {
+        self.temperature
+    }
+
+    pub fn display(&self) -> impl Display {
+        format!("{}[ {:02.1} ]", self.get_name(), self.get_temperature())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn smoke_test() {
+        let thermometer = Thermometer::new("TERM", 20.0);
+        assert_eq!(thermometer.temperature, 20.0);
+        assert_eq!(thermometer.get_temperature(), 20.0);
+        assert_eq!(thermometer.name, "TERM");
+        assert_eq!(thermometer.get_name(), "TERM");
+    }
+
+    #[test]
+    fn display_test() {
+        assert_eq!(format!("{}", Thermometer::new("T1", 19.550).display()), "T1[ 19.5 ]");
+        assert_eq!(format!("{}", Thermometer::new("T2", 19.551).display()), "T2[ 19.6 ]");
+    }
+}