Dataset using introspection is better

mission_rust/src/lib.rs

@@ -3,12 +3,11 @@
 //TODO os errors in API calls
 //TODO look into a pattern for late initialized stuff, currently using Option (can we make it compile time safe?)
 
-mod fsrc;
+pub mod fsrc;
 
 use core::fmt::Write;
 use core::panic::PanicInfo;
 
-use fsrc::datasets::{DataSetIF, DatapoolOwnerIF};
 use fsrc::objectmanager::SystemObjectIF;
 use fsrc::*;
 
@@ -49,16 +48,16 @@ extern "C" fn rust_main() {
     sifln!("Mission done");
 }
 
-#[derive (Copy, Clone, Default)]
+#[derive(Copy, Clone, Default)]
 struct HandlerData {
     x: u32,
-    y: f32
+    y: f32,
 }
 
 struct Handler {
     id: objectmanager::ObjectId,
     command_queue: queues::MessageQueue<10>,
-    data: datasets::OwnedDataset<HandlerData>
+    data: datasets::OwnedDataset<HandlerData>,
 }
 
 struct HandlerSender {
@@ -66,10 +65,9 @@ struct HandlerSender {
     other_handler: objectmanager::ObjectId,
     cycle: u8,
     other_handler_queue: queues::MessageQueueSender,
-    other_data: datasets::ReferencedDataset<HandlerData>
+    other_data: datasets::ReferencedDataset<HandlerData>,
 }
 
-
 impl Handler {
     fn handle_message(&self, message: queues::Message) {
         match message {
@@ -132,17 +130,23 @@ impl SystemObjectIF for Handler {
     }
 }
 
-impl datasets::DatapoolOwnerIF for Handler {
-    fn get_set(&self, type_id: core::any::TypeId) -> Option<&dyn datasets::DataSetIF>{
-        if type_id == self.data.get_type_id(){
-            Some(&self.data)
-        } else {
-            None
-        }
-    }
+impl introspection::Introspection for HandlerSender {
+    fn for_each_member(&self, f: &mut dyn FnMut(&dyn core::any::Any, &str) -> ()) {}
+
+    fn for_each_member_return(&self, f: &mut dyn FnMut(&dyn core::any::Any, &str) -> Option<()>) {}
 }
 
-impl DatapoolOwnerIF for HandlerSender {}
+impl introspection::Introspection for Handler {
+    fn for_each_member(&self, f: &mut dyn FnMut(&dyn core::any::Any, &str) -> ()) {
+        (*f)(&self.command_queue, "command_queue");
+        (*f)(&self.data, "data");
+    }
+
+    fn for_each_member_return(&self, f: &mut dyn FnMut(&dyn core::any::Any, &str) -> Option<()>) {
+        (*f)(&self.command_queue, "command_queue");
+        (*f)(&self.data, "data");
+    }
+}
 
 impl SystemObjectIF for HandlerSender {
     fn get_command_queue(&self) -> crate::fsrc::queues::MessageQueueSender {
@@ -154,14 +158,14 @@ impl SystemObjectIF for HandlerSender {
     }
     fn initialize(&mut self, object_manager: &dyn objectmanager::ObjectManager) -> Result<(), ()> {
         let other_handler_maybe = object_manager.get_object(self.other_handler);
-        let other_handler = 
-        match other_handler_maybe {
+        let other_handler = match other_handler_maybe {
             Ok(other) => other,
             Err(_) => return Err(()),
         };
         self.other_handler_queue = other_handler.get_command_queue();
 
-        self.other_data.initialize(object_manager, self.other_handler)?;
+        self.other_data
+            .initialize(object_manager, self.other_handler)?;
         Ok(())
     }
 }
@@ -172,14 +176,14 @@ fn mission() {
     let mut h1 = Handler {
         id: 1,
         command_queue: queues::MessageQueue::new(),
-        data: datasets::OwnedDataset::new()
+        data: datasets::OwnedDataset::new(),
     };
     let mut h2 = HandlerSender {
         id: 2,
         other_handler: 3,
         cycle: 0,
         other_handler_queue: queues::MessageQueueSender::new(),
-        other_data: datasets::ReferencedDataset::new()
+        other_data: datasets::ReferencedDataset::new(),
     };
 
     let array: &mut [&mut dyn objectmanager::SystemObjectIF] = &mut [&mut h1];