Deque changes

packages/storage-plus/src/deque.rs

@@ -14,14 +14,14 @@ const HEAD_KEY: &[u8] = b"h";
 ///
 /// It has a maximum capacity of `u32::MAX - 1`. Make sure to never exceed that number when using this type.
 /// If you do, the methods won't work as intended anymore.
-pub struct VecDeque<'a, T> {
+pub struct Deque<'a, T> {
     // prefix of the deque items
     namespace: &'a [u8],
     // see https://doc.rust-lang.org/std/marker/struct.PhantomData.html#unused-type-parameters for why this is needed
     item_type: PhantomData<T>,
 }
 
-impl<'a, T> VecDeque<'a, T> {
+impl<'a, T> Deque<'a, T> {
     pub const fn new(prefix: &'a str) -> Self {
         Self {
             namespace: prefix.as_bytes(),
@@ -30,7 +30,7 @@ impl<'a, T> VecDeque<'a, T> {
     }
 }
 
-impl<'a, T: Serialize + DeserializeOwned> VecDeque<'a, T> {
+impl<'a, T: Serialize + DeserializeOwned> Deque<'a, T> {
     /// Adds the given value to the end of the deque
     pub fn push_back(&self, storage: &mut dyn Storage, value: &T) -> StdResult<()> {
         // save value
@@ -196,10 +196,9 @@ fn calc_len(head: u32, tail: u32) -> u32 {
     tail.wrapping_sub(head)
 }
 
-#[cfg(feature = "iterator")]
-impl<'a, T: Serialize + DeserializeOwned> VecDeque<'a, T> {
-    pub fn iter(&self, storage: &'a dyn Storage) -> StdResult<VecDequeIter<T>> {
-        Ok(VecDequeIter {
+impl<'a, T: Serialize + DeserializeOwned> Deque<'a, T> {
+    pub fn iter(&self, storage: &'a dyn Storage) -> StdResult<DequeIter<T>> {
+        Ok(DequeIter {
             deque: self,
             storage,
             start: self.head(storage)?,
@@ -208,19 +207,17 @@ impl<'a, T: Serialize + DeserializeOwned> VecDeque<'a, T> {
     }
 }
 
-#[cfg(feature = "iterator")]
-pub struct VecDequeIter<'a, T>
+pub struct DequeIter<'a, T>
 where
     T: Serialize + DeserializeOwned,
 {
-    deque: &'a VecDeque<'a, T>,
+    deque: &'a Deque<'a, T>,
     storage: &'a dyn Storage,
     start: u32,
     end: u32,
 }
 
-#[cfg(feature = "iterator")]
-impl<'a, T> Iterator for VecDequeIter<'a, T>
+impl<'a, T> Iterator for DequeIter<'a, T>
 where
     T: Serialize + DeserializeOwned,
 {
@@ -261,8 +258,7 @@ where
     }
 }
 
-#[cfg(feature = "iterator")]
-impl<'a, T> DoubleEndedIterator for VecDequeIter<'a, T>
+impl<'a, T> DoubleEndedIterator for DequeIter<'a, T>
 where
     T: Serialize + DeserializeOwned,
 {
@@ -294,15 +290,15 @@ where
 }
 #[cfg(test)]
 mod tests {
-    use crate::deque::VecDeque;
+    use crate::deque::Deque;
 
     use cosmwasm_std::testing::MockStorage;
     use cosmwasm_std::{StdError, StdResult};
     use serde::{Deserialize, Serialize};
 
     #[test]
     fn push_and_pop() {
-        const PEOPLE: VecDeque<String> = VecDeque::new("people");
+        const PEOPLE: Deque<String> = Deque::new("people");
         let mut store = MockStorage::new();
 
         // push some entries
@@ -338,7 +334,7 @@ mod tests {
 
     #[test]
     fn length() {
-        let deque: VecDeque<u32> = VecDeque::new("test");
+        let deque: Deque<u32> = Deque::new("test");
         let mut store = MockStorage::new();
 
         assert_eq!(deque.len(&store).unwrap(), 0);
@@ -375,9 +371,8 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "iterator")]
     fn iterator() {
-        let deque: VecDeque<u32> = VecDeque::new("test");
+        let deque: Deque<u32> = Deque::new("test");
         let mut store = MockStorage::new();
 
         // push some items
@@ -401,9 +396,8 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "iterator")]
     fn reverse_iterator() {
-        let deque: VecDeque<u32> = VecDeque::new("test");
+        let deque: Deque<u32> = Deque::new("test");
         let mut store = MockStorage::new();
 
         // push some items
@@ -437,7 +431,7 @@ mod tests {
 
     #[test]
     fn wrapping() {
-        let deque: VecDeque<u32> = VecDeque::new("test");
+        let deque: Deque<u32> = Deque::new("test");
         let mut store = MockStorage::new();
 
         // simulate deque that was pushed and popped `u32::MAX` times
@@ -463,9 +457,8 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "iterator")]
     fn wrapping_iterator() {
-        let deque: VecDeque<u32> = VecDeque::new("test");
+        let deque: Deque<u32> = Deque::new("test");
         let mut store = MockStorage::new();
 
         deque.set_head(&mut store, u32::MAX);
@@ -488,7 +481,7 @@ mod tests {
 
     #[test]
     fn front_back() {
-        let deque: VecDeque<u64> = VecDeque::new("test");
+        let deque: Deque<u64> = Deque::new("test");
         let mut store = MockStorage::new();
 
         assert_eq!(deque.back(&store).unwrap(), None);
@@ -509,10 +502,9 @@ mod tests {
         pub age: i32,
     }
 
-    const DATA: VecDeque<Data> = VecDeque::new("data");
+    const DATA: Deque<Data> = Deque::new("data");
 
     #[test]
-    #[cfg(feature = "iterator")]
     fn readme_works() -> StdResult<()> {
         let mut store = MockStorage::new();
 
@@ -564,11 +556,10 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "iterator")]
     fn iterator_errors_when_item_missing() {
         let mut store = MockStorage::new();
 
-        let deque = VecDeque::new("error_test");
+        let deque = Deque::new("error_test");
 
         deque.push_back(&mut store, &1u32).unwrap();
         // manually remove it
@@ -593,7 +584,7 @@ mod tests {
     fn get() {
         let mut store = MockStorage::new();
 
-        let deque = VecDeque::new("test");
+        let deque = Deque::new("test");
 
         deque.push_back(&mut store, &1u32).unwrap();
         deque.push_back(&mut store, &2).unwrap();
@@ -615,7 +606,7 @@ mod tests {
         );
 
         // start fresh
-        let deque = VecDeque::new("test2");
+        let deque = Deque::new("test2");
 
         deque.push_back(&mut store, &0u32).unwrap();
         deque.push_back(&mut store, &1).unwrap();

packages/storage-plus/src/lib.rs

@@ -33,9 +33,8 @@ mod snapshot;
 #[cfg(feature = "iterator")]
 pub use bound::{Bound, Bounder, PrefixBound, RawBound};
 pub use de::KeyDeserialize;
-pub use deque::VecDeque;
-#[cfg(feature = "iterator")]
-pub use deque::VecDequeIter;
+pub use deque::Deque;
+pub use deque::DequeIter;
 pub use endian::Endian;
 #[cfg(feature = "iterator")]
 pub use indexed_map::{IndexList, IndexedMap};