imp(timer): feature partiy for sleep implementation

Author: omarabid

src/timer/sleep.rs

@@ -4,6 +4,7 @@
 // https://www.apache.org/licenses/LICENSE-2.0>. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use super::TimerSignal;
 use crate::utils::get_time_range;
 use crate::Result;
 
@@ -25,57 +26,61 @@ use std::{thread, thread::JoinHandle};
 #[derive(Debug, Default)]
 pub struct Timer {
     /// A vector to store listeners (mpsc::Sender)
-    txs: Arc<Mutex<Vec<Sender<u64>>>>,
+    txs: Arc<Mutex<Vec<Sender<TimerSignal>>>>,
 
     /// Thread handle
     pub handle: Option<JoinHandle<Result<()>>>,
 }
 
 impl Timer {
     /// Initialize Timer and run a thread to send events to attached listeners
-    pub fn initialize(self) -> Result<Self> {
-        let txs = Arc::clone(&self.txs);
+    pub fn initialize(cycle: Duration) -> Result<Self> {
+        let txs = Arc::new(Mutex::new(Vec::new()));
 
         // Add Default tx
-        let (tx, _rx): (Sender<u64>, Receiver<u64>) = channel();
+        let (tx, _rx): (Sender<TimerSignal>, Receiver<TimerSignal>) = channel();
         txs.lock()?.push(tx);
 
         // Spawn a Thread
-        let handle = Some(thread::spawn(move || {
-            // Get remaining time for 10th second fire event
-            let rem = get_time_range(0)?.rem;
+        let handle = Some({
+            let txs = txs.clone();
 
-            // Sleep for rem seconds
-            thread::sleep(Duration::from_secs(rem));
+            thread::spawn(move || {
+                // Get remaining time for 10th second fire event
+                let rem = get_time_range(0)?.rem;
 
-            loop {
-                // Exit thread if there are no listeners
-                if txs.lock()?.len() == 0 {
-                    return Ok(());
-                }
+                // Sleep for rem seconds
+                thread::sleep(Duration::from_secs(rem));
 
-                // Get current time
-                let current = get_time_range(0)?.from;
+                loop {
+                    // Exit thread if there are no listeners
+                    if txs.lock()?.len() == 0 {
+                        return Ok(());
+                    }
 
-                // Iterate through Senders
-                txs.lock()?.iter().for_each(|tx| {
-                    // Send event to attached Sender
-                    let _res = tx.send(current);
-                });
+                    // Get current time
+                    let current = TimerSignal::NextSnapshot(get_time_range(0)?.from);
 
-                // Sleep for 10s
-                thread::sleep(Duration::from_millis(10000));
-            }
-        }));
+                    // Iterate through Senders
+                    txs.lock()?.iter().for_each(|tx| {
+                        // Send event to attached Sender
+                        let _res = tx.send(current);
+                    });
+
+                    // Sleep for 10s
+                    thread::sleep(cycle);
+                }
+            })
+        });
 
-        Ok(Self { handle, ..self })
+        Ok(Self { handle, txs })
     }
 
     /// Attach an mpsc::Sender to Timer
     ///
     /// Timer will dispatch an event with the timestamp of the current instant,
     /// every 10th second to all attached senders
-    pub fn attach_listener(&mut self, tx: Sender<u64>) -> Result<()> {
+    pub fn attach_listener(&mut self, tx: Sender<TimerSignal>) -> Result<()> {
         // Push Sender to a Vector of Sender(s)
         let txs = Arc::clone(&self.txs);
         txs.lock()?.push(tx);