Legacy prefix tools.

memory-db/src/lib.rs

@@ -172,6 +172,24 @@ pub fn prefixed_key<H: KeyHasher>(key: &H::Out, prefix: Prefix) -> Vec<u8> {
 	prefixed_key
 }
 
+/// Legacy method for db using previous version of prefix encoding.
+/// Only for trie radix 16.
+pub fn legacy_prefixed_key<H: KeyHasher>(key: &H::Out, prefix: Prefix) -> Vec<u8> {
+	let mut prefixed_key = Vec::with_capacity(key.as_ref().len() + prefix.0.len() + 1);
+	if (prefix.1).0 == 0 {
+		prefixed_key.extend_from_slice(prefix.0);
+	} else {
+		let mut prev = 0u8;
+		for i in prefix.0.iter() {
+			prefixed_key.push((prev << 4) + (*i >> 4));
+			prev = *i;
+		}
+		prefixed_key.push((prev << 4) + ((prefix.1).1 >> 4));
+	}
+	prefixed_key.extend_from_slice(key.as_ref());
+	prefixed_key
+}
+
 /// Make database key from hash only.
 pub fn hash_key<H: KeyHasher>(key: &H::Out, _prefix: Prefix) -> H::Out {
 	key.clone()
@@ -201,6 +219,22 @@ impl<H: KeyHasher> KeyFunction<H> for PrefixedKey<H> {
 	}
 }
 
+#[derive(Clone,Debug)]
+/// Key function that concatenates prefix and hash.
+/// This is doing useless computation and should only be
+/// used for legacy purpose.
+pub struct LegacyPrefixedKey<H: KeyHasher>(PhantomData<H>);
+
+impl<H: KeyHasher> KeyFunction<H> for LegacyPrefixedKey<H> {
+	type Key = Vec<u8>;
+
+	fn key(hash: &H::Out, prefix: Prefix) -> Vec<u8> {
+		legacy_prefixed_key::<H>(hash, prefix)
+	}
+}
+
+
+
 impl<'a, H, KF, T> Default for MemoryDB<H, KF, T>
 where
 	H: KeyHasher,

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

@@ -42,7 +42,7 @@ use keccak_hasher::KeccakHasher;
 
 pub use trie_db::{Trie, TrieMut, NibbleSlice, Recorder, NodeCodec, ChildBitmap,
 	BitMap, ChildSliceIx};
-pub use trie_db::{Record, TrieLayOut, NibbleHalf, NibbleQuarter, NibbleOps};
+pub use trie_db::{Record, TrieLayOut, TrieOps, NibbleHalf, NibbleQuarter, NibbleOps};
 pub use trie_root::TrieStream;
 
 /// trie layout similar to parity-ethereum
@@ -56,6 +56,8 @@ impl TrieLayOut for LayoutOri {
 	type CB = Cache16;
 }
 
+impl TrieOps for LayoutOri { }
+
 /// trie layout similar to substrate one
 pub struct LayoutNew;
 
@@ -67,17 +69,21 @@ impl TrieLayOut for LayoutNew {
 	type CB = Cache16;
 }
 
+impl TrieOps for LayoutNew { }
+
 /// Test quarter nibble
 pub struct LayoutNewQuarter;
 
 impl TrieLayOut for LayoutNewQuarter {
-	const USE_EXTENSION: bool = false;
-	type H = keccak_hasher::KeccakHasher;
-	type C = ReferenceNodeCodecNoExt<BitMap4>;
-	type N = NibbleQuarter;
-	type CB = Cache4;
+  const USE_EXTENSION: bool = false;
+  type H = keccak_hasher::KeccakHasher;
+  type C = ReferenceNodeCodecNoExt<BitMap4>;
+  type N = NibbleQuarter;
+  type CB = Cache4;
 }
 
+impl TrieOps for LayoutNewQuarter { }
+
 /// bitmap codec for radix 16
 pub struct BitMap16(u16);
 

trie-db/src/iter_build.rs

@@ -323,7 +323,7 @@ pub trait ProcessEncodedNode<HO> {
 /// As for all `ProcessEncodedNode` implementation, it 
 /// is only for full trie parsing (not existing trie).
 pub struct TrieBuilder<'a, H, HO, V, DB> {
-	pub db: &'a mut DB,
+	db: &'a mut DB,
 	pub root: Option<HO>,
 	_ph: PhantomData<(H,V)>,
 }

trie-db/src/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2017, 2018 Parity Technologies
+// Copyright 2017, 2019 Parity Technologies
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -365,7 +365,7 @@ where
 	pub fn is_fat(&self) -> bool { self.spec == TrieSpec::Fat }
 }
 
-/// trait with definition of trie layout
+/// Trait with definition of trie layout
 pub trait TrieLayOut {
 	/// does the trie use extension before its branch
 	const USE_EXTENSION: bool;
@@ -375,6 +375,67 @@ pub trait TrieLayOut {
 	type CB: CacheBuilder<<Self::H as Hasher>::Out>;
 }
 
+/// Trait with operation on key value iterator.
+/// This trait contains its own default implementation.
+/// Implementing it allows to use alternate algorithm.
+pub trait TrieOps: Sized + TrieLayOut {
+	/// Operation to build a trie db from its ordered iterator of key value
+	fn trie_build<DB, I, A, B>(db: &mut DB, input: I) -> <Self::H as Hasher>::Out where
+	DB: HashDB<Self::H, usize>,
+	I: IntoIterator<Item = (A, B)>,
+	A: AsRef<[u8]> + Ord,
+	B: AsRef<[u8]>,
+	{
+		let mut cb = TrieBuilder::new(db);
+		trie_visit::<Self, _, _, _, _>(input.into_iter(), &mut cb);
+		cb.root.unwrap_or(Default::default())
+	}
+	/// Determine a trie root given its ordered contents, closed form.
+	fn trie_root<I, A, B>(input: I) -> <Self::H as Hasher>::Out where
+	I: IntoIterator<Item = (A, B)>,
+	A: AsRef<[u8]> + Ord,
+	B: AsRef<[u8]>,
+	{
+		let mut cb = TrieRoot::<Self::H, _>::default();
+		trie_visit::<Self, _, _, _, _>(input.into_iter(), &mut cb);
+		cb.root.unwrap_or(Default::default())
+	}
+
+	/// Determine a trie root node's data given its ordered contents, closed form.
+	fn trie_root_unhashed<I, A, B>(input: I) -> Vec<u8> where
+	I: IntoIterator<Item = (A, B)>,
+	A: AsRef<[u8]> + Ord,
+	B: AsRef<[u8]>,
+	{
+		let mut cb = TrieRootUnhashed::<Self::H>::default();
+		trie_visit::<Self, _, _, _, _>(input.into_iter(), &mut cb);
+		cb.root.unwrap_or(Default::default())
+	}
+
+	/// Encoding of index as a key (when reusing general trie for 
+	/// indexed trie).
+	fn encode_index(input: u32) -> Vec<u8> {
+		// be for byte ordering
+		input.to_be_bytes().to_vec()
+	}
+	/// A trie root formed from the items, with keys attached according to their
+	/// compact-encoded index (using `parity-codec` crate).
+	fn ordered_trie_root<I, A>(input: I) -> <Self::H as Hasher>::Out
+	where
+		I: IntoIterator<Item = A>,
+		A: AsRef<[u8]>,
+	{
+		Self::trie_root(input
+			.into_iter()
+			.enumerate()
+			.map(|(i, v)| (Self::encode_index(i as u32), v))
+		)
+	}
+/*	/// Operation to build a trie from an unordered iterator of key value.
+	/// Operation to calculate a trie root from an ordered iterator of key value.
+	/// Operation to build a trie from an ordered iterator of key value.*/
+}
+
 /// alias to acces hasher hash output type from a `TrieLayout`
 pub type TrieHash<L> = <<L as TrieLayOut>::H as Hasher>::Out;
 /// alias to acces bitmap codec from a `TrieLayout`

trie-db/src/triedb.rs

@@ -1,4 +1,4 @@
-// Copyright 2017, 2018 Parity Technologies
+// Copyright 2017, 2019 Parity Technologies
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.