cleanup

flight/src/scheduler/mod.rs

@@ -1,7 +1,9 @@
 use crate::on_drop::on_drop;
 use anyhow::Result;
 use log::trace;
+use std::any::type_name;
 use std::fmt::Debug;
+use std::ops::Deref;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::sync::Arc;
@@ -10,22 +12,35 @@ use std::thread::{sleep, Scope};
 use std::time::{Duration, Instant};
 
 #[derive(Clone, Debug)]
-pub struct TaskHandle<Message> {
+pub struct TaskHandle<Message, Data> {
     #[allow(dead_code)]
     pub name: String,
     pub sender: Sender<Message>,
+    data: Data,
+}
+
+impl<Message, Data> Deref for TaskHandle<Message, Data> {
+    type Target = Data;
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
 }
 
 #[allow(dead_code)]
 pub trait Task {
     type Message;
+    type Data;
 
+    fn get_data(&self) -> Self::Data;
     fn run(self, receiver: Receiver<Self::Message>, running: Arc<AtomicBool>);
 }
 
 pub trait CyclicTask {
     type Message;
+    type Data;
 
+    fn get_data(&self) -> Self::Data;
     fn step(&mut self, receiver: &Receiver<Self::Message>, step_time: Instant);
 }
 
@@ -34,6 +49,11 @@ where
     F: Fn() -> (),
 {
     type Message = ();
+    type Data = ();
+
+    fn get_data(&self) -> Self::Data {
+        ()
+    }
 
     fn step(&mut self, _receiver: &Receiver<Self::Message>, _step_time: Instant) {
         self();
@@ -70,14 +90,15 @@ impl<'s, 'e> Scheduler<'s, 'e> {
         &self,
         name: impl Into<String>,
         task: T,
-    ) -> Result<TaskHandle<T::Message>> where
+    ) -> Result<TaskHandle<T::Message, T::Data>> where
         T: Task + Send + Debug + 's,
         T::Message: Send,
     {
         let name = name.into();
-        trace!("Scheduler::run(name: {name}, task: {task:?})");
+        trace!("Scheduler::run<T={}>(name: {name}, task: {task:?})", type_name::<T>());
         let running = self.running.clone();
         let (sender, receiver) = channel::<T::Message>();
+        let data = task.get_data();
         let _ = thread::Builder::new()
             .name(name.clone())
             .spawn_scoped(self.scope, move || {
@@ -86,6 +107,7 @@ impl<'s, 'e> Scheduler<'s, 'e> {
         Ok(TaskHandle {
             name,
             sender,
+            data,
         })
     }
 
@@ -94,14 +116,15 @@ impl<'s, 'e> Scheduler<'s, 'e> {
         name: impl Into<String>,
         mut task: T,
         frequency: u64,
-    ) -> Result<TaskHandle<T::Message>> where
+    ) -> Result<TaskHandle<T::Message, T::Data>> where
         T: CyclicTask + Send + 's,
         T::Message: Send,
     {
         let name = name.into();
-        trace!("Scheduler::run_cyclic(name: {name}, task, frequency: {frequency})");
+        trace!("Scheduler::run_cyclic<T={}>(name: {name}, task, frequency: {frequency})", type_name::<T>());
         let running = self.running.clone();
         let (sender, receiver) = channel::<T::Message>();
+        let data = task.get_data();
         let _ = thread::Builder::new()
             .name(name.clone())
             .spawn_scoped(self.scope, move || {
@@ -120,6 +143,7 @@ impl<'s, 'e> Scheduler<'s, 'e> {
         Ok(TaskHandle {
             name,
             sender,
+            data,
         })
     }
 }