Remove Trie::get_with

We prefer using an interface instead of a concrete object to make code
open and generic.
But the current code reveals TrieDB that is an implementation of Trie
because the Trait which has a method having generic parameters cannot be
an object.

This commit removes the get_with method and replaces TrieDB with Trie.

Author: Seulgi Kim

state/src/cache/shard_cache.rs

@@ -16,7 +16,7 @@
 
 use std::cell::RefMut;
 
-use cmerkle::{Result as TrieResult, TrieDB, TrieMut};
+use cmerkle::{Result as TrieResult, Trie, TrieMut};
 
 use super::WriteBack;
 use crate::{AssetScheme, AssetSchemeAddress, OwnedAsset, OwnedAssetAddress};
@@ -58,11 +58,11 @@ impl ShardCache {
         Ok(())
     }
 
-    pub fn asset_scheme(&self, a: &AssetSchemeAddress, db: &TrieDB) -> TrieResult<Option<AssetScheme>> {
+    pub fn asset_scheme(&self, a: &AssetSchemeAddress, db: &dyn Trie) -> TrieResult<Option<AssetScheme>> {
         self.asset_scheme.get(a, db)
     }
 
-    pub fn asset_scheme_mut(&self, a: &AssetSchemeAddress, db: &TrieDB) -> TrieResult<RefMut<AssetScheme>> {
+    pub fn asset_scheme_mut(&self, a: &AssetSchemeAddress, db: &dyn Trie) -> TrieResult<RefMut<AssetScheme>> {
         self.asset_scheme.get_mut(a, db)
     }
 
@@ -72,7 +72,7 @@ impl ShardCache {
         self.asset_scheme.create(a, f)
     }
 
-    pub fn asset(&self, a: &OwnedAssetAddress, db: &TrieDB) -> TrieResult<Option<OwnedAsset>> {
+    pub fn asset(&self, a: &OwnedAssetAddress, db: &dyn Trie) -> TrieResult<Option<OwnedAsset>> {
         self.asset.get(a, db)
     }
 

state/src/cache/top_cache.rs

@@ -17,7 +17,7 @@
 use std::cell::RefMut;
 
 use ckey::Address;
-use cmerkle::{Result as TrieResult, TrieDB, TrieMut};
+use cmerkle::{Result as TrieResult, Trie, TrieMut};
 use primitives::H256;
 
 use super::WriteBack;
@@ -90,43 +90,43 @@ impl TopCache {
         Ok(())
     }
 
-    pub fn account(&self, a: &Address, db: &TrieDB) -> TrieResult<Option<Account>> {
+    pub fn account(&self, a: &Address, db: &dyn Trie) -> TrieResult<Option<Account>> {
         self.account.get(a, db)
     }
 
-    pub fn account_mut(&self, a: &Address, db: &TrieDB) -> TrieResult<RefMut<Account>> {
+    pub fn account_mut(&self, a: &Address, db: &dyn Trie) -> TrieResult<RefMut<Account>> {
         self.account.get_mut(a, db)
     }
 
     pub fn remove_account(&self, address: &Address) {
         self.account.remove(address)
     }
 
-    pub fn regular_account(&self, a: &RegularAccountAddress, db: &TrieDB) -> TrieResult<Option<RegularAccount>> {
+    pub fn regular_account(&self, a: &RegularAccountAddress, db: &dyn Trie) -> TrieResult<Option<RegularAccount>> {
         self.regular_account.get(a, db)
     }
 
-    pub fn regular_account_mut(&self, a: &RegularAccountAddress, db: &TrieDB) -> TrieResult<RefMut<RegularAccount>> {
+    pub fn regular_account_mut(&self, a: &RegularAccountAddress, db: &dyn Trie) -> TrieResult<RefMut<RegularAccount>> {
         self.regular_account.get_mut(a, db)
     }
 
     pub fn remove_regular_account(&self, address: &RegularAccountAddress) {
         self.regular_account.remove(address)
     }
 
-    pub fn metadata(&self, a: &MetadataAddress, db: &TrieDB) -> TrieResult<Option<Metadata>> {
+    pub fn metadata(&self, a: &MetadataAddress, db: &dyn Trie) -> TrieResult<Option<Metadata>> {
         self.metadata.get(a, db)
     }
 
-    pub fn metadata_mut(&self, a: &MetadataAddress, db: &TrieDB) -> TrieResult<RefMut<Metadata>> {
+    pub fn metadata_mut(&self, a: &MetadataAddress, db: &dyn Trie) -> TrieResult<RefMut<Metadata>> {
         self.metadata.get_mut(a, db)
     }
 
-    pub fn shard(&self, a: &ShardAddress, db: &TrieDB) -> TrieResult<Option<Shard>> {
+    pub fn shard(&self, a: &ShardAddress, db: &dyn Trie) -> TrieResult<Option<Shard>> {
         self.shard.get(a, db)
     }
 
-    pub fn shard_mut(&self, a: &ShardAddress, db: &TrieDB) -> TrieResult<RefMut<Shard>> {
+    pub fn shard_mut(&self, a: &ShardAddress, db: &dyn Trie) -> TrieResult<RefMut<Shard>> {
         self.shard.get_mut(a, db)
     }
 
@@ -135,23 +135,23 @@ impl TopCache {
         self.shard.remove(address)
     }
 
-    pub fn text(&self, a: &H256, db: &TrieDB) -> TrieResult<Option<Text>> {
+    pub fn text(&self, a: &H256, db: &dyn Trie) -> TrieResult<Option<Text>> {
         self.text.get(a, db)
     }
 
-    pub fn text_mut(&self, a: &H256, db: &TrieDB) -> TrieResult<RefMut<Text>> {
+    pub fn text_mut(&self, a: &H256, db: &dyn Trie) -> TrieResult<RefMut<Text>> {
         self.text.get_mut(a, db)
     }
 
     pub fn remove_text(&self, address: &H256) {
         self.text.remove(address);
     }
 
-    pub fn action_data(&self, a: &H256, db: &TrieDB) -> TrieResult<Option<ActionData>> {
+    pub fn action_data(&self, a: &H256, db: &dyn Trie) -> TrieResult<Option<ActionData>> {
         self.action_data.get(a, db)
     }
 
-    pub fn action_data_mut(&self, a: &H256, db: &TrieDB) -> TrieResult<RefMut<ActionData>> {
+    pub fn action_data_mut(&self, a: &H256, db: &dyn Trie) -> TrieResult<RefMut<ActionData>> {
         self.action_data.get_mut(a, db)
     }
 

state/src/cache/write_back.rs

@@ -22,7 +22,7 @@ use std::fmt;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::vec::Vec;
 
-use cmerkle::{self, Result as TrieResult, Trie, TrieDB, TrieMut};
+use cmerkle::{self, Result as TrieResult, Trie, TrieMut};
 
 use super::CacheableItem;
 
@@ -195,25 +195,25 @@ where
     /// Check caches for required data
     /// First searches for account in the local, then the shared cache.
     /// Populates local cache if nothing found.
-    pub fn get(&self, a: &Item::Address, db: &TrieDB) -> cmerkle::Result<Option<Item>> {
+    pub fn get(&self, a: &Item::Address, db: &dyn Trie) -> cmerkle::Result<Option<Item>> {
         // check local cache first
         if let Some(cached_item) = self.cache.borrow_mut().get_mut(a) {
             cached_item.touched = touched_count();
             return Ok(cached_item.item.clone())
         }
 
         // not found in the cache, get from the DB and insert into cache
-        let maybe_item = db.get_with(a.as_ref(), &|bytes| ::rlp::decode::<Item>(bytes).unwrap())?;
+        let maybe_item = db.get(a.as_ref())?.map(|bytes| ::rlp::decode::<Item>(&bytes).unwrap());
         self.insert(a, Entry::<Item>::new_clean(maybe_item.clone()));
         Ok(maybe_item)
     }
 
     /// Pull item `a` in our cache from the trie DB.
     /// If it doesn't exist, make item equal the evaluation of `default`.
-    pub fn get_mut(&self, a: &Item::Address, db: &TrieDB) -> cmerkle::Result<RefMut<Item>> {
+    pub fn get_mut(&self, a: &Item::Address, db: &dyn Trie) -> cmerkle::Result<RefMut<Item>> {
         let contains_key = self.cache.borrow().contains_key(a);
         if !contains_key {
-            let maybe_item = db.get_with(a.as_ref(), &|bytes| ::rlp::decode::<Item>(bytes).unwrap())?;
+            let maybe_item = db.get(a.as_ref())?.map(|bytes| ::rlp::decode::<Item>(&bytes).unwrap());
             self.insert(a, Entry::<Item>::new_clean(maybe_item));
         }
         self.note(a);

state/src/impls/shard_level.rs

@@ -670,7 +670,7 @@ impl<'db> ShardLevelState<'db> {
     fn get_asset_scheme_mut(&self, shard_id: ShardId, asset_type: H160) -> cmerkle::Result<RefMut<AssetScheme>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.cache.asset_scheme_mut(&AssetSchemeAddress::new(asset_type, shard_id), &trie)
+        self.cache.asset_scheme_mut(&AssetSchemeAddress::new(asset_type, shard_id), &*trie)
     }
 
     pub fn create_asset(
@@ -697,13 +697,13 @@ impl<'db> ShardStateView for ShardLevelState<'db> {
     fn asset_scheme(&self, asset_type: H160) -> cmerkle::Result<Option<AssetScheme>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.cache.asset_scheme(&AssetSchemeAddress::new(asset_type, self.shard_id), &trie)
+        self.cache.asset_scheme(&AssetSchemeAddress::new(asset_type, self.shard_id), &*trie)
     }
 
     fn asset(&self, tracker: Tracker, index: usize) -> Result<Option<OwnedAsset>, TrieError> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.cache.asset(&OwnedAssetAddress::new(tracker, index, self.shard_id), &trie)
+        self.cache.asset(&OwnedAssetAddress::new(tracker, index, self.shard_id), &*trie)
     }
 }
 
@@ -780,13 +780,13 @@ impl<'db> ShardStateView for ReadOnlyShardLevelState<'db> {
     fn asset_scheme(&self, asset_type: H160) -> cmerkle::Result<Option<AssetScheme>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.cache.asset_scheme(&AssetSchemeAddress::new(asset_type, self.shard_id), &trie)
+        self.cache.asset_scheme(&AssetSchemeAddress::new(asset_type, self.shard_id), &*trie)
     }
 
     fn asset(&self, tracker: Tracker, index: usize) -> Result<Option<OwnedAsset>, TrieError> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.cache.asset(&OwnedAssetAddress::new(tracker, index, self.shard_id), &trie)
+        self.cache.asset(&OwnedAssetAddress::new(tracker, index, self.shard_id), &*trie)
     }
 }
 

state/src/impls/top_level.rs

@@ -105,28 +105,28 @@ impl TopStateView for TopLevelState {
     fn account(&self, a: &Address) -> TrieResult<Option<Account>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.top_cache.account(&a, &trie)
+        self.top_cache.account(&a, &*trie)
     }
 
     fn regular_account_by_address(&self, a: &Address) -> TrieResult<Option<RegularAccount>> {
         let a = RegularAccountAddress::from_address(a);
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        Ok(self.top_cache.regular_account(&a, &trie)?)
+        Ok(self.top_cache.regular_account(&a, &*trie)?)
     }
 
     fn metadata(&self) -> TrieResult<Option<Metadata>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
         let address = MetadataAddress::new();
-        self.top_cache.metadata(&address, &trie)
+        self.top_cache.metadata(&address, &*trie)
     }
 
     fn shard(&self, shard_id: ShardId) -> TrieResult<Option<Shard>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
         let shard_address = ShardAddress::new(shard_id);
-        self.top_cache.shard(&shard_address, &trie)
+        self.top_cache.shard(&shard_address, &*trie)
     }
 
     fn shard_state<'db>(&'db self, shard_id: ShardId) -> TrieResult<Option<Box<dyn ShardStateView + 'db>>> {
@@ -143,13 +143,13 @@ impl TopStateView for TopLevelState {
     fn text(&self, key: &H256) -> TrieResult<Option<Text>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        Ok(self.top_cache.text(key, &trie)?.map(Into::into))
+        Ok(self.top_cache.text(key, &*trie)?.map(Into::into))
     }
 
     fn action_data(&self, key: &H256) -> TrieResult<Option<ActionData>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        Ok(self.top_cache.action_data(key, &trie)?.map(Into::into))
+        Ok(self.top_cache.action_data(key, &*trie)?.map(Into::into))
     }
 }
 
@@ -636,46 +636,46 @@ impl TopLevelState {
 
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.top_cache.account_mut(&a, &trie)
+        self.top_cache.account_mut(&a, &*trie)
     }
 
     fn get_regular_account_mut(&self, public: &Public) -> TrieResult<RefMut<RegularAccount>> {
         let regular_account_address = RegularAccountAddress::new(public);
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.top_cache.regular_account_mut(&regular_account_address, &trie)
+        self.top_cache.regular_account_mut(&regular_account_address, &*trie)
     }
 
     fn get_metadata_mut(&self) -> TrieResult<RefMut<Metadata>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
         let address = MetadataAddress::new();
-        self.top_cache.metadata_mut(&address, &trie)
+        self.top_cache.metadata_mut(&address, &*trie)
     }
 
     fn get_shard_mut(&self, shard_id: ShardId) -> TrieResult<RefMut<Shard>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
         let shard_address = ShardAddress::new(shard_id);
-        self.top_cache.shard_mut(&shard_address, &trie)
+        self.top_cache.shard_mut(&shard_address, &*trie)
     }
 
     fn get_text(&self, key: &TxHash) -> TrieResult<Option<Text>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.top_cache.text(key, &trie)
+        self.top_cache.text(key, &*trie)
     }
 
     fn get_text_mut(&self, key: &TxHash) -> TrieResult<RefMut<Text>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.top_cache.text_mut(key, &trie)
+        self.top_cache.text_mut(key, &*trie)
     }
 
     fn get_action_data_mut(&self, key: &H256) -> TrieResult<RefMut<ActionData>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
-        self.top_cache.action_data_mut(key, &trie)
+        self.top_cache.action_data_mut(key, &*trie)
     }
 
     pub fn journal_under(&self, batch: &mut DBTransaction, now: u64) -> Result<u32, UtilError> {

util/merkle/src/lib.rs

@@ -65,9 +65,6 @@ impl fmt::Display for TrieError {
 
 pub type Result<T> = ::std::result::Result<T, TrieError>;
 
-/// Description of what kind of query will be made to the trie.
-pub type Query<T> = dyn Fn(&[u8]) -> T;
-
 /// A key-value datastore implemented as a database-backed Merkle trie.
 pub trait Trie {
     /// Return the root of the trie.
@@ -84,13 +81,7 @@ pub trait Trie {
     }
 
     /// What is the value of the given key in this trie?
-    fn get(&self, key: &[u8]) -> Result<Option<DBValue>> {
-        self.get_with(key, &|bytes| bytes.to_vec())
-    }
-
-    /// Search for the key with the given query parameter. See the docs of the `Query`
-    /// trait for more details.
-    fn get_with<T>(&self, key: &[u8], query: &Query<T>) -> Result<Option<T>>;
+    fn get(&self, key: &[u8]) -> Result<Option<DBValue>>;
 }
 
 /// A key-value datastore implemented as a database-backed Merkle trie.
@@ -122,8 +113,8 @@ pub enum TrieFactory {}
 
 impl TrieFactory {
     /// Create new immutable instance of Trie.
-    pub fn readonly<'db>(db: &'db dyn HashDB, root: &'db H256) -> Result<TrieDB<'db>> {
-        Ok(TrieDB::try_new(db, root)?)
+    pub fn readonly<'db>(db: &'db dyn HashDB, root: &'db H256) -> Result<Box<dyn Trie + 'db>> {
+        Ok(Box::new(TrieDB::try_new(db, root)?))
     }
 
     /// Create new mutable instance of Trie.

util/merkle/src/triedb.rs

@@ -20,7 +20,7 @@ use primitives::H256;
 
 use crate::nibbleslice::NibbleSlice;
 use crate::node::Node as RlpNode;
-use crate::{Query, Trie, TrieError};
+use crate::{Trie, TrieError};
 /// A `Trie` implementation using a generic `HashDB` backing database.
 ///
 /// Use it as a `Trie` trait object. You can use `db()` to get the backing database object.
@@ -50,6 +50,9 @@ pub struct TrieDB<'db> {
     root: &'db H256,
 }
 
+/// Description of what kind of query will be made to the trie.
+type Query<T> = dyn Fn(&[u8]) -> T;
+
 impl<'db> TrieDB<'db> {
     /// Create a new trie with the backing database `db` and `root`
     /// Returns an error if `root` does not exist
@@ -112,11 +115,11 @@ impl<'db> Trie for TrieDB<'db> {
         self.root
     }
 
-    fn get_with<T>(&self, key: &[u8], query: &Query<T>) -> crate::Result<Option<T>> {
+    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, TrieError> {
         let path = blake256(key);
         let root = *self.root;
 
-        self.get_aux(&NibbleSlice::new(&path), Some(root), query)
+        self.get_aux(&NibbleSlice::new(&path), Some(root), &|bytes| bytes.to_vec())
     }
 }