remove useless function

frame/support/src/hash.rs

@@ -64,11 +64,6 @@ pub trait ReversibleStorageHasher: StorageHasher {
 	fn reverse(x: &[u8]) -> &[u8];
 }
 
-/// Hasher with a fixed length.
-pub trait FixedLengthHasher: StorageHasher {
-	const LENGTH: u32;
-}
-
 /// Store the key directly.
 pub struct Identity;
 impl StorageHasher for Identity {
@@ -136,10 +131,6 @@ impl StorageHasher for Blake2_128 {
 	}
 }
 
-impl FixedLengthHasher for Blake2_128 {
-	const LENGTH: u32 = 16;
-}
-
 /// Hash storage keys with blake2 256
 pub struct Blake2_256;
 impl StorageHasher for Blake2_256 {
@@ -149,10 +140,6 @@ impl StorageHasher for Blake2_256 {
 	}
 }
 
-impl FixedLengthHasher for Blake2_256 {
-	const LENGTH: u32 = 32;
-}
-
 /// Hash storage keys with twox 128
 pub struct Twox128;
 impl StorageHasher for Twox128 {
@@ -162,10 +149,6 @@ impl StorageHasher for Twox128 {
 	}
 }
 
-impl FixedLengthHasher for Twox128 {
-	const LENGTH: u32 = 16;
-}
-
 /// Hash storage keys with twox 256
 pub struct Twox256;
 impl StorageHasher for Twox256 {
@@ -175,10 +158,6 @@ impl StorageHasher for Twox256 {
 	}
 }
 
-impl FixedLengthHasher for Twox256 {
-	const LENGTH: u32 = 32;
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;

frame/support/src/lib.rs

@@ -310,7 +310,7 @@ mod tests {
 			OptionLinkedMap::insert(2, 2);
 			OptionLinkedMap::insert(3, 3);
 
-			let collect = || OptionLinkedMap::iter_key_value().collect::<Vec<_>>().sorted();
+			let collect = || OptionLinkedMap::iter().collect::<Vec<_>>().sorted();
 			assert_eq!(collect(), vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
 
 			// Two existing
@@ -390,43 +390,43 @@ mod tests {
 	#[test]
 	fn map_iteration_should_work() {
 		new_test_ext().execute_with(|| {
-			assert_eq!(Map::iter_key_value().collect::<Vec<_>>().sorted(), 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::iter_key_value().collect::<Vec<_>>().sorted(), vec![(15, 42), (key, 4)]);
+			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::iter_key_value().collect::<Vec<_>>().sorted(), vec![]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![]);
 
 			// Add couple of more elements
 			Map::insert(key, 42u64);
-			assert_eq!(Map::iter_key_value().collect::<Vec<_>>().sorted(), vec![(key, 42)]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key, 42)]);
 			Map::insert(key + 1, 43u64);
-			assert_eq!(Map::iter_key_value().collect::<Vec<_>>().sorted(), vec![(key, 42), (key + 1, 43)]);
+			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::iter_key_value().collect::<Vec<_>>().sorted(), vec![(key - 2, 42), (key - 1, 43), (key, 15)]);
+			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::iter_key_value().collect::<Vec<_>>().sorted(), vec![(key - 2, 42), (key - 1, 43), (key, 17)]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key - 2, 42), (key - 1, 43), (key, 17)]);
 
 			// remove first
 			Map::remove(&key);
-			assert_eq!(Map::iter_key_value().collect::<Vec<_>>().sorted(), vec![(key - 2, 42), (key - 1, 43)]);
+			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::iter_key_value().collect::<Vec<_>>().sorted(), 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::iter_key_value().collect::<Vec<_>>().sorted(), vec![]);
+			assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![]);
 		});
 	}
 

frame/support/src/storage/generator/double_map.rs

@@ -18,7 +18,7 @@ use sp_std::prelude::*;
 use sp_std::borrow::Borrow;
 use codec::{Ref, FullCodec, Decode, Encode, EncodeLike, EncodeAppend};
 use crate::{storage::{self, unhashed}, traits::Len};
-use crate::hash::{StorageHasher, Twox128, ReversibleStorageHasher, FixedLengthHasher};
+use crate::hash::{StorageHasher, Twox128, ReversibleStorageHasher};
 
 /// Generator for `StorageDoubleMap` used by `decl_storage`.
 ///
@@ -214,18 +214,6 @@ impl<K1, K2, V, G> storage::StorageDoubleMap<K1, K2, V> for G where
 		sp_io::storage::clear_prefix(&Self::prefix_hash())
 	}
 
-	fn iter_prefix_value<KArg1>(k1: KArg1) -> storage::PrefixIterator<V> where
-		KArg1: ?Sized + EncodeLike<K1>
-	{
-		let prefix = Self::storage_double_map_final_key1(k1);
-		storage::PrefixIterator {
-			prefix: prefix.clone(),
-			previous_key: prefix,
-			drain: false,
-			closure: |_raw_key, mut raw_value| V::decode(&mut raw_value),
-		}
-	}
-
 	fn mutate<KArg1, KArg2, R, F>(k1: KArg1, k2: KArg2, f: F) -> R where
 		KArg1: EncodeLike<K1>,
 		KArg2: EncodeLike<K2>,
@@ -340,7 +328,7 @@ impl<K1, K2, V, G> storage::StorageDoubleMap<K1, K2, V> for G where
 		})
 	}
 
-	fn iter_prefix_key2_value(k1: impl EncodeLike<K1>) -> storage::PrefixIterator<(K2, V)> where
+	fn iter_prefix(k1: impl EncodeLike<K1>) -> storage::PrefixIterator<(K2, V)> where
 		Self::Hasher2: ReversibleStorageHasher
 	{
 		let prefix = G::storage_double_map_final_key1(k1);
@@ -352,7 +340,7 @@ impl<K1, K2, V, G> storage::StorageDoubleMap<K1, K2, V> for G where
 		}
 	}
 
-	fn drain_prefix_key2_value(k1: impl EncodeLike<K1>) -> storage::PrefixIterator<(K2, V)> where
+	fn drain_prefix(k1: impl EncodeLike<K1>) -> storage::PrefixIterator<(K2, V)> where
 		Self::Hasher2: ReversibleStorageHasher
 	{
 		let prefix = G::storage_double_map_final_key1(k1);
@@ -364,48 +352,19 @@ impl<K1, K2, V, G> storage::StorageDoubleMap<K1, K2, V> for G where
 		}
 	}
 
-	fn iter_key1_value() -> storage::PrefixIterator<(K1, V)> where
-		Self::Hasher1: ReversibleStorageHasher,
-	{
-		let prefix = G::prefix_hash();
-		storage::PrefixIterator {
-			prefix: prefix.clone(),
-			previous_key: prefix,
-			drain: false,
-			closure: |raw_key_without_prefix, mut raw_value| {
-				let mut key1_material = G::Hasher1::reverse(raw_key_without_prefix);
-				let key1 = K1::decode(&mut key1_material)?;
-				let value = V::decode(&mut raw_value)?;
-
-				Ok((key1, value))
-			}
-		}
-	}
-
-	fn iter_key2_value() -> storage::PrefixIterator<(K2, V)> where
-		Self::Hasher2: ReversibleStorageHasher,
-		Self::Hasher1: FixedLengthHasher,
+	fn iter_prefix_values<KArg1>(k1: KArg1) -> storage::PrefixIterator<V> where
+		KArg1: ?Sized + EncodeLike<K1>
 	{
-		let prefix = G::prefix_hash();
+		let prefix = Self::storage_double_map_final_key1(k1);
 		storage::PrefixIterator {
 			prefix: prefix.clone(),
 			previous_key: prefix,
 			drain: false,
-			closure: |raw_key_without_prefix, mut raw_value| {
-				let hasher1_len = G::Hasher1::LENGTH as usize;
-				if raw_key_without_prefix.len() < hasher1_len {
-					return Err("Invalid storage: invalid key length".into())
-				}
-				let mut key2_material = G::Hasher2::reverse(&mut &raw_key_without_prefix[hasher1_len..]);
-				let key2 = K2::decode(&mut key2_material)?;
-				let value = V::decode(&mut raw_value)?;
-
-				Ok((key2, value))
-			}
+			closure: |_raw_key, mut raw_value| V::decode(&mut raw_value),
 		}
 	}
 
-	fn iter_key1_key2_value() -> storage::PrefixIterator<(K1, K2, V)> where
+	fn iter() -> storage::PrefixIterator<(K1, K2, V)> where
 		Self::Hasher1: ReversibleStorageHasher,
 		Self::Hasher2: ReversibleStorageHasher,
 	{
@@ -426,7 +385,7 @@ impl<K1, K2, V, G> storage::StorageDoubleMap<K1, K2, V> for G where
 		}
 	}
 
-	fn iter_value() -> storage::PrefixIterator<V> {
+	fn iter_values() -> storage::PrefixIterator<V> {
 		let prefix = G::prefix_hash();
 		storage::PrefixIterator {
 			prefix: prefix.clone(),
@@ -506,8 +465,8 @@ mod test {
 			MyStorage::insert(2, 5, 9);
 			MyStorage::insert(2, 6, 10);
 
-			assert_eq!(MyStorage::iter_prefix_value(1).collect::<Vec<_>>(), vec![7, 8]);
-			assert_eq!(MyStorage::iter_prefix_value(2).collect::<Vec<_>>(), vec![10, 9]);
+			assert_eq!(MyStorage::iter_prefix_values(1).collect::<Vec<_>>(), vec![7, 8]);
+			assert_eq!(MyStorage::iter_prefix_values(2).collect::<Vec<_>>(), vec![10, 9]);
 		});
 	}
 }

frame/support/src/storage/generator/map.rs

@@ -268,7 +268,7 @@ impl<K: FullCodec, V: FullCodec, G: StorageMap<K, V>> storage::StorageMap<K, V>
 		})
 	}
 
-	fn iter_key_value() -> storage::PrefixIterator<(K, V)> where
+	fn iter() -> storage::PrefixIterator<(K, V)> where
 		Self::Hasher: ReversibleStorageHasher
 	{
 		let prefix = G::prefix_hash();
@@ -280,7 +280,7 @@ impl<K: FullCodec, V: FullCodec, G: StorageMap<K, V>> storage::StorageMap<K, V>
 		}
 	}
 
-	fn drain_key_value() -> storage::PrefixIterator<(K, V)> where
+	fn drain() -> storage::PrefixIterator<(K, V)> where
 		Self::Hasher: ReversibleStorageHasher
 	{
 		let prefix = G::prefix_hash();
@@ -292,7 +292,7 @@ impl<K: FullCodec, V: FullCodec, G: StorageMap<K, V>> storage::StorageMap<K, V>
 		}
 	}
 
-	fn iter_value() -> storage::PrefixIterator<V> {
+	fn iter_values() -> storage::PrefixIterator<V> {
 		let prefix = Self::prefix_hash();
 		storage::PrefixIterator {
 			prefix: prefix.to_vec(),
@@ -302,7 +302,7 @@ impl<K: FullCodec, V: FullCodec, G: StorageMap<K, V>> storage::StorageMap<K, V>
 		}
 	}
 
-	fn translate_key_value<O: Decode, F: Fn(K, O) -> Option<V>>(f: F) where
+	fn translate<O: Decode, F: Fn(K, O) -> Option<V>>(f: F) where
 		Self::Hasher: ReversibleStorageHasher
 	{
 		let prefix = G::prefix_hash();
@@ -347,7 +347,7 @@ impl<K: FullCodec, V: FullCodec, G: StorageMap<K, V>> storage::StorageMap<K, V>
 		}
 	}
 
-	fn translate_value<OldV, TranslateV>(translate_val: TranslateV) -> Result<(), u32>
+	fn translate_values<OldV, TranslateV>(translate_val: TranslateV) -> Result<(), u32>
 		where OldV: Decode, TranslateV: Fn(OldV) -> V
 	{
 		let prefix = Self::prefix_hash();

frame/support/src/storage/generator/mod.rs

@@ -89,15 +89,15 @@ mod tests {
 			}
 
 			assert_eq!(
-				NumberMap::iter_key_value().collect::<Vec<_>>(),
+				NumberMap::iter().collect::<Vec<_>>(),
 				(0..100).map(|x| (x as u32, x as u64)).collect::<Vec<_>>(),
 			);
 
 			// do translation.
-			NumberMap::translate_key_value(|k: u32, v: u64| if k % 2 == 0 { Some((k as u64) << 32 | v) } else { None });
+			NumberMap::translate(|k: u32, v: u64| if k % 2 == 0 { Some((k as u64) << 32 | v) } else { None });
 
 			assert_eq!(
-				NumberMap::iter_key_value().collect::<Vec<_>>(),
+				NumberMap::iter().collect::<Vec<_>>(),
 				(0..50u32).map(|x| x * 2).map(|x| (x, (x as u64) << 32 | x as u64)).collect::<Vec<_>>(),
 			);
 		})

frame/support/src/storage/mod.rs

@@ -18,7 +18,7 @@
 
 use sp_std::prelude::*;
 use codec::{FullCodec, FullEncode, Encode, EncodeAppend, EncodeLike, Decode};
-use crate::{traits::Len, hash::{StorageHasher, ReversibleStorageHasher, FixedLengthHasher}};
+use crate::{traits::Len, hash::{StorageHasher, ReversibleStorageHasher}};
 
 pub mod unhashed;
 pub mod hashed;
@@ -223,26 +223,19 @@ pub trait StorageMap<K: FullEncode, V: FullCodec> {
 
 	/// Enumerate all elements in the map in no particular order. If you alter the map while doing
 	/// this, you'll get undefined results.
-	fn iter_key_value() -> PrefixIterator<(K, V)> where Self::Hasher: ReversibleStorageHasher;
+	fn iter() -> PrefixIterator<(K, V)> where Self::Hasher: ReversibleStorageHasher;
 
 	/// Remove all elements from the map and iterate through them in no particular order. If you
 	/// add elements to the map while doing this, you'll get undefined results.
-	fn drain_key_value() -> PrefixIterator<(K, V)> where Self::Hasher: ReversibleStorageHasher;
+	fn drain() -> PrefixIterator<(K, V)> where Self::Hasher: ReversibleStorageHasher;
 
 	/// Enumerate all elements in the map in no particular order. If you alter the map while doing
 	/// this, you'll get undefined results.
-	#[deprecated(note = "please use `iter_value` instead")]
-	fn iter() -> PrefixIterator<(K, V)> where Self::Hasher: ReversibleStorageHasher {
-		Self::iter_key_value()
-	}
-
-	/// Enumerate all elements in the map in no particular order. If you alter the map while doing
-	/// this, you'll get undefined results.
-	fn iter_value() -> PrefixIterator<V>;
+	fn iter_values() -> PrefixIterator<V>;
 
 	/// Translate the values of all elements by a function `f`, in the map in no particular order.
 	/// By returning `None` from `f` for an element, you'll remove it from the map.
-	fn translate_key_value<O: Decode, F: Fn(K, O) -> Option<V>>(f: F) where
+	fn translate<O: Decode, F: Fn(K, O) -> Option<V>>(f: F) where
 		Self::Hasher: ReversibleStorageHasher;
 
 	/// Translate the values from some previous `OldValue` to the current type.
@@ -263,7 +256,7 @@ pub trait StorageMap<K: FullEncode, V: FullCodec> {
 	/// This would typically be called inside the module implementation of on_runtime_upgrade, while
 	/// ensuring **no usage of this storage are made before the call to `on_runtime_upgrade`**. (More
 	/// precisely prior initialized modules doesn't make use of this storage).
-	fn translate_value<OldV, TranslateV>(translate_val: TranslateV) -> Result<(), u32>
+	fn translate_values<OldV, TranslateV>(translate_val: TranslateV) -> Result<(), u32>
 		where OldV: Decode, TranslateV: Fn(OldV) -> V;
 }
 
@@ -392,41 +385,26 @@ pub trait StorageDoubleMap<K1: FullEncode, K2: FullEncode, V: FullCodec> {
 	/// Enumerate all elements in the map with first key `k1` in no particular order. If you add or
 	/// remove values whose first key is `k1` to the map while doing this, you'll get undefined
 	/// results.
-	fn iter_prefix_key2_value(k1: impl EncodeLike<K1>) -> PrefixIterator<(K2, V)> where
+	fn iter_prefix(k1: impl EncodeLike<K1>) -> PrefixIterator<(K2, V)> where
 		Self::Hasher2: ReversibleStorageHasher;
 
 	/// Remove all elements from the map with first key `k1` and iterate through them in no
 	/// particular order. If you add elements with first key `k1` to the map while doing this,
 	/// you'll get undefined results.
-	fn drain_prefix_key2_value(k1: impl EncodeLike<K1>) -> PrefixIterator<(K2, V)> where
+	fn drain_prefix(k1: impl EncodeLike<K1>) -> PrefixIterator<(K2, V)> where
 		Self::Hasher2: ReversibleStorageHasher;
 
 	/// Iter over all value associated to the first key.
-	#[deprecated(note = "please use `iter_prefix_value` instead")]
-	fn iter_prefix<KArg1>(k1: KArg1) -> PrefixIterator<V> where KArg1: ?Sized + EncodeLike<K1> {
-		Self::iter_prefix_value(k1)
-	}
-
-	/// Iter over all value associated to the first key.
-	fn iter_prefix_value<KArg1>(k1: KArg1) -> PrefixIterator<V> where
+	fn iter_prefix_values<KArg1>(k1: KArg1) -> PrefixIterator<V> where
 		KArg1: ?Sized + EncodeLike<K1>;
 
-	/// Iter over all value and decode the first key.
-	fn iter_key1_value() -> PrefixIterator<(K1, V)> where
-		Self::Hasher1: ReversibleStorageHasher;
-
-	/// Iter over all value and decode the second key.
-	fn iter_key2_value() -> PrefixIterator<(K2, V)> where
-		Self::Hasher1: FixedLengthHasher,
-		Self::Hasher2: ReversibleStorageHasher;
-
 	/// Iter over all value and decode the first key and the second key.
-	fn iter_key1_key2_value() -> PrefixIterator<(K1, K2, V)> where
+	fn iter() -> PrefixIterator<(K1, K2, V)> where
 		Self::Hasher1: ReversibleStorageHasher,
 		Self::Hasher2: ReversibleStorageHasher;
 
 	/// Iter over all value.
-	fn iter_value() -> PrefixIterator<V>;
+	fn iter_values() -> PrefixIterator<V>;
 }
 
 /// Iterate over a prefix and decode raw_key and raw_value into `T`.