Work on new tree system

src/error.rs

@@ -5,6 +5,11 @@ pub type Result<T> = std::result::Result<T, ModuleError>;
 ///Generic error type for module-related operations.
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ModuleError {
+    NoError,
+
+    TreeNotExist,
+    TreeMessageError(String),
+
     LibLoadingError(String),
     // LogError(log::SetLoggerError),
     LinkError(String),
@@ -12,8 +17,6 @@ pub enum ModuleError {
     DatabaseError(String),
     SerdeJsonError(String),
 
-    TreeMessageError(String),
-
     Error(String),
 }
 

src/manager/log.rs

@@ -3,7 +3,7 @@ use crossbeam_channel::Sender;
 
 use crate::{
     logger::{Logger, Record},
-    manager::Manager,
+    manager::Tree,
 };
 
 pub struct ManagerLogger {

src/manager/mod.rs

@@ -1,23 +1,63 @@
-mod log;
+use std::collections::HashMap;
 
-pub struct Manager {
-    // logs_tx: Sender<Record>,
-    // logs_rx: Receiver<Record>,
+use crate::{
+    ModuleError,
+    manager::tree_structs::{TreeMessage, TreeType},
+};
+
+mod log;
+mod tree_structs;
+
+pub trait TreeElement {
+    fn get_children(&self) -> HashMap<String, TreeType>;
+    fn get_type(&self) -> TreeType;
+    fn send_message(&mut self, message: TreeMessage) -> TreeMessage;
+    fn send_message_child(&mut self, element: String, message: TreeMessage) -> TreeMessage;
 }
 
-impl Manager {
+pub struct Tree {
+    elements: HashMap<String, Box<dyn TreeElement>>,
+}
+
+impl Tree {
     pub fn new() -> Self {
-        Self {}
-
-        // let (tx, rx) = crossbeam_channel::unbounded();
-
-        // Self {
-        //     logs_tx: tx,
-        //     logs_rx: rx,
-        // }
+        Self {
+            elements: HashMap::new(),
+        }
     }
 
-    // pub fn log_count(&self) -> usize {
-    //     self.logs_rx.len()
-    // }
+    pub fn add_element(&mut self, name: String, element: Box<dyn TreeElement>) {
+        self.elements.insert(name, element);
+    }
+}
+
+impl TreeElement for Tree {
+    fn get_children(&self) -> HashMap<String, TreeType> {
+        self.elements
+            .iter()
+            .map(|c| (c.0.clone(), c.1.get_type()))
+            .into_iter()
+            .collect()
+    }
+
+    fn get_type(&self) -> TreeType {
+        TreeType::RootTree
+    }
+
+    fn send_message_child(&mut self, element_name: String, message: TreeMessage) -> TreeMessage {
+        if let Some(element) = self.elements.get_mut(&element_name) {
+            element.send_message(message)
+        } else {
+            TreeMessage::Result(ModuleError::TreeNotExist)
+        }
+    }
+
+    fn send_message(&mut self, _message: TreeMessage) -> TreeMessage {
+        TreeMessage::Response
+        // if let Some(element) = self.elements.get_mut(&element_name) {
+        //     element.send_message(message)
+        // } else {
+        //     TreeMessage::Result(ModuleError::TreeNotExist)
+        // }
+    }
 }

src/manager/tree_structs.rs

@@ -0,0 +1,13 @@
+pub enum TreeMessage {
+    Request,
+    Response,
+    Result(crate::error::ModuleError),
+}
+
+pub enum TreeType {
+    RootTree,
+
+    TypeA,
+    TypeB,
+    TypeC,
+}