lint

flight/src/scheduler/mod.rs

@@ -4,11 +4,11 @@ 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;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc::{Receiver, Sender, channel};
 use std::thread;
-use std::thread::{sleep, Scope};
+use std::thread::{Scope, sleep};
 use std::time::{Duration, Instant};
 
 #[derive(Clone, Debug)]
@@ -46,13 +46,12 @@ pub trait CyclicTask {
 
 impl<F> CyclicTask for F
 where
-    F: Fn() -> (),
+    F: Fn(),
 {
     type Message = ();
     type Data = ();
 
     fn get_data(&self) -> Self::Data {
-        ()
     }
 
     fn step(&mut self, _receiver: &Receiver<Self::Message>, _step_time: Instant) {
@@ -60,27 +59,27 @@ where
     }
 }
 
-pub struct Scheduler<'s, 'e>
-{
+pub struct Scheduler<'s, 'e> {
     scope: &'s Scope<'s, 'e>,
     running: Arc<AtomicBool>,
 }
 
-impl<'s, 'e> Scheduler<'s, 'e> {
-    pub fn new<'env, F, R>(running: Arc<AtomicBool>, f: F) -> R
+impl<'s> Scheduler<'s, '_> {
+    pub fn scope<'env, F, R>(running: Arc<AtomicBool>, f: F) -> R
     where
         F: FnOnce(Scheduler<'_, 'env>) -> R,
     {
         trace!("Scheduler::new(running: {running:?}, f)");
         thread::scope(|scope: &Scope| {
+            let running_result = running.clone();
             // This will automatically set running to false when it drops
             // This means that if the function returns any side branches
             // checking running will shut down
-            let _shutdown_threads = on_drop(|| running.store(false, Ordering::Relaxed));
+            let _shutdown_threads = on_drop(move || running.store(false, Ordering::Relaxed));
 
             f(Scheduler {
                 scope,
-                running: running.clone(),
+                running: running_result,
             })
         })
     }
@@ -90,12 +89,16 @@ impl<'s, 'e> Scheduler<'s, 'e> {
         &self,
         name: impl Into<String>,
         task: T,
-    ) -> Result<TaskHandle<T::Message, T::Data>> where
+    ) -> Result<TaskHandle<T::Message, T::Data>>
+    where
         T: Task + Send + Debug + 's,
         T::Message: Send,
     {
         let name = name.into();
-        trace!("Scheduler::run<T={}>(name: {name}, task: {task:?})", type_name::<T>());
+        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();
@@ -104,11 +107,7 @@ impl<'s, 'e> Scheduler<'s, 'e> {
             .spawn_scoped(self.scope, move || {
                 task.run(receiver, running);
             })?;
-        Ok(TaskHandle {
-            name,
-            sender,
-            data,
-        })
+        Ok(TaskHandle { name, sender, data })
     }
 
     pub fn run_cyclic<T>(
@@ -116,12 +115,16 @@ impl<'s, 'e> Scheduler<'s, 'e> {
         name: impl Into<String>,
         mut task: T,
         frequency: u64,
-    ) -> Result<TaskHandle<T::Message, T::Data>> where
+    ) -> Result<TaskHandle<T::Message, T::Data>>
+    where
         T: CyclicTask + Send + 's,
         T::Message: Send,
     {
         let name = name.into();
-        trace!("Scheduler::run_cyclic<T={}>(name: {name}, task, frequency: {frequency})", type_name::<T>());
+        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();
@@ -140,10 +143,6 @@ impl<'s, 'e> Scheduler<'s, 'e> {
                     }
                 }
             })?;
-        Ok(TaskHandle {
-            name,
-            sender,
-            data,
-        })
+        Ok(TaskHandle { name, sender, data })
     }
 }