Remove linked_map part 1

frame/example/src/lib.rs

@@ -353,7 +353,7 @@ decl_storage! {
 		Dummy get(fn dummy) config(): Option<T::Balance>;
 
 		// A map that has enumerable entries.
-		Bar get(fn bar) config(): linked_map hasher(blake2_128_concat) T::AccountId => T::Balance;
+		Bar get(fn bar) config(): map hasher(blake2_128_concat) T::AccountId => T::Balance;
 
 		// this one uses the default, we'll demonstrate the usage of 'mutate' API.
 		Foo get(fn foo) config(): T::Balance;

frame/support/procedural/src/lib.rs

@@ -36,7 +36,7 @@ use proc_macro::TokenStream;
 /// 	trait Store for Module<T: Trait> as Example {
 /// 		Foo get(fn foo) config(): u32=12;
 /// 		Bar: map hasher(identity) u32 => u32;
-/// 		pub Zed build(|config| vec![(0, 0)]): linked_map hasher(identity) u32 => u32;
+/// 		pub Zed build(|config| vec![(0, 0)]): map hasher(identity) u32 => u32;
 /// 	}
 /// }
 /// ```
@@ -105,36 +105,6 @@ use proc_macro::TokenStream;
 ///   twox128(module_prefix) ++ twox128(storage_prefix) ++ hasher(encode(key))
 ///   ```
 ///
-/// * Linked map: `Foo: linked_map hasher($hash) type => type`: Implements the
-///   [`StorageLinkedMap`](../frame_support/storage/trait.StorageLinkedMap.html) trait using the
-///   [`StorageLinkedMap generator`](../frame_support/storage/generator/trait.StorageLinkedMap.html).
-///   And [`StoragePrefixedMap`](../frame_support/storage/trait.StoragePrefixedMap.html).
-///
-///   `$hash` representing a choice of hashing algorithms available in the
-///   [`Hashable`](../frame_support/trait.Hashable.html) trait.
-///
-///   `blake2_256` and `blake2_128_concat` are strong hasher. One should use another hasher
-///   with care, see generator documentation.
-///
-///   All key formatting logic can be accessed in a type-agnostic format via the
-///   `KeyFormat` trait, which
-///   is implemented for the storage linked map type as well.
-///
-///   The generator key format is implemented with:
-///   * `module_prefix`: $module_prefix
-///   * `storage_prefix`: storage_name
-///   * `head_prefix`: `"HeadOf" ++ storage_name`
-///   * `Hasher`: $hash
-///
-///   Thus the keys are stored at:
-///   ```nocompile
-///   Twox128(module_prefix) ++ Twox128(storage_prefix) ++ Hasher(encode(key))
-///   ```
-///   and head is stored at:
-///   ```nocompile
-///   Twox128(module_prefix) ++ Twox128(head_prefix)
-///   ```
-///
 /// * Double map: `Foo: double_map hasher($hash1) u32, hasher($hash2) u32 => u32`: Implements the
 ///   [`StorageDoubleMap`](../frame_support/storage/trait.StorageDoubleMap.html) trait using the
 ///   [`StorageDoubleMap generator`](../frame_support/storage/generator/trait.StorageDoubleMap.html).

frame/support/src/lib.rs

@@ -254,12 +254,12 @@ mod tests {
 	decl_storage! {
 		trait Store for Module<T: Trait> as Example {
 			pub Data get(fn data) build(|_| vec![(15u32, 42u64)]):
-				linked_map hasher(twox_64_concat) u32 => u64;
-			pub OptionLinkedMap: linked_map hasher(blake2_128_concat) u32 => Option<u32>;
+				map hasher(twox_64_concat) u32 => u64;
+			pub OptionLinkedMap: map hasher(blake2_128_concat) u32 => Option<u32>;
 			pub GenericData get(fn generic_data):
-				linked_map hasher(identity) T::BlockNumber => T::BlockNumber;
+				map hasher(identity) T::BlockNumber => T::BlockNumber;
 			pub GenericData2 get(fn generic_data2):
-				linked_map hasher(blake2_128_concat) T::BlockNumber => Option<T::BlockNumber>;
+				map hasher(blake2_128_concat) T::BlockNumber => Option<T::BlockNumber>;
 			pub GetterNoFnKeyword get(no_fn): Option<u32>;
 
 			pub DataDM config(test_config) build(|_| vec![(15u32, 16u32, 42u64)]):
@@ -287,8 +287,16 @@ mod tests {
 
 	type Map = Data;
 
+	trait Sorted { fn sorted(self) -> Self; }
+	impl<T: Ord> Sorted for Vec<T> {
+		fn sorted(mut self) -> Self {
+			self.sort();
+			self
+		}
+	}
+
 	#[test]
-	fn linked_map_issue_3318() {
+	fn map_issue_3318() {
 		new_test_ext().execute_with(|| {
 			OptionLinkedMap::insert(1, 1);
 			assert_eq!(OptionLinkedMap::get(1), Some(1));
@@ -298,31 +306,31 @@ mod tests {
 	}
 
 	#[test]
-	fn linked_map_swap_works() {
+	fn map_swap_works() {
 		new_test_ext().execute_with(|| {
 			OptionLinkedMap::insert(0, 0);
 			OptionLinkedMap::insert(1, 1);
 			OptionLinkedMap::insert(2, 2);
 			OptionLinkedMap::insert(3, 3);
 
-			let collect = || OptionLinkedMap::enumerate().collect::<Vec<_>>();
-			assert_eq!(collect(), vec![(3, 3), (2, 2), (1, 1), (0, 0)]);
+			let collect = || OptionLinkedMap::iter().collect::<Vec<_>>().sorted();
+			assert_eq!(collect(), vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
 
 			// Two existing
 			OptionLinkedMap::swap(1, 2);
-			assert_eq!(collect(), vec![(3, 3), (2, 1), (1, 2), (0, 0)]);
+			assert_eq!(collect(), vec![(0, 0), (1, 2), (2, 1), (3, 3)]);
 
 			// Back to normal
 			OptionLinkedMap::swap(2, 1);
-			assert_eq!(collect(), vec![(3, 3), (2, 2), (1, 1), (0, 0)]);
+			assert_eq!(collect(), vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
 
 			// Left existing
 			OptionLinkedMap::swap(2, 5);
-			assert_eq!(collect(), vec![(5, 2), (3, 3), (1, 1), (0, 0)]);
+			assert_eq!(collect(), vec![(0, 0), (1, 1), (3, 3), (5, 2)]);
 
 			// Right existing
 			OptionLinkedMap::swap(5, 2);
-			assert_eq!(collect(), vec![(2, 2), (3, 3), (1, 1), (0, 0)]);
+			assert_eq!(collect(), vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
 		});
 	}
 
@@ -357,7 +365,7 @@ mod tests {
 	}
 
 	#[test]
-	fn linked_map_basic_insert_remove_should_work() {
+	fn map_basic_insert_remove_should_work() {
 		new_test_ext().execute_with(|| {
 			// initialized during genesis
 			assert_eq!(Map::get(&15u32), 42u64);
@@ -383,54 +391,45 @@ mod tests {
 	}
 
 	#[test]
-	fn linked_map_enumeration_and_head_should_work() {
+	fn map_iteration_should_work() {
 		new_test_ext().execute_with(|| {
-			assert_eq!(Map::head(), Some(15));
-			assert_eq!(Map::enumerate().collect::<Vec<_>>(), vec![(15, 42)]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(15, 42)]);
 			// insert / remove
 			let key = 17u32;
 			Map::insert(key, 4u64);
-			assert_eq!(Map::head(), Some(key));
-			assert_eq!(Map::enumerate().collect::<Vec<_>>(), vec![(key, 4), (15, 42)]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(15, 42), (key, 4)]);
 			assert_eq!(Map::take(&15), 42u64);
 			assert_eq!(Map::take(&key), 4u64);
-			assert_eq!(Map::head(), None);
-			assert_eq!(Map::enumerate().collect::<Vec<_>>(), vec![]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![]);
 
 			// Add couple of more elements
 			Map::insert(key, 42u64);
-			assert_eq!(Map::head(), Some(key));
-			assert_eq!(Map::enumerate().collect::<Vec<_>>(), vec![(key, 42)]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key, 42)]);
 			Map::insert(key + 1, 43u64);
-			assert_eq!(Map::head(), Some(key + 1));
-			assert_eq!(Map::enumerate().collect::<Vec<_>>(), vec![(key + 1, 43), (key, 42)]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key, 42), (key + 1, 43)]);
 
 			// mutate
 			let key = key + 2;
 			Map::mutate(&key, |val| {
 				*val = 15;
 			});
-			assert_eq!(Map::enumerate().collect::<Vec<_>>(), vec![(key, 15), (key - 1, 43), (key - 2, 42)]);
-			assert_eq!(Map::head(), Some(key));
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key - 2, 42), (key - 1, 43), (key, 15)]);
 			Map::mutate(&key, |val| {
 				*val = 17;
 			});
-			assert_eq!(Map::enumerate().collect::<Vec<_>>(), vec![(key, 17), (key - 1, 43), (key - 2, 42)]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key - 2, 42), (key - 1, 43), (key, 17)]);
 
 			// remove first
 			Map::remove(&key);
-			assert_eq!(Map::head(), Some(key - 1));
-			assert_eq!(Map::enumerate().collect::<Vec<_>>(), vec![(key - 1, 43), (key - 2, 42)]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key - 2, 42), (key - 1, 43)]);
 
 			// remove last from the list
 			Map::remove(&(key - 2));
-			assert_eq!(Map::head(), Some(key - 1));
-			assert_eq!(Map::enumerate().collect::<Vec<_>>(), vec![(key - 1, 43)]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key - 1, 43)]);
 
 			// remove the last element
 			Map::remove(&(key - 1));
-			assert_eq!(Map::head(), None);
-			assert_eq!(Map::enumerate().collect::<Vec<_>>(), vec![]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![]);
 		});
 	}
 
@@ -499,7 +498,7 @@ mod tests {
 						hasher: StorageHasher::Twox64Concat,
 						key: DecodeDifferent::Encode("u32"),
 						value: DecodeDifferent::Encode("u64"),
-						is_linked: true,
+						is_linked: false,
 					},
 					default: DecodeDifferent::Encode(
 						DefaultByteGetter(&__GetByteStructData(PhantomData::<Test>))
@@ -513,7 +512,7 @@ mod tests {
 						hasher: StorageHasher::Blake2_128Concat,
 						key: DecodeDifferent::Encode("u32"),
 						value: DecodeDifferent::Encode("u32"),
-						is_linked: true,
+						is_linked: false,
 					},
 					default: DecodeDifferent::Encode(
 						DefaultByteGetter(&__GetByteStructOptionLinkedMap(PhantomData::<Test>))
@@ -527,7 +526,7 @@ mod tests {
 						hasher: StorageHasher::Identity,
 						key: DecodeDifferent::Encode("T::BlockNumber"),
 						value: DecodeDifferent::Encode("T::BlockNumber"),
-						is_linked: true
+						is_linked: false
 					},
 					default: DecodeDifferent::Encode(
 						DefaultByteGetter(&__GetByteStructGenericData(PhantomData::<Test>))
@@ -541,7 +540,7 @@ mod tests {
 						hasher: StorageHasher::Blake2_128Concat,
 						key: DecodeDifferent::Encode("T::BlockNumber"),
 						value: DecodeDifferent::Encode("T::BlockNumber"),
-						is_linked: true
+						is_linked: false
 					},
 					default: DecodeDifferent::Encode(
 						DefaultByteGetter(&__GetByteStructGenericData2(PhantomData::<Test>))