[move-only] Move CAddrMan function definitions to cpp

In preparation for introducing the pimpl pattern to addrman, move all function
bodies out of the header file.

Review hint: use git diff --color-moved=dimmed-zebra
--color-moved-ws=ignore-all-space

Author: amitiuttarwar

src/addrman.cpp

@@ -119,6 +119,11 @@ CAddrMan::CAddrMan(std::vector<bool> asmap, bool deterministic, int32_t consiste
     }
 }
 
+CAddrMan::~CAddrMan()
+{
+    nKey.SetNull();
+}
+
 template <typename Stream>
 void CAddrMan::Serialize(Stream& s_) const
 {
@@ -1017,3 +1022,97 @@ CAddrInfo CAddrMan::SelectTriedCollision_()
 
     return mapInfo[id_old];
 }
+
+size_t CAddrMan::size() const
+{
+    LOCK(cs); // TODO: Cache this in an atomic to avoid this overhead
+    return vRandom.size();
+}
+
+bool CAddrMan::Add(const std::vector<CAddress> &vAddr, const CNetAddr& source, int64_t nTimePenalty)
+{
+    LOCK(cs);
+    int nAdd = 0;
+    Check();
+    for (std::vector<CAddress>::const_iterator it = vAddr.begin(); it != vAddr.end(); it++)
+        nAdd += Add_(*it, source, nTimePenalty) ? 1 : 0;
+    Check();
+    if (nAdd) {
+        LogPrint(BCLog::ADDRMAN, "Added %i addresses from %s: %i tried, %i new\n", nAdd, source.ToString(), nTried, nNew);
+    }
+    return nAdd > 0;
+}
+
+void CAddrMan::Good(const CService &addr, int64_t nTime)
+{
+    LOCK(cs);
+    Check();
+    Good_(addr, /* test_before_evict */ true, nTime);
+    Check();
+}
+
+void CAddrMan::Attempt(const CService &addr, bool fCountFailure, int64_t nTime)
+{
+    LOCK(cs);
+    Check();
+    Attempt_(addr, fCountFailure, nTime);
+    Check();
+}
+
+
+void CAddrMan::ResolveCollisions()
+{
+    LOCK(cs);
+    Check();
+    ResolveCollisions_();
+    Check();
+}
+
+CAddrInfo CAddrMan::SelectTriedCollision()
+{
+    LOCK(cs);
+    Check();
+    const CAddrInfo ret = SelectTriedCollision_();
+    Check();
+    return ret;
+}
+
+CAddrInfo CAddrMan::Select(bool newOnly) const
+{
+    LOCK(cs);
+    Check();
+    const CAddrInfo addrRet = Select_(newOnly);
+    Check();
+    return addrRet;
+}
+
+std::vector<CAddress> CAddrMan::GetAddr(size_t max_addresses, size_t max_pct, std::optional<Network> network) const
+{
+    LOCK(cs);
+    Check();
+    std::vector<CAddress> vAddr;
+    GetAddr_(vAddr, max_addresses, max_pct, network);
+    Check();
+    return vAddr;
+}
+
+void CAddrMan::Connected(const CService &addr, int64_t nTime)
+{
+    LOCK(cs);
+    Check();
+    Connected_(addr, nTime);
+    Check();
+}
+
+void CAddrMan::SetServices(const CService &addr, ServiceFlags nServices)
+{
+    LOCK(cs);
+    Check();
+    SetServices_(addr, nServices);
+    Check();
+}
+
+const std::vector<bool>& CAddrMan::GetAsmap() const
+{
+    return m_asmap;
+}

src/addrman.h

@@ -150,88 +150,33 @@ class CAddrMan
 
     explicit CAddrMan(std::vector<bool> asmap, bool deterministic, int32_t consistency_check_ratio);
 
-    ~CAddrMan()
-    {
-        nKey.SetNull();
-    }
+    ~CAddrMan();
 
     //! Return the number of (unique) addresses in all tables.
-    size_t size() const
-        EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs); // TODO: Cache this in an atomic to avoid this overhead
-        return vRandom.size();
-    }
+    size_t size() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     //! Add addresses to addrman's new table.
     bool Add(const std::vector<CAddress> &vAddr, const CNetAddr& source, int64_t nTimePenalty = 0)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs);
-        int nAdd = 0;
-        Check();
-        for (std::vector<CAddress>::const_iterator it = vAddr.begin(); it != vAddr.end(); it++)
-            nAdd += Add_(*it, source, nTimePenalty) ? 1 : 0;
-        Check();
-        if (nAdd) {
-            LogPrint(BCLog::ADDRMAN, "Added %i addresses from %s: %i tried, %i new\n", nAdd, source.ToString(), nTried, nNew);
-        }
-        return nAdd > 0;
-    }
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     //! Mark an entry as accessible.
     void Good(const CService &addr, int64_t nTime = GetAdjustedTime())
-        EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs);
-        Check();
-        Good_(addr, /* test_before_evict */ true, nTime);
-        Check();
-    }
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     //! Mark an entry as connection attempted to.
     void Attempt(const CService &addr, bool fCountFailure, int64_t nTime = GetAdjustedTime())
-        EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs);
-        Check();
-        Attempt_(addr, fCountFailure, nTime);
-        Check();
-    }
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     //! See if any to-be-evicted tried table entries have been tested and if so resolve the collisions.
-    void ResolveCollisions()
-        EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs);
-        Check();
-        ResolveCollisions_();
-        Check();
-    }
+    void ResolveCollisions() EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     //! Randomly select an address in tried that another address is attempting to evict.
-    CAddrInfo SelectTriedCollision()
-        EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs);
-        Check();
-        const CAddrInfo ret = SelectTriedCollision_();
-        Check();
-        return ret;
-    }
+    CAddrInfo SelectTriedCollision() EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     /**
      * Choose an address to connect to.
      */
-    CAddrInfo Select(bool newOnly = false) const
-        EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs);
-        Check();
-        const CAddrInfo addrRet = Select_(newOnly);
-        Check();
-        return addrRet;
-    }
+    CAddrInfo Select(bool newOnly = false) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     /**
      * Return all or many randomly selected addresses, optionally by network.
@@ -241,36 +186,16 @@ class CAddrMan
      * @param[in] network        Select only addresses of this network (nullopt = all).
      */
     std::vector<CAddress> GetAddr(size_t max_addresses, size_t max_pct, std::optional<Network> network) const
-        EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs);
-        Check();
-        std::vector<CAddress> vAddr;
-        GetAddr_(vAddr, max_addresses, max_pct, network);
-        Check();
-        return vAddr;
-    }
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     //! Outer function for Connected_()
     void Connected(const CService &addr, int64_t nTime = GetAdjustedTime())
-        EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs);
-        Check();
-        Connected_(addr, nTime);
-        Check();
-    }
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     void SetServices(const CService &addr, ServiceFlags nServices)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs);
-        Check();
-        SetServices_(addr, nServices);
-        Check();
-    }
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
-    const std::vector<bool>& GetAsmap() const { return m_asmap; }
+    const std::vector<bool>& GetAsmap() const;
 
 private:
     //! A mutex to protect the inner data structures.