refactor: remove useless helpers of CMasternodeMetaInfo

Author: knst

src/masternode/meta.cpp

@@ -10,6 +10,9 @@
 
 const std::string MasternodeMetaStore::SERIALIZATION_VERSION_STRING = "CMasternodeMetaMan-Version-5";
 
+static constexpr int MASTERNODE_MAX_FAILED_OUTBOUND_ATTEMPTS{5};
+static constexpr int MASTERNODE_MAX_MIXING_TXES{5};
+
 CMasternodeMetaMan::CMasternodeMetaMan() :
     m_db{std::make_unique<db_type>("mncache.dat", "magicMasternodeCache")}
 {
@@ -33,8 +36,8 @@ UniValue CMasternodeMetaInfo::ToJson() const
     int64_t now = GetTime<std::chrono::seconds>().count();
 
     UniValue ret(UniValue::VOBJ);
-    ret.pushKV("lastDSQ", nLastDsq);
-    ret.pushKV("mixingTxCount", nMixingTxCount);
+    ret.pushKV("lastDSQ", m_last_dsq);
+    ret.pushKV("mixingTxCount", m_mixing_tx_count);
     ret.pushKV("outboundAttemptCount", outboundAttemptCount);
     ret.pushKV("lastOutboundAttempt", lastOutboundAttempt);
     ret.pushKV("lastOutboundAttemptElapsed", now - lastOutboundAttempt);
@@ -87,7 +90,7 @@ bool CMasternodeMetaMan::IsDsqOver(const uint256& protx_hash, int mn_count) cons
         return false;
     }
     const auto& meta_info = it->second;
-    int64_t last_dsq = meta_info.GetLastDsq();
+    int64_t last_dsq = meta_info.m_last_dsq;
     int64_t threshold = last_dsq + mn_count / 5;
 
     LogPrint(BCLog::COINJOIN, "DSQUEUE -- mn: %s last_dsq: %d  dsq_threshold: %d  nDsqCount: %d\n",
@@ -100,15 +103,15 @@ void CMasternodeMetaMan::AllowMixing(const uint256& proTxHash)
     LOCK(cs);
     auto& mm = GetMetaInfo(proTxHash);
     nDsqCount++;
-    mm.nLastDsq = nDsqCount.load();
-    mm.nMixingTxCount = 0;
+    mm.m_last_dsq = nDsqCount.load();
+    mm.m_mixing_tx_count = 0;
 }
 
 void CMasternodeMetaMan::DisallowMixing(const uint256& proTxHash)
 {
     LOCK(cs);
     auto& mm = GetMetaInfo(proTxHash);
-    mm.nMixingTxCount++;
+    mm.m_mixing_tx_count++;
 }
 
 bool CMasternodeMetaMan::IsValidForMixingTxes(const uint256& protx_hash) const
@@ -118,7 +121,7 @@ bool CMasternodeMetaMan::IsValidForMixingTxes(const uint256& protx_hash) const
     auto it = metaInfos.find(protx_hash);
     if (it == metaInfos.end()) return true;
 
-    return it->second.IsValidForMixingTxes();
+    return it->second.m_mixing_tx_count <= MASTERNODE_MAX_MIXING_TXES;
 }
 
 bool CMasternodeMetaMan::AddGovernanceVote(const uint256& proTxHash, const uint256& nGovernanceObjectHash)
@@ -175,7 +178,7 @@ int64_t CMasternodeMetaMan::GetLastOutboundAttempt(const uint256& protx_hash) co
     auto it = metaInfos.find(protx_hash);
     if (it == metaInfos.end()) return 0;
 
-    return it->second.GetLastOutboundAttempt();
+    return it->second.lastOutboundAttempt;
 }
 
 int64_t CMasternodeMetaMan::GetLastOutboundSuccess(const uint256& protx_hash) const
@@ -185,7 +188,7 @@ int64_t CMasternodeMetaMan::GetLastOutboundSuccess(const uint256& protx_hash) co
     auto it = metaInfos.find(protx_hash);
     if (it == metaInfos.end()) return 0;
 
-    return it->second.GetLastOutboundSuccess();
+    return it->second.lastOutboundSuccess;
 }
 
 bool CMasternodeMetaMan::OutboundFailedTooManyTimes(const uint256& protx_hash) const
@@ -195,7 +198,7 @@ bool CMasternodeMetaMan::OutboundFailedTooManyTimes(const uint256& protx_hash) c
     auto it = metaInfos.find(protx_hash);
     if (it == metaInfos.end()) return false;
 
-    return it->second.OutboundFailedTooManyTimes();
+    return it->second.outboundAttemptCount > MASTERNODE_MAX_FAILED_OUTBOUND_ATTEMPTS;
 }
 
 bool CMasternodeMetaMan::IsPlatformBanned(const uint256& protx_hash) const
@@ -205,7 +208,7 @@ bool CMasternodeMetaMan::IsPlatformBanned(const uint256& protx_hash) const
     auto it = metaInfos.find(protx_hash);
     if (it == metaInfos.end()) return false;
 
-    return it->second.IsPlatformBanned();
+    return it->second.m_platform_ban;
 }
 
 bool CMasternodeMetaMan::ResetPlatformBan(const uint256& protx_hash, int height)

src/masternode/meta.h

@@ -25,19 +25,16 @@ class UniValue;
 template<typename T>
 class CFlatDB;
 
-static constexpr int MASTERNODE_MAX_MIXING_TXES{5};
-static constexpr int MASTERNODE_MAX_FAILED_OUTBOUND_ATTEMPTS{5};
-
 // Holds extra (non-deterministic) information about masternodes
 // This is mostly local information, e.g. about mixing and governance
 class CMasternodeMetaInfo
 {
 public:
-    uint256 proTxHash;
+    uint256 m_protx_hash;
 
     //the dsq count from the last dsq broadcast of this node
-    int64_t nLastDsq{0};
-    int nMixingTxCount{0};
+    int64_t m_last_dsq{0};
+    int m_mixing_tx_count{0};
 
     // KEEP TRACK OF GOVERNANCE ITEMS EACH MASTERNODE HAS VOTE UPON FOR RECALCULATION
     std::map<uint256, int> mapGovernanceObjectsVotedOn;
@@ -53,38 +50,29 @@ class CMasternodeMetaInfo
 
 public:
     CMasternodeMetaInfo() = default;
-    explicit CMasternodeMetaInfo(const uint256& _proTxHash) : proTxHash(_proTxHash) {}
+    explicit CMasternodeMetaInfo(const uint256& protx_hash) :
+        m_protx_hash(protx_hash)
+    {
+    }
     CMasternodeMetaInfo(const CMasternodeMetaInfo& ref) = default;
 
     SERIALIZE_METHODS(CMasternodeMetaInfo, obj)
     {
-        READWRITE(obj.proTxHash, obj.nLastDsq, obj.nMixingTxCount, obj.mapGovernanceObjectsVotedOn,
+        READWRITE(obj.m_protx_hash, obj.m_last_dsq, obj.m_mixing_tx_count, obj.mapGovernanceObjectsVotedOn,
                   obj.outboundAttemptCount, obj.lastOutboundAttempt, obj.lastOutboundSuccess, obj.m_platform_ban,
                   obj.m_platform_ban_updated);
     }
 
     UniValue ToJson() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
 public:
-    const uint256 GetProTxHash() const EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        return proTxHash;
-    }
-    int64_t GetLastDsq() const { return nLastDsq; }
-    int GetMixingTxCount() const { return nMixingTxCount; }
-
-    bool IsValidForMixingTxes() const { return GetMixingTxCount() <= MASTERNODE_MAX_MIXING_TXES; }
-
     // KEEP TRACK OF EACH GOVERNANCE ITEM IN CASE THIS NODE GOES OFFLINE, SO WE CAN RECALCULATE THEIR STATUS
     void AddGovernanceVote(const uint256& nGovernanceObjectHash) EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     void RemoveGovernanceObject(const uint256& nGovernanceObjectHash) EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
-    bool OutboundFailedTooManyTimes() const { return outboundAttemptCount > MASTERNODE_MAX_FAILED_OUTBOUND_ATTEMPTS; }
     void SetLastOutboundAttempt(int64_t t) { lastOutboundAttempt = t; ++outboundAttemptCount; }
-    int64_t GetLastOutboundAttempt() const { return lastOutboundAttempt; }
     void SetLastOutboundSuccess(int64_t t) { lastOutboundSuccess = t; outboundAttemptCount = 0; }
-    int64_t GetLastOutboundSuccess() const { return lastOutboundSuccess; }
     bool SetPlatformBan(bool is_banned, int height) EXCLUSIVE_LOCKS_REQUIRED(!cs)
     {
         if (height < m_platform_ban_updated) {
@@ -97,10 +85,6 @@ class CMasternodeMetaInfo
         m_platform_ban_updated = height;
         return true;
     }
-    bool IsPlatformBanned() const EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        return m_platform_ban;
-    }
 };
 
 class MasternodeMetaStore
@@ -146,7 +130,7 @@ class MasternodeMetaStore
         std::vector<uint256> tmpUsedMasternodes;
         s >> tmpMetaInfo >> nDsqCount >> tmpUsedMasternodes;
         for (auto& mm : tmpMetaInfo) {
-            metaInfos.emplace(mm.GetProTxHash(), CMasternodeMetaInfo{std::move(mm)});
+            metaInfos.emplace(mm.m_protx_hash, CMasternodeMetaInfo{std::move(mm)});
         }
 
         // Convert vector to deque and build unordered_set for O(1) lookups