From a389ed52e8f4939ab5b4adcf93dcb7783d9006f1 Mon Sep 17 00:00:00 2001
From: Andrew Chow <achow101-github@achow101.com>
Date: Mon, 15 Jun 2020 15:42:53 -0400
Subject: walletdb: refactor Read, Write, Erase, and Exists into non-template
 func

In order to override these later, the specific details of how the Read,
Write, Erase, and Exists functions interact with the actual database
file need to go into functions that are not templated.
---
 src/wallet/bdb.cpp | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/wallet/bdb.h   | 46 +++++++++++----------------------------
 2 files changed, 77 insertions(+), 33 deletions(-)

(limited to 'src/wallet')

diff --git a/src/wallet/bdb.cpp b/src/wallet/bdb.cpp
index 7ed9c88122..125bf004e4 100644
--- a/src/wallet/bdb.cpp
+++ b/src/wallet/bdb.cpp
@@ -803,3 +803,67 @@ std::string BerkeleyDatabaseVersion()
 {
     return DbEnv::version(nullptr, nullptr, nullptr);
 }
+
+bool BerkeleyBatch::ReadKey(CDataStream& key, CDataStream& value)
+{
+    if (!pdb)
+        return false;
+
+    // Key
+    SafeDbt datKey(key.data(), key.size());
+
+    // Read
+    SafeDbt datValue;
+    int ret = pdb->get(activeTxn, datKey, datValue, 0);
+    if (ret == 0 && datValue.get_data() != nullptr) {
+        value.write((char*)datValue.get_data(), datValue.get_size());
+        return true;
+    }
+    return false;
+}
+
+bool BerkeleyBatch::WriteKey(CDataStream& key, CDataStream& value, bool overwrite)
+{
+    if (!pdb)
+        return true;
+    if (fReadOnly)
+        assert(!"Write called on database in read-only mode");
+
+    // Key
+    SafeDbt datKey(key.data(), key.size());
+
+    // Value
+    SafeDbt datValue(value.data(), value.size());
+
+    // Write
+    int ret = pdb->put(activeTxn, datKey, datValue, (overwrite ? 0 : DB_NOOVERWRITE));
+    return (ret == 0);
+}
+
+bool BerkeleyBatch::EraseKey(CDataStream& key)
+{
+    if (!pdb)
+        return false;
+    if (fReadOnly)
+        assert(!"Erase called on database in read-only mode");
+
+    // Key
+    SafeDbt datKey(key.data(), key.size());
+
+    // Erase
+    int ret = pdb->del(activeTxn, datKey, 0);
+    return (ret == 0 || ret == DB_NOTFOUND);
+}
+
+bool BerkeleyBatch::HasKey(CDataStream& key)
+{
+    if (!pdb)
+        return false;
+
+    // Key
+    SafeDbt datKey(key.data(), key.size());
+
+    // Exists
+    int ret = pdb->exists(activeTxn, datKey, 0);
+    return ret == 0;
+}
diff --git a/src/wallet/bdb.h b/src/wallet/bdb.h
index 5ed364344b..1e717b95be 100644
--- a/src/wallet/bdb.h
+++ b/src/wallet/bdb.h
@@ -207,6 +207,12 @@ class BerkeleyBatch
         operator Dbt*();
     };
 
+private:
+    bool ReadKey(CDataStream& key, CDataStream& value);
+    bool WriteKey(CDataStream& key, CDataStream& value, bool overwrite=true);
+    bool EraseKey(CDataStream& key);
+    bool HasKey(CDataStream& key);
+
 protected:
     Db* pdb;
     std::string strFile;
@@ -236,91 +242,65 @@ public:
     template <typename K, typename T>
     bool Read(const K& key, T& value)
     {
-        if (!pdb)
-            return false;
-
         // Key
         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
         ssKey.reserve(1000);
         ssKey << key;
-        SafeDbt datKey(ssKey.data(), ssKey.size());
 
-        // Read
-        SafeDbt datValue;
-        int ret = pdb->get(activeTxn, datKey, datValue, 0);
+        CDataStream ssValue(SER_DISK, CLIENT_VERSION);
         bool success = false;
-        if (datValue.get_data() != nullptr) {
+        bool ret = ReadKey(ssKey, ssValue);
+        if (ret) {
             // Unserialize value
             try {
-                CDataStream ssValue((char*)datValue.get_data(), (char*)datValue.get_data() + datValue.get_size(), SER_DISK, CLIENT_VERSION);
                 ssValue >> value;
                 success = true;
             } catch (const std::exception&) {
                 // In this case success remains 'false'
             }
         }
-        return ret == 0 && success;
+        return ret && success;
     }
 
     template <typename K, typename T>
     bool Write(const K& key, const T& value, bool fOverwrite = true)
     {
-        if (!pdb)
-            return true;
-        if (fReadOnly)
-            assert(!"Write called on database in read-only mode");
-
         // Key
         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
         ssKey.reserve(1000);
         ssKey << key;
-        SafeDbt datKey(ssKey.data(), ssKey.size());
 
         // Value
         CDataStream ssValue(SER_DISK, CLIENT_VERSION);
         ssValue.reserve(10000);
         ssValue << value;
-        SafeDbt datValue(ssValue.data(), ssValue.size());
 
         // Write
-        int ret = pdb->put(activeTxn, datKey, datValue, (fOverwrite ? 0 : DB_NOOVERWRITE));
-        return (ret == 0);
+        return WriteKey(ssKey, ssValue, fOverwrite);
     }
 
     template <typename K>
     bool Erase(const K& key)
     {
-        if (!pdb)
-            return false;
-        if (fReadOnly)
-            assert(!"Erase called on database in read-only mode");
-
         // Key
         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
         ssKey.reserve(1000);
         ssKey << key;
-        SafeDbt datKey(ssKey.data(), ssKey.size());
 
         // Erase
-        int ret = pdb->del(activeTxn, datKey, 0);
-        return (ret == 0 || ret == DB_NOTFOUND);
+        return EraseKey(ssKey);
     }
 
     template <typename K>
     bool Exists(const K& key)
     {
-        if (!pdb)
-            return false;
-
         // Key
         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
         ssKey.reserve(1000);
         ssKey << key;
-        SafeDbt datKey(ssKey.data(), ssKey.size());
 
         // Exists
-        int ret = pdb->exists(activeTxn, datKey, 0);
-        return (ret == 0);
+        return HasKey(ssKey);
     }
 
     Dbc* GetCursor();
-- 
cgit v1.2.3