Convert log_events from function to method

src/historian.rs

@@ -70,38 +70,46 @@ fn verify_event_and_reserve_signature<T: Serialize>(
     true
 }
 
-fn log_events<T: Serialize + Clone + Debug>(
+impl<T: Serialize + Clone + Debug> Logger<T> {
-    receiver: &Receiver<Event<T>>,
+    fn log_events(
-    sender: &SyncSender<Entry<T>>,
+        &mut self,
-    num_hashes: &mut u64,
+        epoch: SystemTime,
-    end_hash: &mut Sha256Hash,
+        ms_per_tick: Option<u64>,
-    epoch: SystemTime,
+    ) -> Result<(), (Entry<T>, ExitReason)> {
-    num_ticks: &mut u64,
+        use std::sync::mpsc::TryRecvError;
-    ms_per_tick: Option<u64>,
+        loop {
-) -> Result<(), (Entry<T>, ExitReason)> {
+            if let Some(ms) = ms_per_tick {
-    use std::sync::mpsc::TryRecvError;
+                let now = SystemTime::now();
-    loop {
+                if now > epoch + Duration::from_millis((self.num_ticks + 1) * ms) {
-        if let Some(ms) = ms_per_tick {
+                    log_event(
-            let now = SystemTime::now();
+                        &self.sender,
-            if now > epoch + Duration::from_millis((*num_ticks + 1) * ms) {
+                        &mut self.num_hashes,
-                log_event(sender, num_hashes, end_hash, Event::Tick)?;
+                        &mut self.end_hash,
-                *num_ticks += 1;
+                        Event::Tick,
+                    )?;
+                    self.num_ticks += 1;
+                }
             }
-        }
+            match self.receiver.try_recv() {
-        match receiver.try_recv() {
+                Ok(event) => {
-            Ok(event) => {
+                    log_event(
-                log_event(sender, num_hashes, end_hash, event)?;
+                        &self.sender,
-            }
+                        &mut self.num_hashes,
-            Err(TryRecvError::Empty) => {
+                        &mut self.end_hash,
-                return Ok(());
+                        event,
-            }
+                    )?;
-            Err(TryRecvError::Disconnected) => {
+                }
-                let entry = Entry {
+                Err(TryRecvError::Empty) => {
-                    end_hash: *end_hash,
+                    return Ok(());
-                    num_hashes: *num_hashes,
+                }
-                    event: Event::Tick,
+                Err(TryRecvError::Disconnected) => {
-                };
+                    let entry = Entry {
-                return Err((entry, ExitReason::RecvDisconnected));
+                        end_hash: self.end_hash,
+                        num_hashes: self.num_hashes,
+                        event: Event::Tick,
+                    };
+                    return Err((entry, ExitReason::RecvDisconnected));
+                }
             }
         }
     }
@@ -126,15 +134,7 @@ pub fn create_logger<T: 'static + Serialize + Clone + Debug + Send>(
         };
         let epoch = SystemTime::now();
         loop {
-            if let Err(err) = log_events(
+            if let Err(err) = logger.log_events(epoch, ms_per_tick) {
-                &logger.receiver,
-                &logger.sender,
-                &mut logger.num_hashes,
-                &mut logger.end_hash,
-                epoch,
-                &mut logger.num_ticks,
-                ms_per_tick,
-            ) {
                 return err;
             }
             logger.end_hash = hash(&logger.end_hash);