Convert log_events from function to method

src/historian.rs

@@ -70,41 +70,49 @@ 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,
-    end_hash: &mut Sha256Hash,
         epoch: SystemTime,
-    num_ticks: &mut u64,
         ms_per_tick: Option<u64>,
-) -> Result<(), (Entry<T>, ExitReason)> {
+    ) -> Result<(), (Entry<T>, ExitReason)> {
         use std::sync::mpsc::TryRecvError;
         loop {
             if let Some(ms) = ms_per_tick {
                 let now = SystemTime::now();
-            if now > epoch + Duration::from_millis((*num_ticks + 1) * ms) {
+                if now > epoch + Duration::from_millis((self.num_ticks + 1) * ms) {
-                log_event(sender, num_hashes, end_hash, Event::Tick)?;
+                    log_event(
-                *num_ticks += 1;
+                        &self.sender,
+                        &mut self.num_hashes,
+                        &mut self.end_hash,
+                        Event::Tick,
+                    )?;
+                    self.num_ticks += 1;
                 }
             }
-        match receiver.try_recv() {
+            match self.receiver.try_recv() {
                 Ok(event) => {
-                log_event(sender, num_hashes, end_hash, event)?;
+                    log_event(
+                        &self.sender,
+                        &mut self.num_hashes,
+                        &mut self.end_hash,
+                        event,
+                    )?;
                 }
                 Err(TryRecvError::Empty) => {
                     return Ok(());
                 }
                 Err(TryRecvError::Disconnected) => {
                     let entry = Entry {
-                    end_hash: *end_hash,
+                        end_hash: self.end_hash,
-                    num_hashes: *num_hashes,
+                        num_hashes: self.num_hashes,
                         event: Event::Tick,
                     };
                     return Err((entry, ExitReason::RecvDisconnected));
                 }
             }
         }
+    }
 }
 
 /// A background thread that will continue tagging received Event messages and
@@ -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);