first version of object initialization (I hate (aka do not understand) lifetimes)

mission_rust/src/lib.rs

@@ -6,10 +6,10 @@
 
 mod fsrc;
 
-use core::mem::size_of;
-use core::panic::PanicInfo;
 use core::fmt::Write;
+use core::panic::PanicInfo;
 
+use fsrc::objectmanager::SystemObject;
 use fsrc::*;
 
 #[panic_handler]
@@ -33,8 +33,6 @@ fn panic(panic: &PanicInfo<'_>) -> ! {
     loop {}
 }
 
-
-
 #[no_mangle]
 extern "C" fn rust_main() {
     sifln!("Rust startup 🚀");
@@ -42,16 +40,16 @@ extern "C" fn rust_main() {
     sifln!("Mission done");
 }
 
-
 struct Handler {
-    id: u32,
-    command_queue: queues::MessageQueue<queues::Message>,
+    id: objectmanager::ObjectId,
+    command_queue: queues::MessageQueue,
 }
 
 struct HandlerSender {
-    id: u32,
+    id: objectmanager::ObjectId,
+    other_handler: objectmanager::ObjectId,
     cycle: u8,
-    other_handler: queues::MessageQueueSender<queues::Message>,
+    other_handler_queue: queues::MessageQueueSender,
 }
 
 impl Handler {
@@ -88,15 +86,15 @@ impl tasks::ExecutableObjectIF for HandlerSender {
         sifln!("HandlerSender {} performs step {}", self.id, self.cycle);
         match self.cycle {
             0 => {
-                let _ = self.other_handler.send(queues::Message::OK);
+                let _ = self.other_handler_queue.send(queues::Message::OK);
             }
             1 => {
-                let _ = self.other_handler.send(queues::Message::FAILED);
+                let _ = self.other_handler_queue.send(queues::Message::FAILED);
             }
             2 => {
-                let _ = self
-                    .other_handler
-                    .send(queues::Message::DATA(queues::GenericMessageData { p1: 13, p2: 2 }));
+                let _ = self.other_handler_queue.send(queues::Message::DATA(
+                    queues::GenericMessageData { p1: 13, p2: 2 },
+                ));
             }
             _ => (),
         }
@@ -104,6 +102,34 @@ impl tasks::ExecutableObjectIF for HandlerSender {
     }
 }
 
+impl SystemObject for Handler {
+    fn get_command_queue(&self) -> crate::fsrc::queues::MessageQueueSender {
+        self.command_queue.get_sender()
+    }
+    fn get_id(&self) -> objectmanager::ObjectId {
+        self.id
+    }
+    fn initialize(&mut self, _object_manager: &dyn objectmanager::ObjectManager) -> Result<(), ()> {
+        Ok(())
+    }
+}
+
+impl SystemObject for HandlerSender {
+    fn get_command_queue(&self) -> crate::fsrc::queues::MessageQueueSender {
+        queues::MessageQueueSender::new()
+    }
+    fn get_id(&self) -> objectmanager::ObjectId {
+        self.id
+    }
+    fn initialize(&mut self, object_manager: &dyn objectmanager::ObjectManager) -> Result<(), ()> {
+        let other_handler = object_manager.get_object(self.other_handler);
+        match other_handler {
+            Some(other) => self.other_handler_queue = other.get_command_queue(),
+            None => return Err(()),
+        }
+        Ok(())
+    }
+}
 
 fn mission() {
     sifln!("Mission enter");
@@ -114,13 +140,12 @@ fn mission() {
     };
     let mut h2 = HandlerSender {
         id: 2,
+        other_handler: 1,
         cycle: 0,
-        other_handler: queues::MessageQueueSender::<queues::Message>::new(),
+        other_handler_queue: queues::MessageQueueSender::new(),
     };
 
-    h2.other_handler = h1.command_queue.get_sender();
-
-    let array: &mut [&mut dyn tasks::ExecutableObjectIF] = &mut [&mut h1];
+    let array: &mut [&mut dyn objectmanager::SystemObject] = &mut [&mut h1];
 
     let mut t1 = tasks::PeriodicTask::new(array, 512, 200);
 
@@ -131,16 +156,10 @@ fn mission() {
         task_handle: 0 as *const cty::c_void,
     };
 
-    let _i = 1;
-
-    sifln!("sizeof {}, pointer struct {:p}, pointer element {:p}, next element{:p}", size_of::<tasks::PeriodicTask>(), &t2, t2.task_objects, &_i);
-
     let mut task_executor = tasks::TaskExecutor {
         tasks: &mut [&mut t1, &mut t2],
     };
 
-    sifln!("{:p}", task_executor.tasks[0]);
-
     task_executor.run_tasks();
 
     sifln!("Mission delay");