Refactor code without changing functionality

An effort to make the code shorter and more readable. This mostly 
affects the code for the clock device.

1 files changed, 19 insertions, 32 deletions

diff --git a/src/devices/clock.rs b/src/devices/clock.rs
index b974a4a..3faa604 100644
--- a/src/devices/clock.rs
+++ b/src/devices/clock.rs
@@ -5,36 +5,36 @@ macro_rules! now { () => {
     .unwrap_or_else(|_| time::OffsetDateTime::now_utc())
 };}
 
-macro_rules! time_from_ticks {
-    ($ticks:expr) => { Instant::now() + Duration::from_millis(($ticks * 4).into()) };
-}
 macro_rules! to_ticks {
     ($duration:expr) => {($duration.as_millis() / 4) as u16}; }
 macro_rules! from_ticks {
     ($ticks:expr) => {Duration::from_millis(($ticks * 4).into())}; }
 
-macro_rules! ticks_since_time {
-    ($time:expr) => { ($time.duration_since(Instant::now()).as_millis() / 4) as u16 };
-}
 
 /// Create a method to set the instant of a timer.
 macro_rules! generate_set_timer_method {
-    ($i:tt) => {mini_paste::item!{
+    ($i:tt) => { mini_paste::item!{
         pub fn [< set_timer_ $i >] (&mut self) {
-            self. [< timer_ $i _instant >] = time_from_ticks!(self. [< timer_ $i >]);
+            let ticks = &mut self. [< timer_ $i >];
+            let instant = &mut self. [< timer_ $i _instant >];
+
+            *instant = Instant::now() + from_ticks!(*ticks);
         }
     }};
 }
 
 /// Create a method to update the value of a timer.
 macro_rules! generate_update_timer_method {
-    ($i:tt) => {mini_paste::item!{
-        pub fn [< update_timer_ $i >] (&mut self) {
-            if self. [< timer_ $i >] > 0 {
-                self. [< timer_ $i >] = ticks_since_time!(self.[< timer_ $i _instant >]);
-                if self. [< timer_ $i >] == 0 { self.wake_flag = true; }
+    ($i:tt) => { mini_paste::item!{
+        pub fn [< update_timer_ $i >] (&mut self) -> u16 {
+            let ticks = &mut self. [< timer_ $i >];
+            let instant = &mut self. [< timer_ $i _instant >];
+
+            if *ticks > 0 {
+                *ticks = to_ticks!(instant.duration_since(Instant::now()));
+                if *ticks == 0 { self.wake_flag = true; }
             }
-            self. [< timer_ $i >]
+            *ticks
         }
     }};
 }
@@ -114,23 +114,10 @@ impl ClockDevice {
     }
 
     pub fn shortest_active_timer(&self) -> Option<Duration> {
-        let mut is_some = false;
-        let mut value = u16::MAX;
-        macro_rules! contribute_to_min {
-            ($timer:expr) => {
-                if $timer > 0 {
-                    is_some = true;
-                    value = std::cmp::min(value, $timer);
-                }
-            };
-        }
-        contribute_to_min!(self.timer_1);
-        contribute_to_min!(self.timer_2);
-        contribute_to_min!(self.timer_3);
-        contribute_to_min!(self.timer_4);
-        match is_some {
-            true => Some(Duration::from_millis((value*4).into())),
-            false => None,
-        }
+        [self.timer_1, self.timer_2, self.timer_3, self.timer_4]
+            .iter()
+            .filter(|t| **t > 0)
+            .min()
+            .and_then(|t| Some(from_ticks!(t)))
     }
 }