Release 0.3.0

  - Add new methods to EventQueue
  - Update depedencies

Author: spnrapp

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spnr-lib"
-version = "0.2.3"
+version = "0.3.0"
 edition = "2021"
 authors = [ "spnr@spnr.app" ]
 description = "Rust library for building smart contracts on the Internet Computer, by the Spinner.Cash team."
@@ -13,8 +13,8 @@ keywords = ["internet-computer", "types", "canister", "spnr", "spinner"]
 include = ["src", "Cargo.toml", "LICENSE", "README.md"]
 
 [dependencies]
-candid = "0.7"
-ic-cdk = "0.5"
+candid = "0.10"
+ic-cdk = "0.17"
 serde = "1.0"
 serde_derive = "1.0"
 

src/event_queue.rs

@@ -1,7 +1,7 @@
 /// An event queue ordered by expiry time.
 ///
 /// Each event has an id and status, and they can be inserted/looked up/purged from the queue.
-use ic_cdk::export::candid::CandidType;
+use candid::CandidType;
 use serde::{Deserialize, Serialize};
 use std::collections::{btree_map::Entry, BTreeMap};
 use std::{error, fmt};
@@ -126,7 +126,7 @@ impl<I: Ord, T> EventQueue<I, T> {
     }
 
     /// Remove all events with an expiry less than the given expiry.
-    /// This operation is `O(log(n))`.
+    /// This operation is `O(log(n))+O(m)`, where `m` is the number of events removed.
     pub fn purge_expired(&mut self, expiry: u64)
     where
         I: Default,
@@ -135,7 +135,11 @@ impl<I: Ord, T> EventQueue<I, T> {
             expiry,
             nonce: I::default(),
         };
-        self.events = self.events.split_off(&key);
+        let to_keep = self.events.split_off(&key);
+        for to_remove in self.events.keys() {
+            self.index.remove(&to_remove.nonce);
+        }
+        self.events = to_keep;
     }
 
     /// Lookup event status given an event id.
@@ -144,6 +148,17 @@ impl<I: Ord, T> EventQueue<I, T> {
         self.events.get(id)
     }
 
+    /// Lookup event status given an event id.
+    /// This operation is `O(log(n))`.
+    pub fn remove(&mut self, id: &EventId<I>) -> Option<T> {
+        if let Some(value) = self.events.remove(id) {
+            self.index.remove(&id.nonce);
+            Some(value)
+        } else {
+            None
+        }
+    }
+
     /// Modify the status of an event given its id.
     /// This operation is `O(log(n))`.
     pub fn modify<F: FnOnce(&mut T)>(&mut self, id: EventId<I>, f: F) {
@@ -158,12 +173,23 @@ impl<I: Ord, T> EventQueue<I, T> {
             .and_then(|id| self.events.get(id).map(|e| (id, e)))
     }
 
+    /// Return max capacity.
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
     /// Return number of events in the queue.
     /// This operation is constant time.
     pub fn len(&self) -> usize {
         self.events.len()
     }
 
+    /// Return true if the queue is at its max capacity.
+    /// This operation is constant time.
+    pub fn is_full(&self) -> bool {
+        self.events.len() == self.capacity
+    }
+
     /// Return true if the queue is empty.
     /// This operation is constant time.
     pub fn is_empty(&self) -> bool {
@@ -195,7 +221,7 @@ mod test {
     use super::*;
     use assert_matches::*;
 
-    #[derive(Debug, PartialEq, Eq)]
+    #[derive(Clone, Debug, PartialEq, Eq)]
     enum Item {
         Begin(u8),
         Middle(u8),
@@ -255,6 +281,8 @@ mod test {
         assert!(q.selfcheck());
         assert_eq!(q.len(), 7);
 
+        let mut p = q.clone();
+
         // test purge
         q.purge(1, is_begin);
         assert_eq!(q.len(), 6);
@@ -268,5 +296,15 @@ mod test {
         q.purge(2, is_begin);
         assert_eq!(q.len(), 0);
         assert!(q.selfcheck());
+
+        // test purge_expired
+        println!("{:?}", p.iter().collect::<Vec<_>>());
+        p.purge_expired(1);
+        assert_eq!(p.len(), 5);
+        assert!(p.selfcheck());
+
+        p.purge_expired(2);
+        assert_eq!(p.len(), 0);
+        assert!(p.selfcheck());
     }
 }

src/log.rs

@@ -6,7 +6,7 @@
 //! We can first seek to the right bucket, then seek to an index within the bucket.
 //! During writes, if the current bucket is full, a new bucket will be created to store the next entry.
 use crate::storage::*;
-use ic_cdk::export::candid::CandidType;
+use candid::CandidType;
 use serde::{Deserialize, Serialize};
 
 /// The state and configuration of the log.

src/storage.rs

@@ -72,12 +72,12 @@ impl Default for StableStorage {
     fn default() -> Self {
         let mut storage = Self {
             offset: 0,
-            capacity: stable::stable64_size(),
+            capacity: stable::stable_size(),
         };
         if storage.capacity > 0 {
             let cap = storage.capacity << 16;
             let mut bytes = [0; 8];
-            stable::stable64_read(cap - 8, &mut bytes);
+            stable::stable_read(cap - 8, &mut bytes);
             storage.offset = u64::from_le_bytes(bytes);
         }
         storage
@@ -88,7 +88,7 @@ impl StableStorage {
     /// Attempt to grow the memory by adding new pages.
     fn grow(&mut self, added_pages: u64) -> Result<(), StorageError> {
         let old_page_count =
-            stable::stable64_grow(added_pages).map_err(|_| StorageError::OutOfMemory)?;
+            stable::stable_grow(added_pages).map_err(|_| StorageError::OutOfMemory)?;
         self.capacity = old_page_count + added_pages;
         Ok(())
     }
@@ -108,7 +108,7 @@ impl StableStorage {
         }
         let bytes = self.offset.to_le_bytes();
         io::Write::write(&mut self, &bytes)?;
-        stable::stable64_write(cap - 8, &bytes);
+        stable::stable_write(cap - 8, &bytes);
         Ok(())
     }
 }
@@ -119,7 +119,7 @@ impl io::Write for StableStorage {
             self.grow((buf.len() >> 16) as u64 + 1)?
         }
 
-        stable::stable64_write(self.offset, buf);
+        stable::stable_write(self.offset, buf);
         self.offset += buf.len() as u64;
         Ok(buf.len())
     }
@@ -187,7 +187,7 @@ impl StorageStack for StableStorage {
         self.seek_prev()?;
         let size = (end - self.offset) as usize;
         let mut bytes = vec![0; size];
-        stable::stable64_read(self.offset, &mut bytes);
+        stable::stable_read(self.offset, &mut bytes);
         let mut de = candid::de::IDLDeserialize::new(&bytes).map_err(StorageError::Candid)?;
         let res = candid::utils::ArgumentDecoder::decode(&mut de).map_err(StorageError::Candid)?;
         Ok(res)
@@ -199,7 +199,7 @@ impl StorageStack for StableStorage {
         }
         let mut bytes = [0; 8];
         let end = self.offset - 8;
-        stable::stable64_read(end, &mut bytes);
+        stable::stable_read(end, &mut bytes);
         let start = u64::from_le_bytes(bytes);
         if start > end {
             return Err(StorageError::OutOfBounds.into());
@@ -221,7 +221,7 @@ impl io::Read for StableStorage {
         } else {
             buf
         };
-        stable::stable64_read(self.offset, read_buf);
+        stable::stable_read(self.offset, read_buf);
         self.offset += read_buf.len() as u64;
         Ok(read_buf.len())
     }