Upgrade quanta to v0.10.0

Cargo.toml

@@ -55,7 +55,7 @@ uuid = { version = "0.8", features = ["v4"] }
 triomphe = { version = "0.1", default-features = false }
 
 # Optional dependencies (quanta, enabled by default)
-quanta = { version = "0.9.3", optional = true }
+quanta = { version = "0.10.0", optional = true }
 
 # Optional dependencies (dashmap)
 dashmap = { version = "5.2", optional = true }

src/common/time.rs

@@ -26,7 +26,7 @@ pub(crate) use clock::Mock;
 /// a wrapper type over Instant to force checked additions and prevent
 /// unintentional overflow. The type preserve the Copy semantics for the wrapped
 #[derive(PartialEq, PartialOrd, Clone, Copy)]
-pub(crate) struct Instant(pub clock::Instant);
+pub(crate) struct Instant(clock::Instant);
 
 pub(crate) trait CheckedTimeOps {
     fn checked_add(&self, duration: Duration) -> Option<Self>

src/common/time/atomic_time.rs

@@ -1,6 +1,9 @@
 use super::Instant;
 
-use std::sync::atomic::{AtomicU64, Ordering};
+use std::{
+    any::TypeId,
+    sync::atomic::{AtomicU64, Ordering},
+};
 
 pub(crate) struct AtomicInstant {
     instant: AtomicU64,
@@ -14,6 +17,9 @@ impl Default for AtomicInstant {
     }
 }
 
+// TODO: Need a safe way to convert between `quanta::Instant` and `u64`.
+// quanta v0.10.0 no longer provides `quanta::Instant::as_u64` method.
+
 impl AtomicInstant {
     pub(crate) fn reset(&self) {
         self.instant.store(std::u64::MAX, Ordering::Release);
@@ -28,11 +34,20 @@ impl AtomicInstant {
         if ts == u64::MAX {
             None
         } else {
-            Some(unsafe { std::mem::transmute(ts) })
+            debug_assert_eq!(
+                TypeId::of::<super::clock::Instant>(),
+                TypeId::of::<quanta::Instant>()
+            );
+            Some(Instant(unsafe { std::mem::transmute(ts) }))
         }
     }
 
     pub(crate) fn set_instant(&self, instant: Instant) {
-        self.instant.store(instant.0.as_u64(), Ordering::Release);
+        debug_assert_eq!(
+            TypeId::of::<super::clock::Instant>(),
+            TypeId::of::<quanta::Instant>()
+        );
+        let ts = unsafe { std::mem::transmute(instant.0) };
+        self.instant.store(ts, Ordering::Release);
     }
 }