Trie without extension node

hash-db/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hash-db"
-version = "0.14.0"
+version = "0.15.0"
 authors = ["Parity Technologies <[email protected]>"]
 description = "Trait for hash-keyed databases."
 license = "Apache-2.0"

hash-db/src/lib.rs

@@ -20,37 +20,47 @@
 use std::fmt::Debug;
 #[cfg(feature = "std")]
 use std::hash;
+#[cfg(not(feature = "std"))]
+use core::hash;
+
 #[cfg(feature = "std")]
 pub trait MaybeDebug: Debug {}
 #[cfg(feature = "std")]
 impl<T: Debug> MaybeDebug for T {}
-
-#[cfg(not(feature = "std"))]
-use core::hash;
 #[cfg(not(feature = "std"))]
 pub trait MaybeDebug {}
 #[cfg(not(feature = "std"))]
 impl<T> MaybeDebug for T {}
 
 
-/// Empty prefix constant.
-pub static EMPTY_PREFIX: Prefix<'static> = &[];
+/// A trie node prefix, it is the nibble path from the trie root
+/// to the trie node.
+/// For a node containing no partial key value it is the full key.
+/// For a value node or node containing a partial key, it is the full key minus its node partial
+/// nibbles (the node key can be split into prefix and node partial).
+/// Therefore it is always the leftmost portion of the node key, so its internal representation
+/// is a non expanded byte slice followed by a last padded byte representation.
+/// The padded byte is an optional padded value.
+pub type Prefix<'a> = (&'a[u8], Option<u8>);
 
-/// Prefix byte information for avoding rc.
-pub type Prefix<'a> = &'a[u8];
+/// An empty prefix constant.
+/// Can be use when the prefix is not use internally
+/// or for root nodes.
+pub static EMPTY_PREFIX: Prefix<'static> = (&[], None);
 
 /// Trait describing an object that can hash a slice of bytes. Used to abstract
 /// other types over the hashing algorithm. Defines a single `hash` method and an
 /// `Out` associated type with the necessary bounds.
 pub trait Hasher: Sync + Send {
 	/// The output type of the `Hasher`
-	type Out: AsRef<[u8]> + AsMut<[u8]> + Default + MaybeDebug + PartialEq + Eq + hash::Hash + Send + Sync + Clone + Copy;
-	/// What to use to build `HashMap`s with this `Hasher`
+	type Out: AsRef<[u8]> + AsMut<[u8]> + Default + MaybeDebug + PartialEq + Eq
+		+ hash::Hash + Send + Sync + Clone + Copy;
+	/// What to use to build `HashMap`s with this `Hasher`.
 	type StdHasher: Sync + Send + Default + hash::Hasher;
-	/// The length in bytes of the `Hasher` output
+	/// The length in bytes of the `Hasher` output.
 	const LENGTH: usize;
 
-	/// Compute the hash of the provided slice of bytes returning the `Out` type of the `Hasher`
+	/// Compute the hash of the provided slice of bytes returning the `Out` type of the `Hasher`.
 	fn hash(x: &[u8]) -> Self::Out;
 }
 
@@ -101,42 +111,47 @@ impl<'a, K, V> PlainDBRef<K, V> for &'a mut dyn PlainDB<K, V> {
 pub trait HashDB<H: Hasher, T>: Send + Sync + AsHashDB<H, T> {
 	/// Look up a given hash into the bytes that hash to it, returning None if the
 	/// hash is not known.
-	fn get(&self, key: &H::Out, prefix: &[u8]) -> Option<T>;
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<T>;
 
 	/// Check for the existance of a hash-key.
-	fn contains(&self, key: &H::Out, prefix: &[u8]) -> bool;
+	fn contains(&self, key: &H::Out, prefix: Prefix) -> bool;
 
 	/// Insert a datum item into the DB and return the datum's hash for a later lookup. Insertions
 	/// are counted and the equivalent number of `remove()`s must be performed before the data
 	/// is considered dead.
-	fn insert(&mut self, prefix: &[u8], value: &[u8]) -> H::Out;
+	fn insert(&mut self, prefix: Prefix, value: &[u8]) -> H::Out;
 
 	/// Like `insert()`, except you provide the key and the data is all moved.
-	fn emplace(&mut self, key: H::Out, prefix: &[u8], value: T);
+	fn emplace(&mut self, key: H::Out, prefix: Prefix, value: T);
 
-	/// Remove a datum previously inserted. Insertions can be "owed" such that the same number of `insert()`s may
-	/// happen without the data being eventually being inserted into the DB. It can be "owed" more than once.
-	fn remove(&mut self, key: &H::Out, prefix: &[u8]);
+	/// Remove a datum previously inserted. Insertions can be "owed" such that the same number of
+	/// `insert()`s may happen without the data being eventually being inserted into the DB.
+	/// It can be "owed" more than once.
+	fn remove(&mut self, key: &H::Out, prefix: Prefix);
 }
 
 /// Trait for immutable reference of HashDB.
 pub trait HashDBRef<H: Hasher, T> {
 	/// Look up a given hash into the bytes that hash to it, returning None if the
 	/// hash is not known.
-	fn get(&self, key: &H::Out, prefix: &[u8]) -> Option<T>;
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<T>;
 
 	/// Check for the existance of a hash-key.
-	fn contains(&self, key: &H::Out, prefix: &[u8]) -> bool;
+	fn contains(&self, key: &H::Out, prefix: Prefix) -> bool;
 }
 
 impl<'a, H: Hasher, T> HashDBRef<H, T> for &'a dyn HashDB<H, T> {
-	fn get(&self, key: &H::Out, prefix: &[u8]) -> Option<T> { HashDB::get(*self, key, prefix) }
-	fn contains(&self, key: &H::Out, prefix: &[u8]) -> bool { HashDB::contains(*self, key, prefix) }
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<T> { HashDB::get(*self, key, prefix) }
+	fn contains(&self, key: &H::Out, prefix: Prefix) -> bool {
+		HashDB::contains(*self, key, prefix)
+	}
 }
 
 impl<'a, H: Hasher, T> HashDBRef<H, T> for &'a mut dyn HashDB<H, T> {
-	fn get(&self, key: &H::Out, prefix: &[u8]) -> Option<T> { HashDB::get(*self, key, prefix) }
-	fn contains(&self, key: &H::Out, prefix: &[u8]) -> bool { HashDB::contains(*self, key, prefix) }
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<T> { HashDB::get(*self, key, prefix) }
+	fn contains(&self, key: &H::Out, prefix: Prefix) -> bool {
+		HashDB::contains(*self, key, prefix)
+	}
 }
 
 /// Upcast trait for HashDB.
@@ -155,15 +170,18 @@ pub trait AsPlainDB<K, V> {
 	fn as_plain_db_mut<'a>(&'a mut self) -> &'a mut (dyn PlainDB<K, V> + 'a);
 }
 
-// NOTE: There used to be a `impl<T> AsHashDB for T` but that does not work with generics. See https://stackoverflow.com/questions/48432842/implementing-a-trait-for-reference-and-non-reference-types-causes-conflicting-im
-// This means we need concrete impls of AsHashDB in several places, which somewhat defeats the point of the trait.
+// NOTE: There used to be a `impl<T> AsHashDB for T` but that does not work with generics.
+// See https://stackoverflow.com/questions/48432842/
+// implementing-a-trait-for-reference-and-non-reference-types-causes-conflicting-im
+// This means we need concrete impls of AsHashDB in several places, which somewhat defeats
+// the point of the trait.
 impl<'a, H: Hasher, T> AsHashDB<H, T> for &'a mut dyn HashDB<H, T> {
 	fn as_hash_db(&self) -> &dyn HashDB<H, T> { &**self }
 	fn as_hash_db_mut<'b>(&'b mut self) -> &'b mut (dyn HashDB<H, T> + 'b) { &mut **self }
 }
 
 #[cfg(feature = "std")]
-impl<'a, K, V> AsPlainDB<K, V> for &'a mut PlainDB<K, V> {
-	fn as_plain_db(&self) -> &PlainDB<K, V> { &**self }
-	fn as_plain_db_mut<'b>(&'b mut self) -> &'b mut (PlainDB<K, V> + 'b) { &mut **self }
+impl<'a, K, V> AsPlainDB<K, V> for &'a mut dyn PlainDB<K, V> {
+	fn as_plain_db(&self) -> &dyn PlainDB<K, V> { &**self }
+	fn as_plain_db_mut<'b>(&'b mut self) -> &'b mut (dyn PlainDB<K, V> + 'b) { &mut **self }
 }

hash256-std-hasher/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "hash256-std-hasher"
 description = "Standard library hasher for 256-bit prehashed keys."
-version = "0.14.0"
+version = "0.15.0"
 authors = ["Parity Technologies <[email protected]>"]
 license = "Apache-2.0"
 homepage = "https://github.com/paritytech/trie"

hash256-std-hasher/src/lib.rs

@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #![cfg_attr(not(feature = "std"), no_std)]
-#![cfg_attr(not(feature = "std"), feature(core_intrinsics))]
 
 #[macro_use]
 extern crate crunchy;

memory-db/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "memory-db"
-version = "0.14.0"
+version = "0.15.0"
 authors = ["Parity Technologies <[email protected]>"]
 description = "In-memory implementation of hash-db, useful for tests"
 repository = "https://github.com/paritytech/trie"
@@ -9,11 +9,11 @@ license = "Apache-2.0"
 [dependencies]
 heapsize = { version = "0.4", optional = true }
 parity-util-mem = { version = "0.2", default-features = false }
-hash-db = { path = "../hash-db", default-features = false, version = "0.14.0"}
+hash-db = { path = "../hash-db", default-features = false, version = "0.15.0"}
 hashmap_core = { version = "0.1" }
 
 [dev-dependencies]
-keccak-hasher = { path = "../test-support/keccak-hasher", version = "0.14.0"}
+keccak-hasher = { path = "../test-support/keccak-hasher", version = "0.15.0"}
 criterion = "0.2.8"
 
 [features]

memory-db/benches/bench.rs

@@ -24,12 +24,13 @@ extern crate memory_db;
 extern crate keccak_hasher;
 
 use memory_db::MemoryDB;
+use memory_db::HashKey;
 use keccak_hasher::KeccakHasher;
-use hash_db::{HashDB, Hasher};
+use hash_db::{HashDB, Hasher, EMPTY_PREFIX};
 
 fn instantiation(b: &mut Criterion) {
 	b.bench_function("instantiation", |b| b.iter(|| {
-		MemoryDB::<KeccakHasher, Vec<u8>>::default();
+		MemoryDB::<KeccakHasher, HashKey<KeccakHasher>, Vec<u8>>::default();
 	}));
 }
 
@@ -52,19 +53,19 @@ fn compare_to_null_in_const(b: &mut Criterion) {
 }
 
 fn contains_with_non_null_key(b: &mut Criterion) {
-	let mut m = MemoryDB::<KeccakHasher, Vec<u8>>::default();
+	let mut m = MemoryDB::<KeccakHasher, HashKey<KeccakHasher>, Vec<u8>>::default();
 	let key = KeccakHasher::hash(b"abc");
-	m.insert(b"abcefghijklmnopqrstuvxyz");
+	m.insert(EMPTY_PREFIX, b"abcefghijklmnopqrstuvxyz");
 	b.bench_function("contains_with_non_null_key", |b| b.iter(|| {
-		m.contains(&key);
+		m.contains(&key, EMPTY_PREFIX);
 	}));
 }
 
 fn contains_with_null_key(b: &mut Criterion) {
-	let mut m = MemoryDB::<KeccakHasher, Vec<u8>>::default();
+	let mut m = MemoryDB::<KeccakHasher, HashKey<KeccakHasher>, Vec<u8>>::default();
 	let null_key = KeccakHasher::hash(&[0u8][..]);
-	m.insert(b"abcefghijklmnopqrstuvxyz");
+	m.insert(EMPTY_PREFIX, b"abcefghijklmnopqrstuvxyz");
 	b.bench_function("contains_with_null_key", |b| b.iter(|| {
-		m.contains(&null_key);
+		m.contains(&null_key, EMPTY_PREFIX);
 	}));
 }