Change the behaviour of the iteratores

Previously, iterators used capacity and length of the cache to know "is cache have changes?" But now, each cache has a number called "state" that increments with each change; iterators now uses "state" number.
awolverp · Nov 25, 2024 · 09b6eb5 · 09b6eb5
1 parent 193fd31
commit 09b6eb5
Show file tree

Hide file tree

Showing 16 changed files with 207 additions and 92 deletions.
diff --git a/cachebox/_cachebox.pyi b/cachebox/_cachebox.pyi
@@ -32,6 +32,7 @@ class BaseCacheImpl(typing.Generic[KT, VT]):
     def __class_getitem__(*args) -> None: ...
     @property
     def maxsize(self) -> int: ...
+    def _state(self) -> int: ...
     def __len__(self) -> int: ...
     def __sizeof__(self) -> int: ...
     def __bool__(self) -> bool: ...

diff --git a/src/bridge/cache.rs b/src/bridge/cache.rs
@@ -54,6 +54,11 @@ impl Cache {
         lock.maxsize.get()
     }
 
+    pub fn _state(&self) -> usize {
+        let lock = self.raw.lock();
+        lock.state.get()
+    }
+
     /// Returns the number of elements in the table - len(self)
     pub fn __len__(&self) -> usize {
         let lock = self.raw.lock();
@@ -145,11 +150,11 @@ impl Cache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
         let iter = unsafe { lock.table.iter() };
 
         let result = cache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(iter),
             typ: 0,
         };
@@ -338,7 +343,8 @@ impl Cache {
     /// Shrinks the cache to fit len(self) elements.
     pub fn shrink_to_fit(&self) {
         let mut lock = self.raw.lock();
-        lock.table.shrink_to(0, |x| x.0.hash)
+        lock.table.shrink_to(0, |x| x.0.hash);
+        lock.state.change();
     }
 
     /// Updates the cache with elements from a dictionary or an iterable object of key/value pairs.
@@ -367,11 +373,11 @@ impl Cache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
         let iter = unsafe { lock.table.iter() };
 
         let result = cache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(iter),
             typ: 2,
         };
@@ -389,11 +395,11 @@ impl Cache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
         let iter = unsafe { lock.table.iter() };
 
         let result = cache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(iter),
             typ: 0,
         };
@@ -411,11 +417,11 @@ impl Cache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
         let iter = unsafe { lock.table.iter() };
 
         let result = cache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(iter),
             typ: 1,
         };

diff --git a/src/bridge/fifocache.rs b/src/bridge/fifocache.rs
@@ -48,6 +48,11 @@ impl FIFOCache {
         lock.maxsize.get()
     }
 
+    pub fn _state(&self) -> usize {
+        let lock = self.raw.lock();
+        lock.state.get()
+    }
+
     /// Returns the number of elements in the table - len(self)
     pub fn __len__(&self) -> usize {
         let lock = self.raw.lock();
@@ -137,10 +142,11 @@ impl FIFOCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<fifocache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let state = lock.state.get();
+        let len = lock.table.len();
 
         let result = fifocache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.iter()),
             typ: 0,
         };
@@ -365,10 +371,11 @@ impl FIFOCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<fifocache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let state = lock.state.get();
+        let len = lock.table.len();
 
         let result = fifocache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.iter()),
             typ: 2,
         };
@@ -385,10 +392,11 @@ impl FIFOCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<fifocache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let state = lock.state.get();
+        let len = lock.table.len();
 
         let result = fifocache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.iter()),
             typ: 0,
         };
@@ -405,10 +413,11 @@ impl FIFOCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<fifocache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let state = lock.state.get();
+        let len = lock.table.len();
 
         let result = fifocache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.iter()),
             typ: 1,
         };

diff --git a/src/bridge/lfucache.rs b/src/bridge/lfucache.rs
@@ -48,6 +48,11 @@ impl LFUCache {
         lock.maxsize.get()
     }
 
+    pub fn _state(&self) -> usize {
+        let lock = self.raw.lock();
+        lock.state.get()
+    }
+
     /// Returns the number of elements in the table - len(self)
     pub fn __len__(&self) -> usize {
         let lock = self.raw.lock();
@@ -144,10 +149,10 @@ impl LFUCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<lfucache_iterator>> {
         let mut lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
 
         let result = lfucache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.iter()),
             typ: 0,
         };
@@ -393,10 +398,10 @@ impl LFUCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<lfucache_iterator>> {
         let mut lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
 
         let result = lfucache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.iter()),
             typ: 2,
         };
@@ -413,10 +418,10 @@ impl LFUCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<lfucache_iterator>> {
         let mut lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
 
         let result = lfucache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.iter()),
             typ: 0,
         };
@@ -433,10 +438,10 @@ impl LFUCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<lfucache_iterator>> {
         let mut lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
 
         let result = lfucache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.iter()),
             typ: 1,
         };

diff --git a/src/bridge/lrucache.rs b/src/bridge/lrucache.rs
@@ -48,6 +48,11 @@ impl LRUCache {
         lock.maxsize.get()
     }
 
+    pub fn _state(&self) -> usize {
+        let lock = self.raw.lock();
+        lock.state.get()
+    }
+
     /// Returns the number of elements in the table - len(self)
     pub fn __len__(&self) -> usize {
         let lock = self.raw.lock();
@@ -138,10 +143,10 @@ impl LRUCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<lrucache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
 
         let result = lrucache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.list.iter()),
             typ: 0,
         };
@@ -387,10 +392,10 @@ impl LRUCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<lrucache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
 
         let result = lrucache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.list.iter()),
             typ: 2,
         };
@@ -407,10 +412,10 @@ impl LRUCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<lrucache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
 
         let result = lrucache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.list.iter()),
             typ: 0,
         };
@@ -427,10 +432,10 @@ impl LRUCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<lrucache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
 
         let result = lrucache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(lock.list.iter()),
             typ: 1,
         };

diff --git a/src/bridge/rrcache.rs b/src/bridge/rrcache.rs
@@ -83,6 +83,11 @@ impl RRCache {
         lock.maxsize.get()
     }
 
+    pub fn _state(&self) -> usize {
+        let lock = self.raw.lock();
+        lock.state.get()
+    }
+
     /// Returns the number of elements in the table - len(self)
     pub fn __len__(&self) -> usize {
         let lock = self.raw.lock();
@@ -174,11 +179,11 @@ impl RRCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
         let iter = unsafe { lock.table.iter() };
 
         let result = cache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(iter),
             typ: 0,
         };
@@ -376,7 +381,8 @@ impl RRCache {
     /// Shrinks the cache to fit len(self) elements.
     pub fn shrink_to_fit(&self) {
         let mut lock = self.raw.lock();
-        lock.table.shrink_to(0, |x| x.0.hash)
+        lock.table.shrink_to(0, |x| x.0.hash);
+        lock.state.change();
     }
 
     /// Updates the cache with elements from a dictionary or an iterable object of key/value pairs.
@@ -430,11 +436,11 @@ impl RRCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
         let iter = unsafe { lock.table.iter() };
 
         let result = cache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(iter),
             typ: 2,
         };
@@ -452,11 +458,11 @@ impl RRCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
         let iter = unsafe { lock.table.iter() };
 
         let result = cache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(iter),
             typ: 0,
         };
@@ -474,11 +480,11 @@ impl RRCache {
         py: pyo3::Python<'_>,
     ) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
         let lock = slf.raw.lock();
-        let (len, capacity) = (lock.table.len(), lock.table.capacity());
+        let (len, state) = (lock.table.len(), lock.state.get());
         let iter = unsafe { lock.table.iter() };
 
         let result = cache_iterator {
-            ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
+            ptr: _KeepForIter::new(slf.as_ptr(), state, len),
             iter: crate::mutex::Mutex::new(iter),
             typ: 1,
         };