Readme updated. Clone implemented for AppendStore and DequeStore

Author: srdtrk

packages/storage/Readme.md

@@ -1,6 +1,6 @@
 # Secret Contract Development Toolkit - Storage Tools
 
-⚠️ This package is a sub-package of the `secret-toolkit` package. Please see its crate page for more context. You need Rust 1.61+ to compile this package.
+⚠️ This package is a sub-package of the `secret-toolkit` package. Please see its crate page for more context. You need Rust 1.63+ to compile this package.
 
 This package contains many tools related to storage access patterns. This readme file assumes basic familiarity with basic cosmwasm storage, [click here to learn about this](https://docs.scrt.network/secret-network-documentation/development/secret-contracts/storage).
 
@@ -28,7 +28,7 @@ This is the simplest storage object in this toolkit. It based on the similarly n
 
 #### **Initialize**
 
-This object is meant to be initialized as a constant in `state.rs`. However, it would also work perfectly fine if it was initialized during run time with a variable key (in this case though, you'd have to remind it what type of object is stored and its serde). Import it using the following lines:
+This object is meant to be initialized as a static constant in `state.rs`. However, it would also work perfectly fine if it was initialized during run time with a variable key (in this case though, you'd have to remind it what type of object is stored and its serde). Import it using the following lines:
 
 ```rust
 use secret_toolkit_storage::{Item}
@@ -37,7 +37,7 @@ use secret_toolkit_storage::{Item}
 And initialize it using the following lines:
 
 ```rust
-pub const OWNER: Item<HumanAddr> = Item::new(b"owner");
+pub static OWNER: Item<HumanAddr> = Item::new(b"owner");
 ```
 
 This uses Bincode2 to serde HumanAddr by default. To specify the Serde algorithm as Json, first import it from `secret-toolkit-serialization`
@@ -49,7 +49,7 @@ use secret_toolkit_serialization::{Bincode2, Json};
 then
 
 ```rust
-pub const SOME_ENUM: Item<SomeEnum, Json> = Item::new(b"some_enum");
+pub static SOME_ENUM: Item<SomeEnum, Json> = Item::new(b"some_enum");
 ```
 
 #### **Read/Write**
@@ -95,16 +95,18 @@ The same conventions from `Item` also apply here, that is:
 
 #### **Initialize**
 
-To import and intialize this storage object as a constant in `state.rs`, do the following:
+To import and intialize this storage object as a static constant in `state.rs`, do the following:
 
 ```rust
 use secret_toolkit::storage::{AppendStore}
 ```
 
 ```rust
-pub const COUNT_STORE: AppendStore<i32> = AppendStore::new(b"count");
+pub static COUNT_STORE: AppendStore<i32> = AppendStore::new(b"count");
 ```
 
+> ❗ Initializing the object as const instead of static will also work but be less efficient since the variable won't be able to cache length data.
+
 Often times we need these storage objects to be associated to a user address or some other key that is variable. In this case, you need not initialize a completely new AppendStore inside `contract.rs`. Instead, you can create a new AppendStore by adding a suffix to an already existing AppendStore. This has the benefit of preventing you from having to rewrite the signature of the AppendStore. For example
 
 ```rust
@@ -133,35 +135,24 @@ let page_size: u32 = 5;
 let values = user_count_store.paging(&deps.storage, start_page, page_size)?;
 ```
 
-> ❗ When using any iterators in any of the storage objects, the following will result in a compiling error.
-
-```rust
-let iterator = COUNT_STORE.iter(&deps.storage)?;
-```
-
-However, the follwoing will not result in an error:
-
-```rust
-let append_store = COUNT_STORE
-let iterator = append_store.iter(&deps.storage)?;
-```
-
 ### **DequeStore**
 
 This is a storage wrapper based on AppendStore that replicates a double ended list. This storage object allows the user to efficiently pop/push items to either end of the list.
 
 #### **Init**
 
-To import and intialize this storage object as a constant in `state.rs`, do the following:
+To import and intialize this storage object as a static constant in `state.rs`, do the following:
 
 ```rust
 use secret_toolkit_storage::{DequeStore}
 ```
 
 ```rust
-pub const COUNT_STORE: DequeStore<i32> = DequeStore::new(b"count");
+pub static COUNT_STORE: DequeStore<i32> = DequeStore::new(b"count");
 ```
 
+> ❗ Initializing the object as const instead of static will also work but be less efficient since the variable won't be able to cache length data.
+
 #### **Read/Write**
 
 The main user facing methods to read/write to DequeStore are `pop_back`, `pop_front`, `push_back`, `push_front`, `get_len`, `get_off`, `set_at` (which replaces data at a position within the length bound), `clear` (which deletes all data in the storage), `remove` (which removes an item in an arbitrary position, this is very inefficient). An extensive list of examples of these being used can be found inside the unit tests of DequeStore found in `deque_store.rs`.
@@ -179,17 +170,19 @@ be returned in each page.
 
 #### **Init**
 
-To import and intialize this storage object as a constant in `state.rs`, do the following:
+To import and intialize this storage object as a static constant in `state.rs`, do the following:
 
 ```rust
 use secret_toolkit_storage::{Keymap}
 ```
 
 ```rust
-pub const ADDR_VOTE: Keymap<HumanAddr, Foo> = Keymap::new(b"vote");
-pub const BET_STORE: Keymap<u32, BetInfo> = Keymap::new(b"vote");
+pub static ADDR_VOTE: Keymap<HumanAddr, Foo> = Keymap::new(b"vote");
+pub static BET_STORE: Keymap<u32, BetInfo> = Keymap::new(b"vote");
 ```
 
+> ❗ Initializing the object as const instead of static will also work but be less efficient since the variable won't be able to cache length data.
+
 You can use Json serde algorithm by changing the signature to `Keymap<HumanAddr, Uint128, Json>`, similar to all the other storage objects above. However, keep in mind that the Serde algorthm is used to serde both the stored object (`Uint128`) AND the key (`HumanAddr`).
 
 If you need to associate a keymap to a user address (or any other variable), then you can also do this using the `.add_suffix` method.

packages/storage/src/append_store.rs

@@ -170,6 +170,17 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> {
     }
 }
 
+impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> Clone for AppendStore<'a, T, Ser> {
+    fn clone(&self) -> Self {
+        Self {
+            namespace: self.namespace.clone(),
+            prefix: self.prefix.clone(),
+            length: Mutex::new(None),
+            item_type: self.item_type.clone(),
+            serialization_type: self.serialization_type.clone() }
+    }
+}
+
 impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> {
     fn as_slice(&self) -> &[u8] {
         if let Some(prefix) = &self.prefix {

packages/storage/src/deque_store.rs

@@ -283,6 +283,18 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> DequeStore<'a, T, Ser> {
     }
 }
 
+impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> Clone for DequeStore<'a, T, Ser> {
+    fn clone(&self) -> Self {
+        Self {
+            namespace: self.namespace.clone(),
+            prefix: self.prefix.clone(),
+            length: Mutex::new(None),
+            offset: Mutex::new(None),
+            item_type: self.item_type.clone(),
+            serialization_type: self.serialization_type.clone() }
+    }
+}
+
 /// An iterator over the contents of the deque store.
 pub struct DequeStoreIter<'a, T, S, Ser>
 where

packages/storage/src/keymap.rs

@@ -370,6 +370,18 @@ impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser:
     }
 }
 
+impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Serde> Clone for Keymap<'a, K, T, Ser> {
+    fn clone(&self) -> Self {
+        Self {
+            namespace: self.namespace.clone(),
+            prefix: self.prefix.clone(),
+            length: Mutex::new(None),
+            key_type: self.key_type.clone(),
+            item_type: self.item_type.clone(),
+            serialization_type: self.serialization_type.clone() }
+    }
+}
+
 /// An iterator over the keys of the Keymap.
 pub struct KeyIter<'a, K, T, S, Ser>
 where