Remove HashDB::emplace()

The emplace method is hard to use safely. The HashDB's key must be the
blake2b hash of the value, but it might not be when the user uses
emplace because the emplace passes the key.

Author: Seulgi Kim

util/hashdb/src/lib.rs

@@ -40,9 +40,6 @@ pub trait HashDB: AsHashDB + Send + Sync {
     /// is considered dead.
     fn insert(&mut self, value: &[u8]) -> H256;
 
-    /// Like `insert()` , except you provide the key and the data is all moved.
-    fn emplace(&mut self, key: H256, value: DBValue);
-
     /// 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: &H256);

util/journaldb/src/archivedb.rs

@@ -96,10 +96,6 @@ impl HashDB for ArchiveDB {
         self.overlay.insert(value)
     }
 
-    fn emplace(&mut self, key: H256, value: DBValue) {
-        self.overlay.emplace(key, value);
-    }
-
     fn remove(&mut self, key: &H256) {
         self.overlay.remove(key);
     }
@@ -357,15 +353,14 @@ mod tests {
     #[test]
     fn reopen() {
         let shared_db = Arc::new(kvdb_memorydb::create(0));
-        let bar_hash = H256::random();
 
-        let foo_hash = {
+        let (foo_hash, bar_hash) = {
             let mut jdb = ArchiveDB::new(shared_db.clone(), None);
             // history is 1
             let foo_hash = jdb.insert(b"foo");
-            jdb.emplace(bar_hash, b"bar".to_vec());
+            let bar_hash = jdb.insert(b"bar");
             jdb.commit_batch(0, &blake256(b"0"), None).unwrap();
-            foo_hash
+            (foo_hash, bar_hash)
         };
 
         {

util/memorydb/src/lib.rs

@@ -229,25 +229,6 @@ impl HashDB for MemoryDB {
         key
     }
 
-    fn emplace(&mut self, key: H256, value: DBValue) {
-        if *value == NULL_RLP {
-            return
-        }
-
-        match self.data.entry(key) {
-            Entry::Occupied(mut entry) => {
-                let &mut (ref mut old_value, ref mut rc) = entry.get_mut();
-                if *rc <= 0 {
-                    *old_value = value;
-                }
-                *rc += 1;
-            }
-            Entry::Vacant(entry) => {
-                entry.insert((value, 1));
-            }
-        }
-    }
-
     fn remove(&mut self, key: &H256) {
         if key == &BLAKE_NULL_RLP {
             return
@@ -308,7 +289,7 @@ mod tests {
         main.remove(&remove_key);
 
         let insert_key = other.insert(b"arf");
-        main.emplace(insert_key, b"arf".to_vec());
+        main.insert(b"arf");
 
         let negative_remove_key = other.insert(b"negative");
         other.remove(&negative_remove_key); // ref cnt: 0