No instance for Layout (NodeCodec should have one at some point), to

benefit from constant.

test-support/reference-trie/src/lib.rs

@@ -40,28 +40,22 @@ use keccak_hasher::KeccakHasher;
 pub use trie_db::{Trie, TrieMut, NibbleSlice, NodeCodec, Recorder, Record, TrieLayOut};
 pub use trie_root::TrieStream;
 
-#[derive(Clone,Default)]
 /// trie layout similar to parity-ethereum
 pub struct LayoutOri;
 
 impl TrieLayOut for LayoutOri {
-  type H = keccak_hasher::KeccakHasher;
-  type C = ReferenceNodeCodec;
-
-  fn uses_extension(&self) -> bool { true }
-  fn new_codec(&self) -> Self::C { ReferenceNodeCodec }
+  const USE_EXTENSION: bool = true;
+	type H = keccak_hasher::KeccakHasher;
+	type C = ReferenceNodeCodec;
 }
 
-#[derive(Clone,Default)]
 /// trie layout similar to substrate one
 pub struct LayoutNew;
 
 impl TrieLayOut for LayoutNew {
-  type H = keccak_hasher::KeccakHasher;
-  type C = ReferenceNodeCodecNoExt;
-
-  fn uses_extension(&self) -> bool { false }
-  fn new_codec(&self) -> Self::C { ReferenceNodeCodecNoExt }
+  const USE_EXTENSION: bool = false;
+	type H = keccak_hasher::KeccakHasher;
+	type C = ReferenceNodeCodecNoExt;
 }
 
 pub type RefTrieDB<'a> = trie_db::TrieDB<'a, keccak_hasher::KeccakHasher, ReferenceNodeCodec>;
@@ -700,7 +694,7 @@ pub fn compare_impl<X : hash_db::HashDB<KeccakHasher,DBValue> + Eq> (
 	};
 	let root = {
 		let mut root = Default::default();
-		let mut t = RefTrieDBMut::new(&mut memdb, &mut root, LayoutOri);
+		let mut t = RefTrieDBMut::new(&mut memdb, &mut root);
 		for i in 0..data.len() {
 			t.insert(&data[i].0[..],&data[i].1[..]).unwrap();
 		}
@@ -742,7 +736,7 @@ pub fn compare_root(
 	};
 	let root = {
 		let mut root = Default::default();
-		let mut t = RefTrieDBMut::new(&mut memdb, &mut root, LayoutOri);
+		let mut t = RefTrieDBMut::new(&mut memdb, &mut root);
 		for i in 0..data.len() {
 			t.insert(&data[i].0[..],&data[i].1[..]).unwrap();
 		}
@@ -818,17 +812,17 @@ pub fn compare_impl_no_ext(
 	};
 	let root = {
 		let mut root = Default::default();
-		let mut t = RefTrieDBMutNoExt::new(&mut memdb, &mut root, LayoutNew);
+		let mut t = RefTrieDBMutNoExt::new(&mut memdb, &mut root);
 		for i in 0..data.len() {
 			t.insert(&data[i].0[..],&data[i].1[..]).unwrap();
 		}
 		t.root().clone()
 	};
-/*  {
+/*	{
 		let db : &dyn hash_db::HashDB<_,_> = &memdb;
 			let t = RefTrieDBNoExt::new(&db, &root).unwrap();
 			println!("{:?}", t);
-  }*/
+	}*/
 
 	if root != root_new {
 		{
@@ -860,7 +854,7 @@ pub fn compare_impl_no_ext_unordered(
 	let mut b_map = std::collections::btree_map::BTreeMap::new();
 	let root = {
 		let mut root = Default::default();
-		let mut t = RefTrieDBMutNoExt::new(&mut memdb, &mut root, LayoutNew);
+		let mut t = RefTrieDBMutNoExt::new(&mut memdb, &mut root);
 		for i in 0..data.len() {
 			t.insert(&data[i].0[..],&data[i].1[..]).unwrap();
 			b_map.insert(data[i].0.clone(),data[i].1.clone());
@@ -903,13 +897,13 @@ pub fn compare_no_ext_insert_remove(
 	let mut root = Default::default();
 	let mut a = 0;
 	{
-		let mut t = RefTrieDBMutNoExt::new(&mut memdb, &mut root, LayoutNew);
+		let mut t = RefTrieDBMutNoExt::new(&mut memdb, &mut root);
 		t.commit();
 	}
 	while a < data.len() {
 		// new triemut every 3 element
 		root = {
-			let mut t = RefTrieDBMutNoExt::from_existing(&mut memdb, &mut root, LayoutNew).unwrap();
+			let mut t = RefTrieDBMutNoExt::from_existing(&mut memdb, &mut root).unwrap();
 			for _ in 0..3 {
 				if data[a].0 {
 					// remove
@@ -930,7 +924,7 @@ pub fn compare_no_ext_insert_remove(
 			*t.root()
 		};
 	}
-	let mut t = RefTrieDBMutNoExt::from_existing(&mut memdb, &mut root, LayoutNew).unwrap();
+	let mut t = RefTrieDBMutNoExt::from_existing(&mut memdb, &mut root).unwrap();
 	// we are testing the RefTrie code here so we do not sort or check uniqueness
 	// before.
 	assert_eq!(*t.root(), calc_root_no_ext(data2));
@@ -944,13 +938,13 @@ pub fn compare_no_ext_insert_remove(
 #[should_panic]
 #[test]
 fn too_big_nibble_len () {
-  // + 1 for 0 added byte of nibble encode
-  let input = vec![0u8; (noext_cst::LEAF_NODE_OVER as usize + 256) / 2 + 1];
-  let enc = ReferenceNodeCodecNoExt::leaf_node(&input, &[1]);
-  let dec = ReferenceNodeCodecNoExt::decode(&enc).unwrap();
-  let o_sl = if let Node::Leaf(sl,_) = dec {
-    //assert_eq!(&input[..], &sl.encoded(false)[..]);
-    Some(sl)
-  } else { None };
-  //assert!(o_sl.is_some());
+	// + 1 for 0 added byte of nibble encode
+	let input = vec![0u8; (noext_cst::LEAF_NODE_OVER as usize + 256) / 2 + 1];
+	let enc = ReferenceNodeCodecNoExt::leaf_node(&input, &[1]);
+	let dec = ReferenceNodeCodecNoExt::decode(&enc).unwrap();
+	let o_sl = if let Node::Leaf(sl,_) = dec {
+		//assert_eq!(&input[..], &sl.encoded(false)[..]);
+		Some(sl)
+	} else { None };
+	//assert!(o_sl.is_some());
 }

test-support/trie-bench/src/lib.rs

@@ -55,9 +55,9 @@ where
 			trie_root::<L::H, S, _, _, _>(d.0.clone())
 		})),
 		Fun::new("Fill", |b, d: &TrieInsertionList| b.iter(&mut ||{
-			let mut memdb = MemoryDB::<_, HashKey<_>, _>::new(&L::C::empty_node()[..]);
+			let mut memdb = MemoryDB::<_, HashKey<L::H>, _>::new(&L::C::empty_node()[..]);
 			let mut root = <TrieHash<L>>::default();
-			let mut t = TrieDBMut::new(&mut memdb, &mut root, L::default());
+			let mut t = TrieDBMut::<L>::new(&mut memdb, &mut root);
 			for i in d.0.iter() {
 				t.insert(&i.0, &i.1).unwrap();
 			}
@@ -66,7 +66,7 @@ where
 			let mut memdb = MemoryDB::<_, HashKey<_>, _>::new(&L::C::empty_node()[..]);
 			let mut root = <TrieHash<L>>::default();
 			{
-				let mut t = TrieDBMut::new(&mut memdb, &mut root, L::default());
+				let mut t = TrieDBMut::<L>::new(&mut memdb, &mut root);
 				for i in d.0.iter() {
 					t.insert(&i.0, &i.1).unwrap();
 				}

trie-db/src/fatdb.rs

@@ -134,7 +134,7 @@ mod test {
 		let mut memdb = MemoryDB::<KeccakHasher, HashKey<_>, DBValue>::default();
 		let mut root = Default::default();
 		{
-			let mut t = RefFatDBMut::new(&mut memdb, &mut root, Default::default());
+			let mut t = RefFatDBMut::new(&mut memdb, &mut root);
 			t.insert(&[0x01u8, 0x23], &[0x01u8, 0x23]).unwrap();
 		}
 		let t = RefFatDB::new(&memdb, &root).unwrap();

trie-db/src/fatdbmut.rs

@@ -34,15 +34,15 @@ where
 	/// Create a new trie with the backing database `db` and empty `root`
 	/// Initialise to the state entailed by the genesis block.
 	/// This guarantees the trie is built correctly.
-	pub fn new(db: &'db mut HashDB<L::H, DBValue>, root: &'db mut TrieHash<L>, layout: L) -> Self {
-		FatDBMut { raw: TrieDBMut::new(db, root, layout) }
+	pub fn new(db: &'db mut HashDB<L::H, DBValue>, root: &'db mut TrieHash<L>) -> Self {
+		FatDBMut { raw: TrieDBMut::new(db, root) }
 	}
 
 	/// Create a new trie with the backing database `db` and `root`.
 	///
 	/// Returns an error if root does not exist.
-	pub fn from_existing(db: &'db mut HashDB<L::H, DBValue>, root: &'db mut TrieHash<L>, layout: L) -> Result<Self, TrieHash<L>, CError<L>> {
-		Ok(FatDBMut { raw: TrieDBMut::from_existing(db, root, layout)? })
+	pub fn from_existing(db: &'db mut HashDB<L::H, DBValue>, root: &'db mut TrieHash<L>) -> Result<Self, TrieHash<L>, CError<L>> {
+		Ok(FatDBMut { raw: TrieDBMut::from_existing(db, root)? })
 	}
 
 	/// Get the backing database.
@@ -114,7 +114,7 @@ mod test {
 		let mut memdb = MemoryDB::<KeccakHasher, HashKey<_>, _>::default();
 		let mut root = Default::default();
 		{
-			let mut t = RefFatDBMut::new(&mut memdb, &mut root, Default::default());
+			let mut t = RefFatDBMut::new(&mut memdb, &mut root);
 			t.insert(&[0x01u8, 0x23], &[0x01u8, 0x23]).unwrap();
 		}
 		let t = RefTrieDB::new(&memdb, &root).unwrap();
@@ -129,7 +129,7 @@ mod test {
 		let val = [0x01u8, 0x24];
 		let key_hash = KeccakHasher::hash(&key);
 		let aux_hash = KeccakHasher::hash(&key_hash);
-		let mut t = RefFatDBMut::new(&mut memdb, &mut root, Default::default());
+		let mut t = RefFatDBMut::new(&mut memdb, &mut root);
 		t.insert(&key, &val).unwrap();
 		assert_eq!(t.get(&key), Ok(Some(DBValue::from_slice(&val))));
 		assert_eq!(t.db().get(&aux_hash, &[]), Some(DBValue::from_slice(&key)));

trie-db/src/iter_build.rs

@@ -258,7 +258,7 @@ where
 			self.0[branch_d].0.iter(), v.as_ref().map(|v|v.as_ref()));
 		self.reset_depth(branch_d);
 		let ext_len = nkey.as_ref().map(|nkeyix|nkeyix.0).unwrap_or(0);
-		let encoded_key = NibbleSlice::new(&key_branch.as_ref()[..]).encoded_leftmost(branch_d - ext_len, false); // TODO EMCH !!!!!!!!!!! debug that it may be shifted from a unit!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+		let encoded_key = NibbleSlice::new(&key_branch.as_ref()[..]).encoded_leftmost(branch_d - ext_len, false);
 		cb_ext.process(&encoded_key[..], encoded, is_root)
 	}
 

trie-db/src/lib.rs

@@ -342,11 +342,11 @@ where
 	}
 
 	/// Create new mutable instance of Trie.
-	pub fn create(&self, db: &'db mut HashDB<L::H, DBValue>, root: &'db mut TrieHash<L>, layout: L) -> Box<TrieMut<L::H, L::C> + 'db> {
+	pub fn create(&self, db: &'db mut HashDB<L::H, DBValue>, root: &'db mut TrieHash<L>) -> Box<TrieMut<L::H, L::C> + 'db> {
 		match self.spec {
-			TrieSpec::Generic => Box::new(TrieDBMut::new(db, root, layout)),
-			TrieSpec::Secure => Box::new(SecTrieDBMut::new(db, root, layout)),
-			TrieSpec::Fat => Box::new(FatDBMut::new(db, root, layout)),
+			TrieSpec::Generic => Box::new(TrieDBMut::<L>::new(db, root)),
+			TrieSpec::Secure => Box::new(SecTrieDBMut::<L>::new(db, root)),
+			TrieSpec::Fat => Box::new(FatDBMut::<L>::new(db, root)),
 		}
 	}
 
@@ -355,12 +355,11 @@ where
 		&self,
 		db: &'db mut HashDB<L::H, DBValue>,
 		root: &'db mut TrieHash<L>,
-		layout: L,
 	) -> Result<Box<TrieMut<L::H,L::C> + 'db>, TrieHash<L>, CError<L>> {
 		match self.spec {
-			TrieSpec::Generic => Ok(Box::new(TrieDBMut::from_existing(db, root, layout)?)),
-			TrieSpec::Secure => Ok(Box::new(SecTrieDBMut::from_existing(db, root, layout)?)),
-			TrieSpec::Fat => Ok(Box::new(FatDBMut::from_existing(db, root, layout)?)),
+			TrieSpec::Generic => Ok(Box::new(TrieDBMut::<L>::from_existing(db, root)?)),
+			TrieSpec::Secure => Ok(Box::new(SecTrieDBMut::<L>::from_existing(db, root)?)),
+			TrieSpec::Fat => Ok(Box::new(FatDBMut::<L>::from_existing(db, root)?)),
 		}
 	}
 
@@ -370,17 +369,15 @@ where
 
 
 /// trait with definition of trie layout
-pub trait TrieLayOut: Clone + Send + Sync + Default {
+pub trait TrieLayOut {
+  /// does the trie use extension before its branch
+  const USE_EXTENSION: bool;
   type H: Hasher;
   type C: NodeCodec<Self::H>;
-
-  /// does the trie use extension before its branch
-  fn uses_extension(&self) -> bool;
-  fn new_codec(&self) -> Self::C;
 }
 
 /// alias to acces hasher hash output type from a `TrieLayout`
-pub type TrieHash<L: TrieLayOut> = <L::H as Hasher>::Out;
+pub type TrieHash<L> = <<L as TrieLayOut>::H as Hasher>::Out;
 /// alias to acces `NodeCodec` `Error` type from a `TrieLayout`
-pub type CError<L: TrieLayOut> = <L::C as NodeCodec<L::H>>::Error;
+pub type CError<L> = <<L as TrieLayOut>::C as NodeCodec<<L as TrieLayOut>::H>>::Error;
 

trie-db/src/recorder.rs

@@ -137,7 +137,7 @@ mod tests {
 		let mut db = MemoryDB::<KeccakHasher, HashKey<_>, _>::default();
 		let mut root = Default::default();
 		{
-			let mut x = RefTrieDBMut::new(&mut db, &mut root, Default::default());
+			let mut x = RefTrieDBMut::new(&mut db, &mut root);
 
 			x.insert(b"dog", b"cat").unwrap();
 			x.insert(b"lunch", b"time").unwrap();

trie-db/src/sectriedb.rs

@@ -91,7 +91,7 @@ mod test {
 		let mut db = MemoryDB::<KeccakHasher, HashKey<_>, DBValue>::default();
 		let mut root = Default::default();
 		{
-			let mut t = RefTrieDBMut::new(&mut db, &mut root, Default::default());
+			let mut t = RefTrieDBMut::new(&mut db, &mut root);
 			t.insert(&KeccakHasher::hash(&[0x01u8, 0x23]), &[0x01u8, 0x23]).unwrap();
 		}
 		let t = RefSecTrieDB::new(&db, &root).unwrap();

trie-db/src/sectriedbmut.rs

@@ -32,15 +32,15 @@ where
 	/// Create a new trie with the backing database `db` and empty `root`
 	/// Initialise to the state entailed by the genesis block.
 	/// This guarantees the trie is built correctly.
-	pub fn new(db: &'db mut HashDB<L::H, DBValue>, root: &'db mut TrieHash<L>, layout: L) -> Self {
-		SecTrieDBMut { raw: TrieDBMut::new(db, root, layout) }
+	pub fn new(db: &'db mut HashDB<L::H, DBValue>, root: &'db mut TrieHash<L>) -> Self {
+		SecTrieDBMut { raw: TrieDBMut::new(db, root) }
 	}
 
 	/// Create a new trie with the backing database `db` and `root`.
 	///
 	/// Returns an error if root does not exist.
-	pub fn from_existing(db: &'db mut HashDB<L::H, DBValue>, root: &'db mut TrieHash<L>, layout: L) -> Result<Self, TrieHash<L>, CError<L>> {
-		Ok(SecTrieDBMut { raw: TrieDBMut::from_existing(db, root, layout)? })
+	pub fn from_existing(db: &'db mut HashDB<L::H, DBValue>, root: &'db mut TrieHash<L>) -> Result<Self, TrieHash<L>, CError<L>> {
+		Ok(SecTrieDBMut { raw: TrieDBMut::from_existing(db, root)? })
 	}
 
 	/// Get the backing database.
@@ -94,7 +94,7 @@ mod test {
 		let mut memdb = MemoryDB::<KeccakHasher, HashKey<_>, DBValue>::default();
 		let mut root = Default::default();
 		{
-			let mut t = RefSecTrieDBMut::new(&mut memdb, &mut root, Default::default());
+			let mut t = RefSecTrieDBMut::new(&mut memdb, &mut root);
 			t.insert(&[0x01u8, 0x23], &[0x01u8, 0x23]).unwrap();
 		}
 		let t = RefTrieDB::new(&memdb, &root).unwrap();