From 9f3b9e1af5f7ead796d51abaae70badb6611d8f2 Mon Sep 17 00:00:00 2001 From: Eshel Date: Tue, 7 Feb 2023 17:06:08 +0200 Subject: [PATCH 1/5] renamed Keymap to Map --- Releases.md | 8 +- packages/storage/Readme.md | 86 ++++---- packages/storage/src/keymap.rs | 366 ++++++++++++++++----------------- packages/storage/src/keyset.rs | 18 +- packages/storage/src/lib.rs | 2 +- 5 files changed, 240 insertions(+), 240 deletions(-) diff --git a/Releases.md b/Releases.md index 84378a7..22cd47a 100644 --- a/Releases.md +++ b/Releases.md @@ -14,9 +14,9 @@ The APIs remains the same, but it is necessary to upgrade the contract's `cosmwa - This release changes the internal toolkit package to be part of the workspace - this fixes default-features flags in some of the crates. In addition, crates used by the toolkit have been bumped, and the edition of the toolkit crates has been bumped to 2021. - Added the `Keyset` storage object (A hashset like storage object). -- Allowed further customisation of Keymap and Keyset with new constructor structs called `KeymapBuilder` and `KeysetBuilder` which allow the user to disable the iterator feature (saving gas) or adjust the internal indexes' page size so that the user may determine how many objects are to be stored/loaded together in the iterator. +- Allowed further customisation of Map and Keyset with new constructor structs called `MapBuilder` and `KeysetBuilder` which allow the user to disable the iterator feature (saving gas) or adjust the internal indexes' page size so that the user may determine how many objects are to be stored/loaded together in the iterator. - `::new_with_page_size(namespace, page_size)` method was added to `AppendStore` and `DequeStore` so that the user may adjust the internal indexes' page size which determine how many objects are to be stored/loaded together in the iterator. -- Minor performance upgrades to `Keymap`, `AppendStore`, and `DequeStore`. +- Minor performance upgrades to `Map`, `AppendStore`, and `DequeStore`. ### Breaking @@ -40,7 +40,7 @@ are prone to bugs, or inefficient. Unless you are using these specific interface ### Breaking - Removed the implementations of Clone for storage types which are not useful and may cause data corruption if used incorrectly. -- Changed `Keymap::insert` to take the item by reference rather than by value. This should reduce the cost of calling that function by avoiding cloning. +- Changed `Map::insert` to take the item by reference rather than by value. This should reduce the cost of calling that function by avoiding cloning. ### Features @@ -50,7 +50,7 @@ are prone to bugs, or inefficient. Unless you are using these specific interface * BUGFIX: implementation of `.clone` method fixed * Added `.add_suffix` and `.clone` methods to `secret-toolkit::storage::Item` -* Minor performance updates to `secret-toolkit::storage::Keymap` +* Minor performance updates to `secret-toolkit::storage::Map` ## secret-toolkit-storage v0.4.1 diff --git a/packages/storage/Readme.md b/packages/storage/Readme.md index 187017a..a3c68da 100644 --- a/packages/storage/Readme.md +++ b/packages/storage/Readme.md @@ -244,7 +244,7 @@ The main user facing methods to read/write to DequeStore are `pop_back`, `pop_fr This is exactly same as that of AppendStore. -### **Keymap** +### **Map** This hashmap-like storage structure allows the user to use generic typed keys to store objects. Allows iteration with paging over keys and/or items (without guaranteed ordering, although the order of insertion is preserved until you start removing objects). An example use-case for such a structure is if you want to contain a large amount of votes, deposits, or bets and iterate over them at some time in the future. @@ -256,11 +256,11 @@ be returned in each page. To import and initialize this storage object as a static constant in `state.rs`, do the following: ```ignore -use secret_toolkit::storage::{Keymap, KeymapBuilder}; +use secret_toolkit::storage::{Map, MapBuilder}; ``` ```rust -# use secret_toolkit_storage::Keymap; +# use secret_toolkit_storage::Map; # use cosmwasm_std::{Addr}; # use serde::{Serialize, Deserialize}; # #[derive(Serialize, Deserialize)] @@ -268,79 +268,79 @@ use secret_toolkit::storage::{Keymap, KeymapBuilder}; # #[derive(Serialize, Deserialize)] # struct Foo { vote_for: String }; # -pub static ADDR_VOTE: Keymap = Keymap::new(b"vote"); -pub static BET_STORE: Keymap = Keymap::new(b"bet"); +pub static ADDR_VOTE: Map = Map::new(b"vote"); +pub static BET_STORE: Map = Map::new(b"bet"); ``` > ❗ 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`, similar to all the other storage objects above. However, keep in mind that the Serde algorithm is used to serde both the stored object (`Uint128`) AND the key (`Addr`). +You can use Json serde algorithm by changing the signature to `Map`, similar to all the other storage objects above. However, keep in mind that the Serde algorithm is used to serde both the stored object (`Uint128`) AND the key (`Addr`). -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. +If you need to associate a map to a user address (or any other variable), then you can also do this using the `.add_suffix` method. -For example, suppose that in your contract, a user can make multiple bets. Then, you'd want a Keymap to be associated to each user. You would achieve this by doing the following during execution in `contract.rs`. +For example, suppose that in your contract, a user can make multiple bets. Then, you'd want a Map to be associated to each user. You would achieve this by doing the following during execution in `contract.rs`. ```rust -# use secret_toolkit_storage::Keymap; +# use secret_toolkit_storage::Map; # use cosmwasm_std::{Addr, testing::mock_info}; # use serde::{Serialize, Deserialize}; # #[derive(Serialize, Deserialize)] # struct BetInfo { bet_outcome: u32, amount: u32 }; # let info = mock_info("sender", &[]); # -pub static BET_STORE: Keymap = Keymap::new(b"bet"); +pub static BET_STORE: Map = Map::new(b"bet"); // The compiler knows that user_bet_store is AppendStore let user_count_store = BET_STORE.add_suffix(info.sender.to_string().as_bytes()); ``` #### **Advanced Init** -It is also possible to modify some of the configuration settings of the Keymap structure so that it suits better to a specific use case. In this case, we use a struct called `KeymapBuilder` to build a keymap with specialized config. Currently, we can use KeymapBuilder to modify two attributes of keymaps. +It is also possible to modify some of the configuration settings of the Map structure so that it suits better to a specific use case. In this case, we use a struct called `MapBuilder` to build a map with specialized config. Currently, we can use MapBuilder to modify two attributes of maps. -One is to disable the iterator feature altogether using `.without_iter()`. This basically turns a keymap into a typed PrefixedStorage, but it also saves a ton of gas by not storing the keys and the length of the keymap. +One is to disable the iterator feature altogether using `.without_iter()`. This basically turns a map into a typed PrefixedStorage, but it also saves a ton of gas by not storing the keys and the length of the map. -The other feature is to modify the page size of the internal indexer (only if the iterator feature is enabled, i.e. this setting is irrelevant if `.without_iter()` is used). Keymap iterates by using internal index pages allowing it to load the next 5 objects at the same time. You can change the default 5 to any `u32` greater than zero by using `.with_page_size(num)`. This allows the user to optimize the gas usage of Keymap. +The other feature is to modify the page size of the internal indexer (only if the iterator feature is enabled, i.e. this setting is irrelevant if `.without_iter()` is used). Map iterates by using internal index pages allowing it to load the next 5 objects at the same time. You can change the default 5 to any `u32` greater than zero by using `.with_page_size(num)`. This allows the user to optimize the gas usage of Map. -The following is used to produce a Keymap without an iterator in `state.rs` +The following is used to produce a Map without an iterator in `state.rs` ```rust -# use secret_toolkit_storage::{Keymap, KeymapBuilder, WithoutIter}; +# use secret_toolkit_storage::{Map, MapBuilder, WithoutIter}; # use secret_toolkit_serialization::{Json, Bincode2}; # use serde::{Serialize, Deserialize}; # #[derive(Serialize, Deserialize)] # struct Foo { vote: u32 }; # -pub static JSON_ADDR_VOTE: Keymap = - KeymapBuilder::new(b"json_vote").without_iter().build(); +pub static JSON_ADDR_VOTE: Map = + MapBuilder::new(b"json_vote").without_iter().build(); -pub static BINCODE_ADDR_VOTE: Keymap = - KeymapBuilder::new(b"bincode_vote").without_iter().build(); +pub static BINCODE_ADDR_VOTE: Map = + MapBuilder::new(b"bincode_vote").without_iter().build(); ``` -The following is used to produce a Keymap with modified index page size: +The following is used to produce a Map with modified index page size: ```rust -# use secret_toolkit_storage::{Keymap, KeymapBuilder}; +# use secret_toolkit_storage::{Map, MapBuilder}; # use cosmwasm_std::{Addr}; # use secret_toolkit_serialization::{Json}; # use serde::{Serialize, Deserialize}; # #[derive(Serialize, Deserialize)] # struct Foo { vote: u32 }; # -pub static ADDR_VOTE: Keymap = KeymapBuilder::new(b"page_vote").with_page_size(13).build(); +pub static ADDR_VOTE: Map = MapBuilder::new(b"page_vote").with_page_size(13).build(); -pub static JSON_VOTE: Keymap = - KeymapBuilder::new(b"page_vote").with_page_size(3).build(); +pub static JSON_VOTE: Map = + MapBuilder::new(b"page_vote").with_page_size(3).build(); ``` #### **Read/Write** -You can find more examples of using keymaps in the unit tests of Keymap in `keymap.rs`. +You can find more examples of using maps in the unit tests of Map in `keymap.rs`. -To insert, remove, read from the keymap, do the following: +To insert, remove, read from the map, do the following: ```rust -# use secret_toolkit_storage::{Keymap, KeymapBuilder}; +# use secret_toolkit_storage::{Map, MapBuilder}; # use cosmwasm_std::{Addr, testing::{mock_info, mock_dependencies}, StdError}; # use serde::{Serialize, Deserialize}; # #[derive(Serialize, Deserialize, PartialEq, Debug)] @@ -348,7 +348,7 @@ To insert, remove, read from the keymap, do the following: # # let mut deps = mock_dependencies(); # let info = mock_info("sender", &[]); -# pub static ADDR_VOTE: Keymap = KeymapBuilder::new(b"page_vote").with_page_size(13).build(); +# pub static ADDR_VOTE: Map = MapBuilder::new(b"page_vote").with_page_size(13).build(); # let user_addr: Addr = info.sender; @@ -368,23 +368,23 @@ assert_eq!(ADDR_VOTE.get_len(deps.as_ref().storage)?, 0); #### **Iterator** -There are two methods that create an iterator in Keymap. These are `.iter` and `.iter_keys`. `iter_keys` only iterates over the keys whereas `iter` iterates over (key, item) pairs. Needless to say, `.iter_keys` is more efficient as it does not attempt to read the item. +There are two methods that create an iterator in Map. These are `.iter` and `.iter_keys`. `iter_keys` only iterates over the keys whereas `iter` iterates over (key, item) pairs. Needless to say, `.iter_keys` is more efficient as it does not attempt to read the item. -Keymap also has two paging methods, these are `.paging` and `.paging_keys`. `paging_keys` only paginates keys whereas `iter` iterates over (key, item) pairs. Needless to say, `.iter_keys` is more efficient as it does not attempt to read the item. +Map also has two paging methods, these are `.paging` and `.paging_keys`. `paging_keys` only paginates keys whereas `iter` iterates over (key, item) pairs. Needless to say, `.iter_keys` is more efficient as it does not attempt to read the item. Here are some select examples from the unit tests: ```rust # use cosmwasm_std::{StdResult, testing::MockStorage}; -# use secret_toolkit_storage::Keymap; +# use secret_toolkit_storage::Map; # use serde::{Serialize, Deserialize}; # #[derive(Serialize, Deserialize, PartialEq, Debug)] # struct Foo { string: String, number: u32 }; # -fn test_keymap_iter_keys() -> StdResult<()> { +fn test_map_iter_keys() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap = Keymap::new(b"test"); + let map: Map = Map::new(b"test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -397,10 +397,10 @@ fn test_keymap_iter_keys() -> StdResult<()> { let key1 = "key1".to_string(); let key2 = "key2".to_string(); - keymap.insert(&mut storage, &key1, &foo1)?; - keymap.insert(&mut storage, &key2, &foo2)?; + map.insert(&mut storage, &key1, &foo1)?; + map.insert(&mut storage, &key2, &foo2)?; - let mut x = keymap.iter_keys(&storage)?; + let mut x = map.iter_keys(&storage)?; let (len, _) = x.size_hint(); assert_eq!(len, 2); @@ -414,15 +414,15 @@ fn test_keymap_iter_keys() -> StdResult<()> { ```rust # use cosmwasm_std::{StdResult, testing::MockStorage}; -# use secret_toolkit_storage::Keymap; +# use secret_toolkit_storage::Map; # use serde::{Serialize, Deserialize}; # #[derive(Serialize, Deserialize, PartialEq, Debug)] # struct Foo { string: String, number: u32 }; # -fn test_keymap_iter() -> StdResult<()> { +fn test_map_iter() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = Keymap::new(b"test"); + let map: Map, Foo> = Map::new(b"test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -432,10 +432,10 @@ fn test_keymap_iter() -> StdResult<()> { number: 1111, }; - keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?; - keymap.insert(&mut storage, &b"key2".to_vec(), &foo2)?; + map.insert(&mut storage, &b"key1".to_vec(), &foo1)?; + map.insert(&mut storage, &b"key2".to_vec(), &foo2)?; - let mut x = keymap.iter(&storage)?; + let mut x = map.iter(&storage)?; let (len, _) = x.size_hint(); assert_eq!(len, 2); @@ -468,7 +468,7 @@ pub static WHITELIST: Keyset = Keyset::new(b"whitelist"); > ❗ 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. -> add_suffix and KeysetBuilder methods function similarly to that of Keymap's. +> add_suffix and KeysetBuilder methods function similarly to that of Map's. #### **Storage Methods** diff --git a/packages/storage/src/keymap.rs b/packages/storage/src/keymap.rs index df39c12..58148c3 100644 --- a/packages/storage/src/keymap.rs +++ b/packages/storage/src/keymap.rs @@ -47,7 +47,7 @@ impl InternalItem { } } -pub struct KeymapBuilder<'a, K, T, Ser = Bincode2, I = WithIter> { +pub struct MapBuilder<'a, K, T, Ser = Bincode2, I = WithIter> { /// namespace of the newly constructed Storage namespace: &'a [u8], page_size: u32, @@ -57,13 +57,13 @@ pub struct KeymapBuilder<'a, K, T, Ser = Bincode2, I = WithIter> { iter_option: PhantomData, } -impl<'a, K, T, Ser> KeymapBuilder<'a, K, T, Ser, WithIter> +impl<'a, K, T, Ser> MapBuilder<'a, K, T, Ser, WithIter> where K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Serde, { - /// Creates a KeymapBuilder with default features + /// Creates a MapBuilder with default features pub const fn new(namespace: &'a [u8]) -> Self { Self { namespace, @@ -77,7 +77,7 @@ where /// Modifies the number of keys stored in one page of indexing, for the iterator pub const fn with_page_size(&self, indexes_size: u32) -> Self { if indexes_size == 0 { - panic!("zero index page size used in keymap") + panic!("zero index page size used in map") } Self { namespace: self.namespace, @@ -88,9 +88,9 @@ where iter_option: self.iter_option, } } - /// Disables the iterator of the keymap, saving at least 4000 gas in each insertion. - pub const fn without_iter(&self) -> KeymapBuilder<'a, K, T, Ser, WithoutIter> { - KeymapBuilder { + /// Disables the iterator of the map, saving at least 4000 gas in each insertion. + pub const fn without_iter(&self) -> MapBuilder <'a, K, T, Ser, WithoutIter> { + MapBuilder { namespace: self.namespace, page_size: self.page_size, key_type: PhantomData, @@ -99,9 +99,9 @@ where iter_option: PhantomData, } } - /// Returns a keymap with the given configuration - pub const fn build(&self) -> Keymap<'a, K, T, Ser, WithIter> { - Keymap { + /// Returns a map with the given configuration + pub const fn build(&self) -> Map<'a, K, T, Ser, WithIter> { + Map { namespace: self.namespace, prefix: None, page_size: self.page_size, @@ -115,14 +115,14 @@ where } // This enables writing `.iter().skip(n).rev()` -impl<'a, K, T, Ser> KeymapBuilder<'a, K, T, Ser, WithoutIter> +impl<'a, K, T, Ser> MapBuilder<'a, K, T, Ser, WithoutIter> where K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Serde, { - pub const fn build(&self) -> Keymap<'a, K, T, Ser, WithoutIter> { - Keymap { + pub const fn build(&self) -> Map<'a, K, T, Ser, WithoutIter> { + Map { namespace: self.namespace, prefix: None, page_size: self.page_size, @@ -135,7 +135,7 @@ where } } -pub struct Keymap<'a, K, T, Ser = Bincode2, I = WithIter> +pub struct Map<'a, K, T, Ser = Bincode2, I = WithIter> where K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, @@ -155,7 +155,7 @@ where } impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Serde> - Keymap<'a, K, T, Ser> + Map<'a, K, T, Ser> { /// constructor pub const fn new(namespace: &'a [u8]) -> Self { @@ -171,8 +171,8 @@ impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: } } - /// This is used to produce a new Keymap. This can be used when you want to associate an Keymap to each user - /// and you still get to define the Keymap as a static constant + /// This is used to produce a new Map. This can be used when you want to associate an Map to each user + /// and you still get to define the Map as a static constant pub fn add_suffix(&self, suffix: &[u8]) -> Self { let suffix = to_length_prefixed(suffix); let prefix = self.prefix.as_deref().unwrap_or(self.namespace); @@ -191,7 +191,7 @@ impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: } impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Serde> - Keymap<'a, K, T, Ser, WithoutIter> + Map<'a, K, T, Ser, WithoutIter> { /// Serialize key fn serialize_key(&self, key: &K) -> StdResult> { @@ -233,7 +233,7 @@ impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: } impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Serde> - Keymap<'a, K, T, Ser, WithIter> + Map<'a, K, T, Ser, WithIter> { /// Serialize key fn serialize_key(&self, key: &K) -> StdResult> { @@ -359,7 +359,7 @@ impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: if indexes[pos_in_indexes] != key_vec { return Err(StdError::generic_err( - "tried to remove from keymap, but key not found in indexes - should never happen", + "tried to remove from map, but key not found in indexes - should never happen", )); } @@ -573,7 +573,7 @@ impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: } impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Serde> - PrefixedTypedStorage, Bincode2> for Keymap<'a, K, T, Ser, WithIter> + PrefixedTypedStorage, Bincode2> for Map<'a, K, T, Ser, WithIter> { fn as_slice(&self) -> &[u8] { if let Some(prefix) = &self.prefix { @@ -585,7 +585,7 @@ impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: } impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Serde> - PrefixedTypedStorage for Keymap<'a, K, T, Ser, WithoutIter> + PrefixedTypedStorage for Map<'a, K, T, Ser, WithoutIter> { fn as_slice(&self) -> &[u8] { if let Some(prefix) = &self.prefix { @@ -596,14 +596,14 @@ impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: } } -/// An iterator over the keys of the Keymap. +/// An iterator over the keys of the Map. pub struct KeyIter<'a, K, T, Ser> where K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Serde, { - keymap: &'a Keymap<'a, K, T, Ser>, + map: &'a Map<'a, K, T, Ser>, storage: &'a dyn Storage, start: u32, end: u32, @@ -618,13 +618,13 @@ where { /// constructor pub fn new( - keymap: &'a Keymap<'a, K, T, Ser>, + map: &'a Map<'a, K, T, Ser>, storage: &'a dyn Storage, start: u32, end: u32, ) -> Self { Self { - keymap, + map, storage, start, end, @@ -647,18 +647,18 @@ where } let key; - let page = self.keymap.page_from_position(self.start); - let indexes_pos = (self.start % self.keymap.page_size) as usize; + let page = self.map.page_from_position(self.start); + let indexes_pos = (self.start % self.map.page_size) as usize; match self.cache.get(&page) { Some(indexes) => { let key_data = &indexes[indexes_pos]; - key = self.keymap.deserialize_key(key_data); + key = self.map.deserialize_key(key_data); } - None => match self.keymap.get_indexes(self.storage, page) { + None => match self.map.get_indexes(self.storage, page) { Ok(indexes) => { let key_data = &indexes[indexes_pos]; - key = self.keymap.deserialize_key(key_data); + key = self.map.deserialize_key(key_data); self.cache.insert(page, indexes); } Err(e) => key = Err(e), @@ -699,18 +699,18 @@ where self.end -= 1; let key; - let page = self.keymap.page_from_position(self.end); - let indexes_pos = (self.end % self.keymap.page_size) as usize; + let page = self.map.page_from_position(self.end); + let indexes_pos = (self.end % self.map.page_size) as usize; match self.cache.get(&page) { Some(indexes) => { let key_data = &indexes[indexes_pos]; - key = self.keymap.deserialize_key(key_data); + key = self.map.deserialize_key(key_data); } - None => match self.keymap.get_indexes(self.storage, page) { + None => match self.map.get_indexes(self.storage, page) { Ok(indexes) => { let key_data = &indexes[indexes_pos]; - key = self.keymap.deserialize_key(key_data); + key = self.map.deserialize_key(key_data); self.cache.insert(page, indexes); } Err(e) => key = Err(e), @@ -742,14 +742,14 @@ where // =============================================================================================== -/// An iterator over the (key, item) pairs of the Keymap. Less efficient than just iterating over keys. +/// An iterator over the (key, item) pairs of the Map. Less efficient than just iterating over keys. pub struct KeyItemIter<'a, K, T, Ser> where K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Serde, { - keymap: &'a Keymap<'a, K, T, Ser>, + map: &'a Map<'a, K, T, Ser>, storage: &'a dyn Storage, start: u32, end: u32, @@ -764,13 +764,13 @@ where { /// constructor pub fn new( - keymap: &'a Keymap<'a, K, T, Ser>, + map: &'a Map<'a, K, T, Ser>, storage: &'a dyn Storage, start: u32, end: u32, ) -> Self { Self { - keymap, + map, storage, start, end, @@ -793,18 +793,18 @@ where } let key; - let page = self.keymap.page_from_position(self.start); - let indexes_pos = (self.start % self.keymap.page_size) as usize; + let page = self.map.page_from_position(self.start); + let indexes_pos = (self.start % self.map.page_size) as usize; match self.cache.get(&page) { Some(indexes) => { let key_data = &indexes[indexes_pos]; - key = self.keymap.deserialize_key(key_data); + key = self.map.deserialize_key(key_data); } - None => match self.keymap.get_indexes(self.storage, page) { + None => match self.map.get_indexes(self.storage, page) { Ok(indexes) => { let key_data = &indexes[indexes_pos]; - key = self.keymap.deserialize_key(key_data); + key = self.map.deserialize_key(key_data); self.cache.insert(page, indexes); } Err(e) => key = Err(e), @@ -813,7 +813,7 @@ where self.start += 1; // turn key into pair let pair = match key { - Ok(k) => match self.keymap.get_from_key(self.storage, &k) { + Ok(k) => match self.map.get_from_key(self.storage, &k) { Ok(internal_item) => match internal_item.get_item() { Ok(item) => Ok((k, item)), Err(e) => Err(e), @@ -856,18 +856,18 @@ where self.end -= 1; let key; - let page = self.keymap.page_from_position(self.end); - let indexes_pos = (self.end % self.keymap.page_size) as usize; + let page = self.map.page_from_position(self.end); + let indexes_pos = (self.end % self.map.page_size) as usize; match self.cache.get(&page) { Some(indexes) => { let key_data = &indexes[indexes_pos]; - key = self.keymap.deserialize_key(key_data); + key = self.map.deserialize_key(key_data); } - None => match self.keymap.get_indexes(self.storage, page) { + None => match self.map.get_indexes(self.storage, page) { Ok(indexes) => { let key_data = &indexes[indexes_pos]; - key = self.keymap.deserialize_key(key_data); + key = self.map.deserialize_key(key_data); self.cache.insert(page, indexes); } Err(e) => key = Err(e), @@ -875,7 +875,7 @@ where } // turn key into pair let pair = match key { - Ok(k) => match self.keymap.get_from_key(self.storage, &k) { + Ok(k) => match self.map.get_from_key(self.storage, &k) { Ok(internal_item) => match internal_item.get_item() { Ok(item) => Ok((k, item)), Err(e) => Err(e), @@ -993,61 +993,61 @@ mod tests { number: i32, } #[test] - fn test_keymap_perf_insert() -> StdResult<()> { + fn map_perf_insert() -> StdResult<()> { let mut storage = MockStorage::new(); let total_items = 1000; - let keymap: Keymap, i32> = Keymap::new(b"test"); + let map: Map, i32> = Map::new(b"test"); for i in 0..total_items { let key: Vec = (i as i32).to_be_bytes().to_vec(); - keymap.insert(&mut storage, &key, &i)?; + map.insert(&mut storage, &key, &i)?; } - assert_eq!(keymap.get_len(&storage)?, 1000); + assert_eq!(map.get_len(&storage)?, 1000); Ok(()) } #[test] - fn test_keymap_perf_insert_remove() -> StdResult<()> { + fn test_map_perf_insert_remove() -> StdResult<()> { let mut storage = MockStorage::new(); let total_items = 100; - let keymap: Keymap = Keymap::new(b"test"); + let map: Map = Map::new(b"test"); for i in 0..total_items { - keymap.insert(&mut storage, &i, &i)?; + map.insert(&mut storage, &i, &i)?; } for i in 0..total_items { - keymap.remove(&mut storage, &i)?; + map.remove(&mut storage, &i)?; } - assert_eq!(keymap.get_len(&storage)?, 0); + assert_eq!(map.get_len(&storage)?, 0); Ok(()) } #[test] - fn test_keymap_paging() -> StdResult<()> { + fn test_map_paging() -> StdResult<()> { let mut storage = MockStorage::new(); let page_size: u32 = 5; let total_items: u32 = 50; - let keymap: Keymap, u32> = Keymap::new(b"test"); + let map: Map, u32> = Map::new(b"test"); for i in 0..total_items { let key: Vec = (i as i32).to_be_bytes().to_vec(); - keymap.insert(&mut storage, &key, &i)?; + map.insert(&mut storage, &key, &i)?; } for i in 0..((total_items / page_size) - 1) { let start_page = i; - let values = keymap.paging(&storage, start_page, page_size)?; + let values = map.paging(&storage, start_page, page_size)?; for (index, (key_value, value)) in values.iter().enumerate() { let i = page_size * start_page + index as u32; @@ -1061,18 +1061,18 @@ mod tests { } #[test] - fn test_keymap_paging_overflow() -> StdResult<()> { + fn test_map_paging_overflow() -> StdResult<()> { let mut storage = MockStorage::new(); let page_size = 50; let total_items = 10; - let keymap: Keymap = Keymap::new(b"test"); + let map: Map = Map::new(b"test"); for i in 0..total_items { - keymap.insert(&mut storage, &(i as i32), &i)?; + map.insert(&mut storage, &(i as i32), &i)?; } - let values = keymap.paging_keys(&storage, 0, page_size)?; + let values = map.paging_keys(&storage, 0, page_size)?; assert_eq!(values.len(), total_items as usize); @@ -1084,10 +1084,10 @@ mod tests { } #[test] - fn test_keymap_insert_multiple() -> StdResult<()> { + fn test_map_insert_multiple() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = Keymap::new(b"test"); + let map: Map, Foo> = Map::new(b"test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1097,11 +1097,11 @@ mod tests { number: 1111, }; - keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?; - keymap.insert(&mut storage, &b"key2".to_vec(), &foo2)?; + map.insert(&mut storage, &b"key1".to_vec(), &foo1)?; + map.insert(&mut storage, &b"key2".to_vec(), &foo2)?; - let read_foo1 = keymap.get(&storage, &b"key1".to_vec()).unwrap(); - let read_foo2 = keymap.get(&storage, &b"key2".to_vec()).unwrap(); + let read_foo1 = map.get(&storage, &b"key1".to_vec()).unwrap(); + let read_foo2 = map.get(&storage, &b"key2".to_vec()).unwrap(); assert_eq!(foo1, read_foo1); assert_eq!(foo2, read_foo2); @@ -1109,17 +1109,17 @@ mod tests { } #[test] - fn test_keymap_contains() -> StdResult<()> { + fn test_map_contains() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = Keymap::new(b"test"); + let map: Map, Foo> = Map::new(b"test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, }; - keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?; - let contains_k1 = keymap.contains(&storage, &b"key1".to_vec()); + map.insert(&mut storage, &b"key1".to_vec(), &foo1)?; + let contains_k1 = map.contains(&storage, &b"key1".to_vec()); assert!(contains_k1); @@ -1127,10 +1127,10 @@ mod tests { } #[test] - fn test_keymap_iter() -> StdResult<()> { + fn test_map_iter() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = Keymap::new(b"test"); + let map: Map, Foo> = Map::new(b"test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1140,10 +1140,10 @@ mod tests { number: 1111, }; - keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?; - keymap.insert(&mut storage, &b"key2".to_vec(), &foo2)?; + map.insert(&mut storage, &b"key1".to_vec(), &foo1)?; + map.insert(&mut storage, &b"key2".to_vec(), &foo2)?; - let mut x = keymap.iter(&storage)?; + let mut x = map.iter(&storage)?; let (len, _) = x.size_hint(); assert_eq!(len, 2); @@ -1155,10 +1155,10 @@ mod tests { } #[test] - fn test_keymap_iter_keys() -> StdResult<()> { + fn test_map_iter_keys() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap = Keymap::new(b"test"); + let map: Map = Map::new(b"test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1171,10 +1171,10 @@ mod tests { let key1 = "key1".to_string(); let key2 = "key2".to_string(); - keymap.insert(&mut storage, &key1, &foo1)?; - keymap.insert(&mut storage, &key2, &foo2)?; + map.insert(&mut storage, &key1, &foo1)?; + map.insert(&mut storage, &key2, &foo2)?; - let mut x = keymap.iter_keys(&storage)?; + let mut x = map.iter_keys(&storage)?; let (len, _) = x.size_hint(); assert_eq!(len, 2); @@ -1186,10 +1186,10 @@ mod tests { } #[test] - fn test_keymap_overwrite() -> StdResult<()> { + fn test_map_overwrite() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = Keymap::new(b"test"); + let map: Map, Foo> = Map::new(b"test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1199,10 +1199,10 @@ mod tests { number: 2222, }; - keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?; - keymap.insert(&mut storage, &b"key1".to_vec(), &foo2)?; + map.insert(&mut storage, &b"key1".to_vec(), &foo1)?; + map.insert(&mut storage, &b"key1".to_vec(), &foo2)?; - let foo3 = keymap.get(&storage, &b"key1".to_vec()).unwrap(); + let foo3 = map.get(&storage, &b"key1".to_vec()).unwrap(); assert_eq!(foo3, foo2); @@ -1210,11 +1210,11 @@ mod tests { } #[test] - fn test_keymap_suffixed_basics() -> StdResult<()> { + fn test_map_suffixed_basics() -> StdResult<()> { let mut storage = MockStorage::new(); - let original_keymap: Keymap = Keymap::new(b"test"); - let keymap = original_keymap.add_suffix(b"test_suffix"); + let original_map: Map = Map::new(b"test"); + let map = original_map.add_suffix(b"test_suffix"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1223,48 +1223,48 @@ mod tests { string: "string one".to_string(), number: 1111, }; - keymap.insert(&mut storage, &"key1".to_string(), &foo1)?; - keymap.insert(&mut storage, &"key2".to_string(), &foo2)?; + map.insert(&mut storage, &"key1".to_string(), &foo1)?; + map.insert(&mut storage, &"key2".to_string(), &foo2)?; - let read_foo1 = keymap.get(&storage, &"key1".to_string()).unwrap(); - let read_foo2 = keymap.get(&storage, &"key2".to_string()).unwrap(); + let read_foo1 = map.get(&storage, &"key1".to_string()).unwrap(); + let read_foo2 = map.get(&storage, &"key2".to_string()).unwrap(); - assert_eq!(original_keymap.get_len(&storage)?, 0); + assert_eq!(original_map.get_len(&storage)?, 0); assert_eq!(foo1, read_foo1); assert_eq!(foo2, read_foo2); - let alternative_keymap: Keymap = Keymap::new(b"alternative"); - let alt_same_suffix = alternative_keymap.add_suffix(b"test_suffix"); + let alternative_map: Map = Map::new(b"alternative"); + let alt_same_suffix = alternative_map.add_suffix(b"test_suffix"); assert!(alt_same_suffix.is_empty(&storage)?); // show that it loads foo1 before removal - let before_remove_foo1 = keymap.get(&storage, &"key1".to_string()); + let before_remove_foo1 = map.get(&storage, &"key1".to_string()); assert!(before_remove_foo1.is_some()); assert_eq!(foo1, before_remove_foo1.unwrap()); // and returns None after removal - keymap.remove(&mut storage, &"key1".to_string())?; - let removed_foo1 = keymap.get(&storage, &"key1".to_string()); + map.remove(&mut storage, &"key1".to_string())?; + let removed_foo1 = map.get(&storage, &"key1".to_string()); assert!(removed_foo1.is_none()); // show what happens when reading from keys that have not been set yet. - assert!(keymap.get(&storage, &"key3".to_string()).is_none()); + assert!(map.get(&storage, &"key3".to_string()).is_none()); Ok(()) } #[test] - fn test_keymap_length() -> StdResult<()> { - test_keymap_length_with_page_size(1)?; - test_keymap_length_with_page_size(5)?; - test_keymap_length_with_page_size(13)?; + fn test_map_length() -> StdResult<()> { + test_map_length_with_page_size(1)?; + test_map_length_with_page_size(5)?; + test_map_length_with_page_size(13)?; Ok(()) } - fn test_keymap_length_with_page_size(page_size: u32) -> StdResult<()> { + fn test_map_length_with_page_size(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap = KeymapBuilder::new(b"test") + let map: Map = MapBuilder::new(b"test") .with_page_size(page_size) .build(); let foo1 = Foo { @@ -1276,52 +1276,52 @@ mod tests { number: 1111, }; - assert!(keymap.length.lock().unwrap().eq(&None)); - assert_eq!(keymap.get_len(&storage)?, 0); - assert!(keymap.length.lock().unwrap().eq(&Some(0))); + assert!(map.length.lock().unwrap().eq(&None)); + assert_eq!(map.get_len(&storage)?, 0); + assert!(map.length.lock().unwrap().eq(&Some(0))); let key1 = "k1".to_string(); let key2 = "k2".to_string(); - keymap.insert(&mut storage, &key1, &foo1)?; - assert_eq!(keymap.get_len(&storage)?, 1); - assert!(keymap.length.lock().unwrap().eq(&Some(1))); + map.insert(&mut storage, &key1, &foo1)?; + assert_eq!(map.get_len(&storage)?, 1); + assert!(map.length.lock().unwrap().eq(&Some(1))); // add another item - keymap.insert(&mut storage, &key2, &foo2)?; - assert_eq!(keymap.get_len(&storage)?, 2); - assert!(keymap.length.lock().unwrap().eq(&Some(2))); + map.insert(&mut storage, &key2, &foo2)?; + assert_eq!(map.get_len(&storage)?, 2); + assert!(map.length.lock().unwrap().eq(&Some(2))); // remove item and check length - keymap.remove(&mut storage, &key1)?; - assert_eq!(keymap.get_len(&storage)?, 1); - assert!(keymap.length.lock().unwrap().eq(&Some(1))); + map.remove(&mut storage, &key1)?; + assert_eq!(map.get_len(&storage)?, 1); + assert!(map.length.lock().unwrap().eq(&Some(1))); // override item (should not change length) - keymap.insert(&mut storage, &key2, &foo1)?; - assert_eq!(keymap.get_len(&storage)?, 1); - assert!(keymap.length.lock().unwrap().eq(&Some(1))); + map.insert(&mut storage, &key2, &foo1)?; + assert_eq!(map.get_len(&storage)?, 1); + assert!(map.length.lock().unwrap().eq(&Some(1))); // remove item and check length - keymap.remove(&mut storage, &key2)?; - assert_eq!(keymap.get_len(&storage)?, 0); - assert!(keymap.length.lock().unwrap().eq(&Some(0))); + map.remove(&mut storage, &key2)?; + assert_eq!(map.get_len(&storage)?, 0); + assert!(map.length.lock().unwrap().eq(&Some(0))); Ok(()) } #[test] - fn test_keymap_without_iter() -> StdResult<()> { - test_keymap_without_iter_custom_page(1)?; - test_keymap_without_iter_custom_page(2)?; - test_keymap_without_iter_custom_page(3)?; + fn test_map_without_iter() -> StdResult<()> { + test_map_without_iter_custom_page(1)?; + test_map_without_iter_custom_page(2)?; + test_map_without_iter_custom_page(3)?; Ok(()) } - fn test_keymap_without_iter_custom_page(page_size: u32) -> StdResult<()> { + fn test_map_without_iter_custom_page(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap = KeymapBuilder::new(b"test") + let map: Map = MapBuilder::new(b"test") .with_page_size(page_size) .without_iter() .build(); @@ -1334,20 +1334,20 @@ mod tests { string: "string one".to_string(), number: 1111, }; - keymap.insert(&mut storage, &"key1".to_string(), &foo1)?; - keymap.insert(&mut storage, &"key2".to_string(), &foo2)?; + map.insert(&mut storage, &"key1".to_string(), &foo1)?; + map.insert(&mut storage, &"key2".to_string(), &foo2)?; - let read_foo1 = keymap.get(&storage, &"key1".to_string()).unwrap(); - let read_foo2 = keymap.get(&storage, &"key2".to_string()).unwrap(); + let read_foo1 = map.get(&storage, &"key1".to_string()).unwrap(); + let read_foo2 = map.get(&storage, &"key2".to_string()).unwrap(); assert_eq!(foo1, read_foo1); assert_eq!(foo2, read_foo2); - assert!(keymap.contains(&storage, &"key1".to_string())); + assert!(map.contains(&storage, &"key1".to_string())); - keymap.remove(&mut storage, &"key1".to_string())?; + map.remove(&mut storage, &"key1".to_string())?; - let read_foo1 = keymap.get(&storage, &"key1".to_string()); - let read_foo2 = keymap.get(&storage, &"key2".to_string()).unwrap(); + let read_foo1 = map.get(&storage, &"key1".to_string()); + let read_foo2 = map.get(&storage, &"key2".to_string()).unwrap(); assert!(read_foo1.is_none()); assert_eq!(foo2, read_foo2); @@ -1356,22 +1356,22 @@ mod tests { } #[test] - fn test_keymap_custom_paging() -> StdResult<()> { + fn test_map_custom_paging() -> StdResult<()> { let mut storage = MockStorage::new(); let page_size: u32 = 5; let total_items: u32 = 50; - let keymap: Keymap, u32> = KeymapBuilder::new(b"test").with_page_size(13).build(); + let map: Map, u32> = MapBuilder::new(b"test").with_page_size(13).build(); for i in 0..total_items { let key: Vec = (i as i32).to_be_bytes().to_vec(); - keymap.insert(&mut storage, &key, &i)?; + map.insert(&mut storage, &key, &i)?; } for i in 0..((total_items / page_size) - 1) { let start_page = i; - let values = keymap.paging(&storage, start_page, page_size)?; + let values = map.paging(&storage, start_page, page_size)?; for (index, (key_value, value)) in values.iter().enumerate() { let i = page_size * start_page + index as u32; @@ -1385,18 +1385,18 @@ mod tests { } #[test] - fn test_keymap_custom_paging_overflow() -> StdResult<()> { + fn test_map_custom_paging_overflow() -> StdResult<()> { let mut storage = MockStorage::new(); let page_size = 50; let total_items = 10; - let keymap: Keymap = KeymapBuilder::new(b"test").with_page_size(3).build(); + let map: Map = MapBuilder::new(b"test").with_page_size(3).build(); for i in 0..total_items { - keymap.insert(&mut storage, &(i as i32), &i)?; + map.insert(&mut storage, &(i as i32), &i)?; } - let values = keymap.paging_keys(&storage, 0, page_size)?; + let values = map.paging_keys(&storage, 0, page_size)?; assert_eq!(values.len(), total_items as usize); @@ -1408,10 +1408,10 @@ mod tests { } #[test] - fn test_keymap_custom_page_iter() -> StdResult<()> { + fn test_map_custom_page_iter() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = KeymapBuilder::new(b"test").with_page_size(2).build(); + let map: Map, Foo> = MapBuilder::new(b"test").with_page_size(2).build(); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1425,11 +1425,11 @@ mod tests { number: 1111, }; - keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?; - keymap.insert(&mut storage, &b"key2".to_vec(), &foo2)?; - keymap.insert(&mut storage, &b"key3".to_vec(), &foo3)?; + map.insert(&mut storage, &b"key1".to_vec(), &foo1)?; + map.insert(&mut storage, &b"key2".to_vec(), &foo2)?; + map.insert(&mut storage, &b"key3".to_vec(), &foo3)?; - let mut x = keymap.iter(&storage)?; + let mut x = map.iter(&storage)?; let (len, _) = x.size_hint(); assert_eq!(len, 3); @@ -1445,25 +1445,25 @@ mod tests { } #[test] - fn test_keymap_reverse_iter() -> StdResult<()> { - test_keymap_custom_page_reverse_iterator(1)?; - test_keymap_custom_page_reverse_iterator(2)?; - test_keymap_custom_page_reverse_iterator(5)?; - test_keymap_custom_page_reverse_iterator(25)?; + fn test_map_reverse_iter() -> StdResult<()> { + test_map_custom_page_reverse_iterator(1)?; + test_map_custom_page_reverse_iterator(2)?; + test_map_custom_page_reverse_iterator(5)?; + test_map_custom_page_reverse_iterator(25)?; Ok(()) } - fn test_keymap_custom_page_reverse_iterator(page_size: u32) -> StdResult<()> { + fn test_map_custom_page_reverse_iterator(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap = KeymapBuilder::new(b"test") + let map: Map = MapBuilder::new(b"test") .with_page_size(page_size) .build(); - keymap.insert(&mut storage, &1234, &1234)?; - keymap.insert(&mut storage, &2143, &2143)?; - keymap.insert(&mut storage, &3412, &3412)?; - keymap.insert(&mut storage, &4321, &4321)?; + map.insert(&mut storage, &1234, &1234)?; + map.insert(&mut storage, &2143, &2143)?; + map.insert(&mut storage, &3412, &3412)?; + map.insert(&mut storage, &4321, &4321)?; - let mut iter = keymap.iter(&storage)?.rev(); + let mut iter = map.iter(&storage)?.rev(); assert_eq!(iter.next(), Some(Ok((4321, 4321)))); assert_eq!(iter.next(), Some(Ok((3412, 3412)))); assert_eq!(iter.next(), Some(Ok((2143, 2143)))); @@ -1471,7 +1471,7 @@ mod tests { assert_eq!(iter.next(), None); // iterate twice to make sure nothing changed - let mut iter = keymap.iter(&storage)?.rev(); + let mut iter = map.iter(&storage)?.rev(); assert_eq!(iter.next(), Some(Ok((4321, 4321)))); assert_eq!(iter.next(), Some(Ok((3412, 3412)))); assert_eq!(iter.next(), Some(Ok((2143, 2143)))); @@ -1479,13 +1479,13 @@ mod tests { assert_eq!(iter.next(), None); // make sure our implementation of `nth_back` doesn't break anything - let mut iter = keymap.iter(&storage)?.rev().skip(2); + let mut iter = map.iter(&storage)?.rev().skip(2); assert_eq!(iter.next(), Some(Ok((2143, 2143)))); assert_eq!(iter.next(), Some(Ok((1234, 1234)))); assert_eq!(iter.next(), None); // make sure our implementation of `ExactSizeIterator` works well - let mut iter = keymap.iter(&storage)?.skip(2).rev(); + let mut iter = map.iter(&storage)?.skip(2).rev(); assert_eq!(iter.next(), Some(Ok((4321, 4321)))); assert_eq!(iter.next(), Some(Ok((3412, 3412)))); assert_eq!(iter.next(), None); @@ -1505,13 +1505,13 @@ mod tests { // Check the default behavior is Bincode2 let mut storage = MockStorage::new(); - let keymap: Keymap = KeymapBuilder::new(b"test") + let map: Map = MapBuilder::new(b"test") .with_page_size(page_size) .build(); - keymap.insert(&mut storage, &1234, &1234)?; + map.insert(&mut storage, &1234, &1234)?; - let page_key = [keymap.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat(); - if keymap.page_size == 1 { + let page_key = [map.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat(); + if map.page_size == 1 { let item_data = storage.get(&page_key); let expected_data = Bincode2::serialize(&1234)?; assert_eq!(item_data, Some(expected_data)); @@ -1523,13 +1523,13 @@ mod tests { // Check that overriding the serializer with Json works let mut storage = MockStorage::new(); - let json_keymap: Keymap = KeymapBuilder::new(b"test2") + let json_map: Map = MapBuilder::new(b"test2") .with_page_size(page_size) .build(); - json_keymap.insert(&mut storage, &1234, &1234)?; + json_map.insert(&mut storage, &1234, &1234)?; - let key = [json_keymap.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat(); - if json_keymap.page_size == 1 { + let key = [json_map.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat(); + if json_map.page_size == 1 { let item_data = storage.get(&key); let expected = b"1234".to_vec(); assert_eq!(item_data, Some(expected)); diff --git a/packages/storage/src/keyset.rs b/packages/storage/src/keyset.rs index 83b1cb0..c8b2c37 100644 --- a/packages/storage/src/keyset.rs +++ b/packages/storage/src/keyset.rs @@ -1024,15 +1024,15 @@ mod tests { fn test_keyset_custom_page_reverse_iterator(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keyset = KeysetBuilder::new(b"test") + let keyset: Keyset = KeysetBuilder::new(b"test") .with_page_size(page_size) .build(); - keymap.insert(&mut storage, &1234)?; - keymap.insert(&mut storage, &2143)?; - keymap.insert(&mut storage, &3412)?; - keymap.insert(&mut storage, &4321)?; + keyset.insert(&mut storage, &1234)?; + keyset.insert(&mut storage, &2143)?; + keyset.insert(&mut storage, &3412)?; + keyset.insert(&mut storage, &4321)?; - let mut iter = keymap.iter(&storage)?.rev(); + let mut iter = keyset.iter(&storage)?.rev(); assert_eq!(iter.next(), Some(Ok(4321))); assert_eq!(iter.next(), Some(Ok(3412))); assert_eq!(iter.next(), Some(Ok(2143))); @@ -1040,7 +1040,7 @@ mod tests { assert_eq!(iter.next(), None); // iterate twice to make sure nothing changed - let mut iter = keymap.iter(&storage)?.rev(); + let mut iter = keyset.iter(&storage)?.rev(); assert_eq!(iter.next(), Some(Ok(4321))); assert_eq!(iter.next(), Some(Ok(3412))); assert_eq!(iter.next(), Some(Ok(2143))); @@ -1048,13 +1048,13 @@ mod tests { assert_eq!(iter.next(), None); // make sure our implementation of `nth_back` doesn't break anything - let mut iter = keymap.iter(&storage)?.rev().skip(2); + let mut iter = keyset.iter(&storage)?.rev().skip(2); assert_eq!(iter.next(), Some(Ok(2143))); assert_eq!(iter.next(), Some(Ok(1234))); assert_eq!(iter.next(), None); // make sure our implementation of `ExactSizeIterator` works well - let mut iter = keymap.iter(&storage)?.skip(2).rev(); + let mut iter = keyset.iter(&storage)?.skip(2).rev(); assert_eq!(iter.next(), Some(Ok(4321))); assert_eq!(iter.next(), Some(Ok(3412))); assert_eq!(iter.next(), None); diff --git a/packages/storage/src/lib.rs b/packages/storage/src/lib.rs index c6b0f14..5e4c11a 100644 --- a/packages/storage/src/lib.rs +++ b/packages/storage/src/lib.rs @@ -11,7 +11,7 @@ pub use deque_store::DequeStore; pub use item::Item; pub use iter_options::WithoutIter; use iter_options::{IterOption, WithIter}; -pub use keymap::{Keymap, KeymapBuilder}; +pub use keymap::{Map, MapBuilder}; pub use keyset::{Keyset, KeysetBuilder}; pub mod iter_options { From 0f0088c87344bfd16c9311763e324b57589a6e0f Mon Sep 17 00:00:00 2001 From: Eshel Date: Tue, 7 Feb 2023 17:08:57 +0200 Subject: [PATCH 2/5] renamed keymap.rs to map.rs --- packages/storage/Readme.md | 2 +- packages/storage/src/lib.rs | 4 ++-- packages/storage/src/{keymap.rs => map.rs} | 0 3 files changed, 3 insertions(+), 3 deletions(-) rename packages/storage/src/{keymap.rs => map.rs} (100%) diff --git a/packages/storage/Readme.md b/packages/storage/Readme.md index a3c68da..6b1d74c 100644 --- a/packages/storage/Readme.md +++ b/packages/storage/Readme.md @@ -335,7 +335,7 @@ pub static JSON_VOTE: Map = #### **Read/Write** -You can find more examples of using maps in the unit tests of Map in `keymap.rs`. +You can find more examples of using maps in the unit tests of Map in `map.rs`. To insert, remove, read from the map, do the following: diff --git a/packages/storage/src/lib.rs b/packages/storage/src/lib.rs index 5e4c11a..a657311 100644 --- a/packages/storage/src/lib.rs +++ b/packages/storage/src/lib.rs @@ -3,7 +3,7 @@ pub mod append_store; pub mod deque_store; pub mod item; -pub mod keymap; +pub mod map; pub mod keyset; pub use append_store::AppendStore; @@ -11,7 +11,7 @@ pub use deque_store::DequeStore; pub use item::Item; pub use iter_options::WithoutIter; use iter_options::{IterOption, WithIter}; -pub use keymap::{Map, MapBuilder}; +pub use map::{Map, MapBuilder}; pub use keyset::{Keyset, KeysetBuilder}; pub mod iter_options { diff --git a/packages/storage/src/keymap.rs b/packages/storage/src/map.rs similarity index 100% rename from packages/storage/src/keymap.rs rename to packages/storage/src/map.rs From c690998385adad72e5ec1d0179188b02e7b2acaa Mon Sep 17 00:00:00 2001 From: Eshel Date: Sun, 12 Feb 2023 23:26:49 +0200 Subject: [PATCH 3/5] renamed DequeStore to Deque --- packages/storage/src/deque_store.rs | 50 ++++++++++++++--------------- packages/storage/src/lib.rs | 2 +- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/packages/storage/src/deque_store.rs b/packages/storage/src/deque_store.rs index 8db35ac..90feec7 100644 --- a/packages/storage/src/deque_store.rs +++ b/packages/storage/src/deque_store.rs @@ -1,4 +1,4 @@ -//! This is a storage wrapper based on AppendStore called DequeStore. +//! This is a storage wrapper based on AppendStore called Deque. //! It guarantees constant-cost appending to and popping from a list of items in storage on both directions (front and back). //! //! This is achieved by storing each item in a separate storage entry. @@ -22,7 +22,7 @@ const OFFSET_KEY: &[u8] = b"off"; const DEFAULT_PAGE_SIZE: u32 = 1; -pub struct DequeStore<'a, T, Ser = Bincode2> +pub struct Deque<'a, T, Ser = Bincode2> where T: Serialize + DeserializeOwned, Ser: Serde, @@ -38,7 +38,7 @@ where serialization_type: PhantomData, } -impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> DequeStore<'a, T, Ser> { +impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> Deque<'a, T, Ser> { /// constructor pub const fn new(prefix: &'a [u8]) -> Self { Self { @@ -68,8 +68,8 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> DequeStore<'a, T, Ser> { } } - /// This is used to produce a new DequeStorage. This can be used when you want to associate an AppendListStorage to each user - /// and you still get to define the DequeStorage as a static constant + /// This is used to produce a new Deque. This can be used when you want to associate an AppendListStorage to each user + /// and you still get to define the Dequeas a static constant pub fn add_suffix(&self, suffix: &[u8]) -> Self { let suffix = to_length_prefixed(suffix); let prefix = self.prefix.as_deref().unwrap_or(self.namespace); @@ -86,7 +86,7 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> DequeStore<'a, T, Ser> { } } -impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> DequeStore<'a, T, Ser> { +impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> Deque<'a, T, Ser> { fn as_slice(&self) -> &[u8] { if let Some(prefix) = &self.prefix { prefix @@ -391,9 +391,9 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> DequeStore<'a, T, Ser> { } /// Returns a readonly iterator - pub fn iter(&self, storage: &'a dyn Storage) -> StdResult> { + pub fn iter(&self, storage: &'a dyn Storage) -> StdResult> { let len = self.get_len(storage)?; - let iter = DequeStoreIter::new(self, storage, 0, len); + let iter = DequeIter::new(self, storage, 0, len); Ok(iter) } @@ -407,26 +407,26 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> DequeStore<'a, T, Ser> { } /// An iterator over the contents of the deque store. -pub struct DequeStoreIter<'a, T, Ser> +pub struct DequeIter<'a, T, Ser> where T: Serialize + DeserializeOwned, Ser: Serde, { - deque_store: &'a DequeStore<'a, T, Ser>, + deque_store: &'a Deque<'a, T, Ser>, storage: &'a dyn Storage, start: u32, end: u32, cache: HashMap>>, } -impl<'a, T, Ser> DequeStoreIter<'a, T, Ser> +impl<'a, T, Ser> DequeIter<'a, T, Ser> where T: Serialize + DeserializeOwned, Ser: Serde, { /// constructor pub fn new( - deque_store: &'a DequeStore<'a, T, Ser>, + deque_store: &'a Deque<'a, T, Ser>, storage: &'a dyn Storage, start: u32, end: u32, @@ -441,7 +441,7 @@ where } } -impl<'a, T, Ser> Iterator for DequeStoreIter<'a, T, Ser> +impl<'a, T, Ser> Iterator for DequeIter<'a, T, Ser> where T: Serialize + DeserializeOwned, Ser: Serde, @@ -506,7 +506,7 @@ where } } -impl<'a, T, Ser> DoubleEndedIterator for DequeStoreIter<'a, T, Ser> +impl<'a, T, Ser> DoubleEndedIterator for DequeIter<'a, T, Ser> where T: Serialize + DeserializeOwned, Ser: Serde, @@ -564,7 +564,7 @@ where } // This enables writing `deque_store.iter().skip(n).rev()` -impl<'a, T, Ser> ExactSizeIterator for DequeStoreIter<'a, T, Ser> +impl<'a, T, Ser> ExactSizeIterator for DequeIter<'a, T, Ser> where T: Serialize + DeserializeOwned, Ser: Serde, @@ -590,7 +590,7 @@ mod tests { fn test_pushs_pops_with_size(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new_with_page_size(b"test", page_size); + let deque_store: Deque = Deque::new_with_page_size(b"test", page_size); deque_store.push_front(&mut storage, &4)?; deque_store.push_back(&mut storage, &5)?; deque_store.push_front(&mut storage, &3)?; @@ -626,7 +626,7 @@ mod tests { #[test] fn test_remove() -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new(b"test"); + let deque_store: Deque = Deque::new(b"test"); deque_store.push_front(&mut storage, &2143)?; deque_store.push_back(&mut storage, &3412)?; deque_store.push_back(&mut storage, &3333)?; @@ -649,7 +649,7 @@ mod tests { fn test_removes_with_page_size(size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new_with_page_size(b"test", size); + let deque_store: Deque = Deque::new_with_page_size(b"test", size); deque_store.push_front(&mut storage, &2)?; deque_store.push_back(&mut storage, &3)?; deque_store.push_back(&mut storage, &4)?; @@ -723,7 +723,7 @@ mod tests { fn test_overwrite_with_page_size(size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new_with_page_size(b"test", size); + let deque_store: Deque = Deque::new_with_page_size(b"test", size); deque_store.push_front(&mut storage, &2)?; deque_store.push_back(&mut storage, &3)?; deque_store.push_back(&mut storage, &4)?; @@ -820,7 +820,7 @@ mod tests { #[test] fn test_iterator() -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new(b"test"); + let deque_store: Deque = Deque::new(b"test"); deque_store.push_front(&mut storage, &2143)?; deque_store.push_back(&mut storage, &3333)?; @@ -866,7 +866,7 @@ mod tests { fn test_reverse_iterator_with_size(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new_with_page_size(b"test", page_size); + let deque_store: Deque = Deque::new_with_page_size(b"test", page_size); deque_store.push_front(&mut storage, &2143)?; deque_store.push_back(&mut storage, &3412)?; deque_store.push_back(&mut storage, &3333)?; @@ -917,7 +917,7 @@ mod tests { // Check the default behavior is Bincode2 let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new_with_page_size(b"test", page_size); + let deque_store: Deque = Deque::new_with_page_size("test", page_size); deque_store.push_back(&mut storage, &1234)?; let key = [deque_store.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat(); @@ -933,8 +933,8 @@ mod tests { // Check that overriding the serializer with Json works let mut storage = MockStorage::new(); - let json_deque_store: DequeStore = - DequeStore::new_with_page_size(b"test2", page_size); + let json_deque_store: Deque = + Deque::new_with_page_size(b"test2", page_size); json_deque_store.push_back(&mut storage, &1234)?; let key = [json_deque_store.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat(); @@ -955,7 +955,7 @@ mod tests { #[test] fn test_paging() -> StdResult<()> { let mut storage = MockStorage::new(); - let append_store: DequeStore = DequeStore::new(b"test"); + let append_store: Deque = Deque::new(b"test"); let page_size: u32 = 5; let total_items: u32 = 50; diff --git a/packages/storage/src/lib.rs b/packages/storage/src/lib.rs index a657311..027a294 100644 --- a/packages/storage/src/lib.rs +++ b/packages/storage/src/lib.rs @@ -7,7 +7,7 @@ pub mod map; pub mod keyset; pub use append_store::AppendStore; -pub use deque_store::DequeStore; +pub use deque_store::Deque; pub use item::Item; pub use iter_options::WithoutIter; use iter_options::{IterOption, WithIter}; From fa45817d511f1cc404f8253eee85d50925937bd5 Mon Sep 17 00:00:00 2001 From: Eshel Date: Sun, 12 Feb 2023 23:28:14 +0200 Subject: [PATCH 4/5] renamed deque_store.rs to deque.rs --- packages/storage/src/{deque_store.rs => deque.rs} | 0 packages/storage/src/lib.rs | 4 ++-- 2 files changed, 2 insertions(+), 2 deletions(-) rename packages/storage/src/{deque_store.rs => deque.rs} (100%) diff --git a/packages/storage/src/deque_store.rs b/packages/storage/src/deque.rs similarity index 100% rename from packages/storage/src/deque_store.rs rename to packages/storage/src/deque.rs diff --git a/packages/storage/src/lib.rs b/packages/storage/src/lib.rs index 027a294..ecd076d 100644 --- a/packages/storage/src/lib.rs +++ b/packages/storage/src/lib.rs @@ -1,13 +1,13 @@ #![doc = include_str!("../Readme.md")] pub mod append_store; -pub mod deque_store; +pub mod deque; pub mod item; pub mod map; pub mod keyset; pub use append_store::AppendStore; -pub use deque_store::Deque; +pub use deque::Deque; pub use item::Item; pub use iter_options::WithoutIter; use iter_options::{IterOption, WithIter}; From dd025fee2a9649d397e724b7cd0d4423dc71f247 Mon Sep 17 00:00:00 2001 From: Eshel Date: Mon, 13 Feb 2023 19:19:56 +0200 Subject: [PATCH 5/5] last fixes --- packages/storage/Readme.md | 10 +++++----- packages/storage/src/deque.rs | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/packages/storage/Readme.md b/packages/storage/Readme.md index 6b1d74c..5776b07 100644 --- a/packages/storage/Readme.md +++ b/packages/storage/Readme.md @@ -215,7 +215,7 @@ let values = COUNT_STORE.paging(&deps.storage, start_page, page_size)?; # Ok::<(), StdError>(()) ``` -### **DequeStore** +### **Deque** 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. @@ -224,12 +224,12 @@ This is a storage wrapper based on AppendStore that replicates a double ended li To import and initialize this storage object as a static constant in `state.rs`, do the following: ```ignore -use secret_toolkit::storage::{DequeStore}; +use secret_toolkit::storage::{Deque}; ``` ```rust -# use secret_toolkit_storage::DequeStore; -pub static COUNT_STORE: DequeStore = DequeStore::new(b"count"); +# use secret_toolkit_storage::Deque; +pub static COUNT_STORE: Deque = Deque::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. @@ -238,7 +238,7 @@ pub static COUNT_STORE: DequeStore = DequeStore::new(b"count"); #### **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`. +The main user facing methods to read/write to Deque 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 Deque found in `deque_store.rs`. #### **Iterator** diff --git a/packages/storage/src/deque.rs b/packages/storage/src/deque.rs index 90feec7..594ad6d 100644 --- a/packages/storage/src/deque.rs +++ b/packages/storage/src/deque.rs @@ -917,7 +917,7 @@ mod tests { // Check the default behavior is Bincode2 let mut storage = MockStorage::new(); - let deque_store: Deque = Deque::new_with_page_size("test", page_size); + let deque_store: Deque = Deque::new_with_page_size(b"test", page_size); deque_store.push_back(&mut storage, &1234)?; let key = [deque_store.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat();