various updates & improvements

.devcontainer/Dockerfile

@@ -0,0 +1,9 @@
+FROM ubuntu:20.04
+
+WORKDIR /home/
+
+COPY . .
+
+RUN bash ./setup.sh
+
+ENV PATH="/root/.cargo/bin:$PATH"

.devcontainer/devcontainer.json

@@ -0,0 +1,18 @@
+{
+	"name": "rust-stopwatch",
+	"extensions": [
+		"matklad.rust-analyzer",
+		"bungcip.better-toml"
+	],
+	"dockerFile": "Dockerfile",
+	"containerEnv": {
+		"GIT_EDITOR": "code --wait"
+	},
+	"onCreateCommand": "cargo build",
+	"settings": {
+		"editor.formatOnSave": true,
+		"files.exclude": {
+			"**/LICENSE.txt": true
+		}
+	}
+}

.devcontainer/setup.sh

@@ -0,0 +1,13 @@
+apt-get update
+apt-get install -y \
+  curl \
+  git \
+  gnupg2 \
+  jq \
+  sudo \
+  build-essential \
+  openssl
+
+curl https://sh.rustup.rs -sSf | sh -s -- -y
+source "$HOME/.cargo/env"
+rustup component add clippy rustfmt

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
-
 name = "stopwatch"
 version = "0.0.7"
+edition = "2021"
 authors = ["Chucky Ellison <cme@freefour.com>"]
 
 description = "A stopwatch library for timing things."
@@ -11,4 +11,4 @@ keywords = ["stopwatch", "timing"]
 license = "MIT"
 
 [dependencies]
-num = "0.1.32"
+num-traits = "0.2.15"

src/lib.rs

@@ -4,118 +4,113 @@ use std::time::{Duration, Instant};
 
 #[derive(Clone, Copy)]
 pub struct Stopwatch {
-	/// The time the stopwatch was started last, if ever.
-	start_time: Option<Instant>,
-	/// The time the stopwatch was split last, if ever.
-	split_time: Option<Instant>,
-	/// The time elapsed while the stopwatch was running (between start() and stop()).
-	elapsed: Duration,
+    /// The time the stopwatch was started last, if ever.
+    start_time: Option<Instant>,
+    /// The time the stopwatch was split last, if ever.
+    split_time: Option<Instant>,
+    /// The time elapsed while the stopwatch was running (between start() and stop()).
+    elapsed: Duration,
 }
 
 impl Default for Stopwatch {
-	fn default() -> Stopwatch {
-		Stopwatch {
-			start_time: None,
-			split_time: None,
-			elapsed: Duration::from_secs(0),
-		}
-	}
+    fn default() -> Stopwatch {
+        Stopwatch {
+            start_time: None,
+            split_time: None,
+            elapsed: Duration::from_secs(0),
+        }
+    }
 }
 
 impl fmt::Display for Stopwatch {
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		return write!(f, "{}ms", self.elapsed_ms());
-	}
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        return write!(f, "{}ms", self.elapsed_ms());
+    }
 }
 
 impl Stopwatch {
-	/// Returns a new stopwatch.
-	pub fn new() -> Stopwatch {
-		let sw: Stopwatch = Default::default();
-		return sw;
-	}
+    /// Returns a new stopwatch.
+    pub fn new() -> Stopwatch {
+        return Stopwatch::default();
+    }
 
-	/// Returns a new stopwatch which will immediately be started.
-	pub fn start_new() -> Stopwatch {
-		let mut sw = Stopwatch::new();
-		sw.start();
-		return sw;
-	}
+    /// Returns a new stopwatch which will immediately be started.
+    pub fn start_new() -> Stopwatch {
+        let mut sw = Stopwatch::new();
+        sw.start();
+        return sw;
+    }
 
-	/// Starts the stopwatch.
-	pub fn start(&mut self) {
-		self.start_time = Some(Instant::now());
-	}
+    /// Starts the stopwatch.
+    pub fn start(&mut self) {
+        self.start_time = Some(Instant::now());
+    }
 
-	/// Stops the stopwatch.
-	pub fn stop(&mut self) {
-		self.elapsed = self.elapsed();
-		self.start_time = None;
-		self.split_time = None;
-	}
+    /// Stops the stopwatch.
+    pub fn stop(&mut self) {
+        self.elapsed = self.elapsed();
+        self.start_time = None;
+        self.split_time = None;
+    }
 
-	/// Resets all counters and stops the stopwatch.
-	pub fn reset(&mut self) {
-		self.elapsed = Duration::from_secs(0);
-		self.start_time = None;
-		self.split_time = None;
-	}
+    /// Resets all counters and stops the stopwatch.
+    pub fn reset(&mut self) {
+        self.elapsed = Duration::from_secs(0);
+        self.start_time = None;
+        self.split_time = None;
+    }
 
-	/// Resets and starts the stopwatch again.
-	pub fn restart(&mut self) {
-		self.reset();
-		self.start();
-	}
+    /// Resets and starts the stopwatch again.
+    pub fn restart(&mut self) {
+        self.reset();
+        self.start();
+    }
 
-	/// Returns whether the stopwatch is running.
-	pub fn is_running(&self) -> bool {
-		return self.start_time.is_some();
-	}
+    /// Returns whether the stopwatch is running.
+    pub fn is_running(&self) -> bool {
+        self.start_time.is_some()
+    }
 
-	/// Returns the elapsed time since the start of the stopwatch.
-	pub fn elapsed(&self) -> Duration {
-		match self.start_time {
-			// stopwatch is running
-			Some(t1) => {
-				return t1.elapsed() + self.elapsed;
-			}
-			// stopwatch is not running
-			None => {
-				return self.elapsed;
-			}
-		}
-	}
+    /// Returns the elapsed time since the start of the stopwatch.
+    pub fn elapsed(&self) -> Duration {
+        match self.start_time {
+            // stopwatch is running
+            Some(t1) => t1.elapsed() + self.elapsed,
+            // stopwatch is not running
+            None => self.elapsed,
+        }
+    }
 
-	/// Returns the elapsed time since the start of the stopwatch in milliseconds.
-	pub fn elapsed_ms(&self) -> i64 {
-		let dur = self.elapsed();
-		return (dur.as_secs() * 1000 + (dur.subsec_nanos() / 1000000) as u64) as i64;
-	}
+    /// Returns the elapsed time since the start of the stopwatch in milliseconds.
+    pub fn elapsed_ms(&self) -> i64 {
+        let dur = self.elapsed();
+        return (dur.as_secs() * 1000 + dur.subsec_millis() as u64) as i64;
+    }
 
-	/// Returns the elapsed time since last split or start/restart.
-	///
-	/// If the stopwatch is in stopped state this will always return a zero Duration.
-	pub fn elapsed_split(&mut self) -> Duration {
-		match self.start_time {
-			// stopwatch is running
-			Some(start) => {
-				let res = match self.split_time {
-					Some(split) => split.elapsed(),
-					None => start.elapsed(),
-				};
-				self.split_time = Some(Instant::now());
-				res
-			}
-			// stopwatch is not running
-			None => Duration::from_secs(0),
-		}
-	}
+    /// Returns the elapsed time since last split or start/restart.
+    ///
+    /// If the stopwatch is in stopped state this will always return a zero Duration.
+    pub fn elapsed_split(&mut self) -> Duration {
+        match self.start_time {
+            // stopwatch is running
+            Some(start) => {
+                let res = match self.split_time {
+                    Some(split) => split.elapsed(),
+                    None => start.elapsed(),
+                };
+                self.split_time = Some(Instant::now());
+                return res;
+            }
+            // stopwatch is not running
+            None => Duration::from_secs(0),
+        }
+    }
 
-	/// Returns the elapsed time since last split or start/restart in milliseconds.
-	///
-	/// If the stopwatch is in stopped state this will always return zero.
-	pub fn elapsed_split_ms(&mut self) -> i64 {
-		let dur = self.elapsed_split();
-		return (dur.as_secs() * 1000 + (dur.subsec_nanos() / 1_000_000) as u64) as i64;
-	}
+    /// Returns the elapsed time since last split or start/restart in milliseconds.
+    ///
+    /// If the stopwatch is in stopped state this will always return zero.
+    pub fn elapsed_split_ms(&mut self) -> i64 {
+        let dur = self.elapsed_split();
+        return (dur.as_secs() * 1000 + dur.subsec_millis() as u64) as i64;
+    }
 }