a bit clean up

Cargo.toml

@@ -37,9 +37,8 @@ features = ["macros", "extension-module"]
 [dependencies.cfg-if]
 version = "1.0.3"
 
-[dependencies.parking_lot_core]
-version = "0.9.11"
-default-features = false
+[dependencies.parking_lot]
+version = "0.12.4"
 
 [dependencies.lock_api]
 version = "0.4.13"

src/bridge/cache.rs

@@ -4,14 +4,14 @@ use crate::common::PreHashObject;
 
 #[pyo3::pyclass(module = "cachebox._core", frozen)]
 pub struct Cache {
-    raw: crate::mutex::Mutex<crate::policies::nopolicy::NoPolicy>,
+    raw: crate::common::Mutex<crate::policies::nopolicy::NoPolicy>,
 }
 
 #[allow(non_camel_case_types)]
 #[pyo3::pyclass(module = "cachebox._core")]
 pub struct cache_items {
     pub ptr: ObservedIterator,
-    pub iter: crate::mutex::Mutex<hashbrown::raw::RawIter<(PreHashObject, pyo3::Py<pyo3::PyAny>)>>,
+    pub iter: crate::common::Mutex<hashbrown::raw::RawIter<(PreHashObject, pyo3::Py<pyo3::PyAny>)>>,
 }
 
 #[pyo3::pymethods]
@@ -22,7 +22,7 @@ impl Cache {
         let raw = crate::policies::nopolicy::NoPolicy::new(maxsize, capacity)?;
 
         let self_ = Self {
-            raw: crate::mutex::Mutex::new(raw),
+            raw: crate::common::Mutex::new(raw),
         };
         Ok(self_)
     }
@@ -205,7 +205,7 @@ impl Cache {
 
         let result = cache_items {
             ptr: ObservedIterator::new(slf.as_ptr(), state),
-            iter: crate::mutex::Mutex::new(iter),
+            iter: crate::common::Mutex::new(iter),
         };
 
         pyo3::Py::new(slf.py(), result)

src/bridge/fifocache.rs

@@ -4,14 +4,14 @@ use crate::common::PreHashObject;
 
 #[pyo3::pyclass(module = "cachebox._core", frozen)]
 pub struct FIFOCache {
-    raw: crate::mutex::Mutex<crate::policies::fifo::FIFOPolicy>,
+    raw: crate::common::Mutex<crate::policies::fifo::FIFOPolicy>,
 }
 
 #[allow(non_camel_case_types)]
 #[pyo3::pyclass(module = "cachebox._core")]
 pub struct fifocache_items {
     pub ptr: ObservedIterator,
-    pub iter: crate::mutex::Mutex<crate::policies::fifo::FIFOIterator>,
+    pub iter: crate::common::Mutex<crate::policies::fifo::FIFOIterator>,
 }
 
 #[pyo3::pymethods]
@@ -22,7 +22,7 @@ impl FIFOCache {
         let raw = crate::policies::fifo::FIFOPolicy::new(maxsize, capacity)?;
 
         let self_ = Self {
-            raw: crate::mutex::Mutex::new(raw),
+            raw: crate::common::Mutex::new(raw),
         };
         Ok(self_)
     }
@@ -221,7 +221,7 @@ impl FIFOCache {
 
         let result = fifocache_items {
             ptr: ObservedIterator::new(slf.as_ptr(), state),
-            iter: crate::mutex::Mutex::new(iter),
+            iter: crate::common::Mutex::new(iter),
         };
 
         pyo3::Py::new(slf.py(), result)

src/bridge/lfucache.rs

@@ -4,14 +4,14 @@ use crate::common::PreHashObject;
 
 #[pyo3::pyclass(module = "cachebox._core", frozen)]
 pub struct LFUCache {
-    raw: crate::mutex::Mutex<crate::policies::lfu::LFUPolicy>,
+    raw: crate::common::Mutex<crate::policies::lfu::LFUPolicy>,
 }
 
 #[allow(non_camel_case_types)]
 #[pyo3::pyclass(module = "cachebox._core")]
 pub struct lfucache_items {
     pub ptr: ObservedIterator,
-    pub iter: crate::mutex::Mutex<crate::policies::lfu::LFUIterator>,
+    pub iter: crate::common::Mutex<crate::policies::lfu::LFUIterator>,
 }
 
 #[pyo3::pymethods]
@@ -22,7 +22,7 @@ impl LFUCache {
         let raw = crate::policies::lfu::LFUPolicy::new(maxsize, capacity)?;
 
         let self_ = Self {
-            raw: crate::mutex::Mutex::new(raw),
+            raw: crate::common::Mutex::new(raw),
         };
         Ok(self_)
     }
@@ -234,7 +234,7 @@ impl LFUCache {
 
         let result = lfucache_items {
             ptr: ObservedIterator::new(slf.as_ptr(), state),
-            iter: crate::mutex::Mutex::new(iter),
+            iter: crate::common::Mutex::new(iter),
         };
 
         pyo3::Py::new(slf.py(), result)

src/bridge/lrucache.rs

@@ -4,14 +4,14 @@ use crate::common::PreHashObject;
 
 #[pyo3::pyclass(module = "cachebox._core", frozen)]
 pub struct LRUCache {
-    raw: crate::mutex::Mutex<crate::policies::lru::LRUPolicy>,
+    raw: crate::common::Mutex<crate::policies::lru::LRUPolicy>,
 }
 
 #[allow(non_camel_case_types)]
 #[pyo3::pyclass(module = "cachebox._core")]
 pub struct lrucache_items {
     pub ptr: ObservedIterator,
-    pub iter: crate::mutex::Mutex<crate::linked_list::Iter>,
+    pub iter: crate::common::Mutex<crate::linked_list::Iter>,
 }
 
 #[pyo3::pymethods]
@@ -22,7 +22,7 @@ impl LRUCache {
         let raw = crate::policies::lru::LRUPolicy::new(maxsize, capacity)?;
 
         let self_ = Self {
-            raw: crate::mutex::Mutex::new(raw),
+            raw: crate::common::Mutex::new(raw),
         };
         Ok(self_)
     }
@@ -230,7 +230,7 @@ impl LRUCache {
 
         let result = lrucache_items {
             ptr: ObservedIterator::new(slf.as_ptr(), state),
-            iter: crate::mutex::Mutex::new(iter),
+            iter: crate::common::Mutex::new(iter),
         };
 
         pyo3::Py::new(slf.py(), result)

src/bridge/rrcache.rs

@@ -5,7 +5,7 @@ use crate::common::PreHashObject;
 
 #[pyo3::pyclass(module = "cachebox._core", frozen)]
 pub struct RRCache {
-    raw: crate::mutex::Mutex<crate::policies::random::RandomPolicy>,
+    raw: crate::common::Mutex<crate::policies::random::RandomPolicy>,
 }
 
 #[pyo3::pymethods]
@@ -16,7 +16,7 @@ impl RRCache {
         let raw = crate::policies::random::RandomPolicy::new(maxsize, capacity)?;
 
         let self_ = Self {
-            raw: crate::mutex::Mutex::new(raw),
+            raw: crate::common::Mutex::new(raw),
         };
         Ok(self_)
     }
@@ -208,7 +208,7 @@ impl RRCache {
 
         let result = cache_items {
             ptr: ObservedIterator::new(slf.as_ptr(), state),
-            iter: crate::mutex::Mutex::new(iter),
+            iter: crate::common::Mutex::new(iter),
         };
 
         pyo3::Py::new(slf.py(), result)

src/bridge/ttlcache.rs

@@ -5,14 +5,14 @@ use crate::common::TimeToLivePair;
 
 #[pyo3::pyclass(module = "cachebox._core", frozen)]
 pub struct TTLCache {
-    raw: crate::mutex::Mutex<crate::policies::ttl::TTLPolicy>,
+    raw: crate::common::Mutex<crate::policies::ttl::TTLPolicy>,
 }
 
 #[allow(non_camel_case_types)]
 #[pyo3::pyclass(module = "cachebox._core")]
 pub struct ttlcache_items {
     pub ptr: ObservedIterator,
-    pub iter: crate::mutex::Mutex<crate::policies::ttl::TTLIterator>,
+    pub iter: crate::common::Mutex<crate::policies::ttl::TTLIterator>,
     pub now: std::time::SystemTime,
 }
 
@@ -24,7 +24,7 @@ impl TTLCache {
         let raw = crate::policies::ttl::TTLPolicy::new(maxsize, capacity, ttl)?;
 
         let self_ = Self {
-            raw: crate::mutex::Mutex::new(raw),
+            raw: crate::common::Mutex::new(raw),
         };
         Ok(self_)
     }
@@ -224,7 +224,7 @@ impl TTLCache {
 
         let result = ttlcache_items {
             ptr: ObservedIterator::new(slf.as_ptr(), state),
-            iter: crate::mutex::Mutex::new(iter),
+            iter: crate::common::Mutex::new(iter),
             now: std::time::SystemTime::now(),
         };
 

src/bridge/vttlcache.rs

@@ -5,14 +5,14 @@ use crate::common::TimeToLivePair;
 
 #[pyo3::pyclass(module = "cachebox._core", frozen)]
 pub struct VTTLCache {
-    raw: crate::mutex::Mutex<crate::policies::vttl::VTTLPolicy>,
+    raw: crate::common::Mutex<crate::policies::vttl::VTTLPolicy>,
 }
 
 #[allow(non_camel_case_types)]
 #[pyo3::pyclass(module = "cachebox._core")]
 pub struct vttlcache_items {
     pub ptr: ObservedIterator,
-    pub iter: crate::mutex::Mutex<crate::policies::vttl::VTTLIterator>,
+    pub iter: crate::common::Mutex<crate::policies::vttl::VTTLIterator>,
     pub now: std::time::SystemTime,
 }
 
@@ -24,7 +24,7 @@ impl VTTLCache {
         let raw = crate::policies::vttl::VTTLPolicy::new(maxsize, capacity)?;
 
         let self_ = Self {
-            raw: crate::mutex::Mutex::new(raw),
+            raw: crate::common::Mutex::new(raw),
         };
         Ok(self_)
     }
@@ -224,7 +224,7 @@ impl VTTLCache {
 
         let result = vttlcache_items {
             ptr: ObservedIterator::new(slf.as_ptr(), state),
-            iter: crate::mutex::Mutex::new(iter),
+            iter: crate::common::Mutex::new(iter),
             now: std::time::SystemTime::now(),
         };
 

src/common.rs

@@ -484,3 +484,7 @@ impl TimeToLivePair {
         }
     }
 }
+
+// Thanks to `Amanieu d'Antras` for this beautiful implementation.
+// https://github.com/Amanieu/parking_lot/blob/eeb186c48c8e6433c10f7552ef1cd1d56e5c83b1/src/raw_mutex.rs
+pub type Mutex<T> = lock_api::Mutex<parking_lot::RawMutex, T>;

src/lib.rs

@@ -2,7 +2,6 @@ use pyo3::prelude::*;
 
 mod lazyheap;
 mod linked_list;
-mod mutex;
 
 #[macro_use]
 mod common;