Apply clang-format on some infrequently-updated files

1 files changed, 110 insertions, 115 deletions

diff --git a/src/addrman.cpp b/src/addrman.cpp
index 68948ac7ff..7b674a66e7 100644
--- a/src/addrman.cpp
+++ b/src/addrman.cpp
@@ -9,7 +9,7 @@
 
 using namespace std;
 
-int CAddrInfo::GetTriedBucket(const std::vector<unsigned char> &nKey) const
+int CAddrInfo::GetTriedBucket(const std::vector<unsigned char>& nKey) const
 {
     CDataStream ss1(SER_GETHASH, 0);
     std::vector<unsigned char> vchKey = GetKey();
@@ -23,7 +23,7 @@ int CAddrInfo::GetTriedBucket(const std::vector<unsigned char> &nKey) const
     return hash2 % ADDRMAN_TRIED_BUCKET_COUNT;
 }
 
-int CAddrInfo::GetNewBucket(const std::vector<unsigned char> &nKey, const CNetAddr& src) const
+int CAddrInfo::GetNewBucket(const std::vector<unsigned char>& nKey, const CNetAddr& src) const
 {
     CDataStream ss1(SER_GETHASH, 0);
     std::vector<unsigned char> vchGroupKey = GetGroup();
@@ -39,19 +39,19 @@ int CAddrInfo::GetNewBucket(const std::vector<unsigned char> &nKey, const CNetAd
 
 bool CAddrInfo::IsTerrible(int64_t nNow) const
 {
-    if (nLastTry && nLastTry >= nNow-60) // never remove things tried the last minute
+    if (nLastTry && nLastTry >= nNow - 60) // never remove things tried the last minute
         return false;
 
-    if (nTime > nNow + 10*60) // came in a flying DeLorean
+    if (nTime > nNow + 10 * 60) // came in a flying DeLorean
         return true;
 
-    if (nTime==0 || nNow-nTime > ADDRMAN_HORIZON_DAYS*24*60*60) // not seen in recent history
+    if (nTime == 0 || nNow - nTime > ADDRMAN_HORIZON_DAYS * 24 * 60 * 60) // not seen in recent history
         return true;
 
-    if (nLastSuccess==0 && nAttempts>=ADDRMAN_RETRIES) // tried N times and never a success
+    if (nLastSuccess == 0 && nAttempts >= ADDRMAN_RETRIES) // tried N times and never a success
         return true;
 
-    if (nNow-nLastSuccess > ADDRMAN_MIN_FAIL_DAYS*24*60*60 && nAttempts>=ADDRMAN_MAX_FAILURES) // N successive failures in the last week
+    if (nNow - nLastSuccess > ADDRMAN_MIN_FAIL_DAYS * 24 * 60 * 60 && nAttempts >= ADDRMAN_MAX_FAILURES) // N successive failures in the last week
         return true;
 
     return false;
@@ -64,23 +64,25 @@ double CAddrInfo::GetChance(int64_t nNow) const
     int64_t nSinceLastSeen = nNow - nTime;
     int64_t nSinceLastTry = nNow - nLastTry;
 
-    if (nSinceLastSeen < 0) nSinceLastSeen = 0;
-    if (nSinceLastTry < 0) nSinceLastTry = 0;
+    if (nSinceLastSeen < 0)
+        nSinceLastSeen = 0;
+    if (nSinceLastTry < 0)
+        nSinceLastTry = 0;
 
     fChance *= 600.0 / (600.0 + nSinceLastSeen);
 
     // deprioritize very recent attempts away
-    if (nSinceLastTry < 60*10)
+    if (nSinceLastTry < 60 * 10)
         fChance *= 0.01;
 
     // deprioritize 50% after each failed attempt
-    for (int n=0; n<nAttempts; n++)
+    for (int n = 0; n < nAttempts; n++)
         fChance /= 1.5;
 
     return fChance;
 }
 
-CAddrInfo* CAddrMan::Find(const CNetAddr& addr, int *pnId)
+CAddrInfo* CAddrMan::Find(const CNetAddr& addr, int* pnId)
 {
     std::map<CNetAddr, int>::iterator it = mapAddr.find(addr);
     if (it == mapAddr.end())
@@ -93,7 +95,7 @@ CAddrInfo* CAddrMan::Find(const CNetAddr& addr, int *pnId)
     return NULL;
 }
 
-CAddrInfo* CAddrMan::Create(const CAddress &addr, const CNetAddr &addrSource, int *pnId)
+CAddrInfo* CAddrMan::Create(const CAddress& addr, const CNetAddr& addrSource, int* pnId)
 {
     int nId = nIdCount++;
     mapInfo[nId] = CAddrInfo(addr, addrSource);
@@ -127,22 +129,21 @@ void CAddrMan::SwapRandom(unsigned int nRndPos1, unsigned int nRndPos2)
 
 int CAddrMan::SelectTried(int nKBucket)
 {
-    std::vector<int> &vTried = vvTried[nKBucket];
+    std::vector<int>& vTried = vvTried[nKBucket];
 
     // random shuffle the first few elements (using the entire list)
     // find the least recently tried among them
     int64_t nOldest = -1;
     int nOldestPos = -1;
-    for (unsigned int i = 0; i < ADDRMAN_TRIED_ENTRIES_INSPECT_ON_EVICT && i < vTried.size(); i++)
-    {
+    for (unsigned int i = 0; i < ADDRMAN_TRIED_ENTRIES_INSPECT_ON_EVICT && i < vTried.size(); i++) {
         int nPos = GetRandInt(vTried.size() - i) + i;
         int nTemp = vTried[nPos];
         vTried[nPos] = vTried[i];
         vTried[i] = nTemp;
         assert(nOldest == -1 || mapInfo.count(nTemp) == 1);
         if (nOldest == -1 || mapInfo[nTemp].nLastSuccess < mapInfo[nOldest].nLastSuccess) {
-           nOldest = nTemp;
-           nOldestPos = nPos;
+            nOldest = nTemp;
+            nOldestPos = nPos;
         }
     }
 
@@ -152,18 +153,15 @@ int CAddrMan::SelectTried(int nKBucket)
 int CAddrMan::ShrinkNew(int nUBucket)
 {
     assert(nUBucket >= 0 && (unsigned int)nUBucket < vvNew.size());
-    std::set<int> &vNew = vvNew[nUBucket];
+    std::set<int>& vNew = vvNew[nUBucket];
 
     // first look for deletable items
-    for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++)
-    {
+    for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++) {
         assert(mapInfo.count(*it));
-        CAddrInfo &info = mapInfo[*it];
-        if (info.IsTerrible())
-        {
-            if (--info.nRefCount == 0)
-            {
-                SwapRandom(info.nRandomPos, vRandom.size()-1);
+        CAddrInfo& info = mapInfo[*it];
+        if (info.IsTerrible()) {
+            if (--info.nRefCount == 0) {
+                SwapRandom(info.nRandomPos, vRandom.size() - 1);
                 vRandom.pop_back();
                 mapAddr.erase(info);
                 mapInfo.erase(*it);
@@ -178,10 +176,8 @@ int CAddrMan::ShrinkNew(int nUBucket)
     int n[4] = {GetRandInt(vNew.size()), GetRandInt(vNew.size()), GetRandInt(vNew.size()), GetRandInt(vNew.size())};
     int nI = 0;
     int nOldest = -1;
-    for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++)
-    {
-        if (nI == n[0] || nI == n[1] || nI == n[2] || nI == n[3])
-        {
+    for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++) {
+        if (nI == n[0] || nI == n[1] || nI == n[2] || nI == n[3]) {
             assert(nOldest == -1 || mapInfo.count(*it) == 1);
             if (nOldest == -1 || mapInfo[*it].nTime < mapInfo[nOldest].nTime)
                 nOldest = *it;
@@ -189,10 +185,9 @@ int CAddrMan::ShrinkNew(int nUBucket)
         nI++;
     }
     assert(mapInfo.count(nOldest) == 1);
-    CAddrInfo &info = mapInfo[nOldest];
-    if (--info.nRefCount == 0)
-    {
-        SwapRandom(info.nRandomPos, vRandom.size()-1);
+    CAddrInfo& info = mapInfo[nOldest];
+    if (--info.nRefCount == 0) {
+        SwapRandom(info.nRandomPos, vRandom.size() - 1);
         vRandom.pop_back();
         mapAddr.erase(info);
         mapInfo.erase(nOldest);
@@ -208,8 +203,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId, int nOrigin)
     assert(vvNew[nOrigin].count(nId) == 1);
 
     // remove the entry from all new buckets
-    for (std::vector<std::set<int> >::iterator it = vvNew.begin(); it != vvNew.end(); it++)
-    {
+    for (std::vector<std::set<int> >::iterator it = vvNew.begin(); it != vvNew.end(); it++) {
         if ((*it).erase(nId))
             info.nRefCount--;
     }
@@ -219,11 +213,10 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId, int nOrigin)
 
     // what tried bucket to move the entry to
     int nKBucket = info.GetTriedBucket(nKey);
-    std::vector<int> &vTried = vvTried[nKBucket];
+    std::vector<int>& vTried = vvTried[nKBucket];
 
     // first check whether there is place to just add it
-    if (vTried.size() < ADDRMAN_TRIED_BUCKET_SIZE)
-    {
+    if (vTried.size() < ADDRMAN_TRIED_BUCKET_SIZE) {
         vTried.push_back(nId);
         nTried++;
         info.fInTried = true;
@@ -236,7 +229,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId, int nOrigin)
     // find which new bucket it belongs to
     assert(mapInfo.count(vTried[nPos]) == 1);
     int nUBucket = mapInfo[vTried[nPos]].GetNewBucket(nKey);
-    std::set<int> &vNew = vvNew[nUBucket];
+    std::set<int>& vNew = vvNew[nUBucket];
 
     // remove the to-be-replaced tried entry from the tried set
     CAddrInfo& infoOld = mapInfo[vTried[nPos]];
@@ -245,8 +238,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId, int nOrigin)
     // do not update nTried, as we are going to move something else there immediately
 
     // check whether there is place in that one,
-    if (vNew.size() < ADDRMAN_NEW_BUCKET_SIZE)
-    {
+    if (vNew.size() < ADDRMAN_NEW_BUCKET_SIZE) {
         // if so, move it back there
         vNew.insert(vTried[nPos]);
     } else {
@@ -261,16 +253,16 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId, int nOrigin)
     return;
 }
 
-void CAddrMan::Good_(const CService &addr, int64_t nTime)
+void CAddrMan::Good_(const CService& addr, int64_t nTime)
 {
     int nId;
-    CAddrInfo *pinfo = Find(addr, &nId);
+    CAddrInfo* pinfo = Find(addr, &nId);
 
     // if not found, bail out
     if (!pinfo)
         return;
 
-    CAddrInfo &info = *pinfo;
+    CAddrInfo& info = *pinfo;
 
     // check whether we are talking about the exact same CService (including same port)
     if (info != addr)
@@ -289,12 +281,10 @@ void CAddrMan::Good_(const CService &addr, int64_t nTime)
     // find a bucket it is in now
     int nRnd = GetRandInt(vvNew.size());
     int nUBucket = -1;
-    for (unsigned int n = 0; n < vvNew.size(); n++)
-    {
-        int nB = (n+nRnd) % vvNew.size();
-        std::set<int> &vNew = vvNew[nB];
-        if (vNew.count(nId))
-        {
+    for (unsigned int n = 0; n < vvNew.size(); n++) {
+        int nB = (n + nRnd) % vvNew.size();
+        std::set<int>& vNew = vvNew[nB];
+        if (vNew.count(nId)) {
             nUBucket = nB;
             break;
         }
@@ -302,7 +292,8 @@ void CAddrMan::Good_(const CService &addr, int64_t nTime)
 
     // if no bucket is found, something bad happened;
     // TODO: maybe re-add the node, but for now, just bail out
-    if (nUBucket == -1) return;
+    if (nUBucket == -1)
+        return;
 
     LogPrint("addrman", "Moving %s to tried\n", addr.ToString());
 
@@ -310,17 +301,16 @@ void CAddrMan::Good_(const CService &addr, int64_t nTime)
     MakeTried(info, nId, nUBucket);
 }
 
-bool CAddrMan::Add_(const CAddress &addr, const CNetAddr& source, int64_t nTimePenalty)
+bool CAddrMan::Add_(const CAddress& addr, const CNetAddr& source, int64_t nTimePenalty)
 {
     if (!addr.IsRoutable())
         return false;
 
     bool fNew = false;
     int nId;
-    CAddrInfo *pinfo = Find(addr, &nId);
+    CAddrInfo* pinfo = Find(addr, &nId);
 
-    if (pinfo)
-    {
+    if (pinfo) {
         // periodically update nTime
         bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);
         int64_t nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);
@@ -344,7 +334,7 @@ bool CAddrMan::Add_(const CAddress &addr, const CNetAddr& source, int64_t nTimeP
 
         // stochastic test: previous nRefCount == N: 2^N times harder to increase it
         int nFactor = 1;
-        for (int n=0; n<pinfo->nRefCount; n++)
+        for (int n = 0; n < pinfo->nRefCount; n++)
             nFactor *= 2;
         if (nFactor > 1 && (GetRandInt(nFactor) != 0))
             return false;
@@ -356,9 +346,8 @@ bool CAddrMan::Add_(const CAddress &addr, const CNetAddr& source, int64_t nTimeP
     }
 
     int nUBucket = pinfo->GetNewBucket(nKey, source);
-    std::set<int> &vNew = vvNew[nUBucket];
-    if (!vNew.count(nId))
-    {
+    std::set<int>& vNew = vvNew[nUBucket];
+    if (!vNew.count(nId)) {
         pinfo->nRefCount++;
         if (vNew.size() == ADDRMAN_NEW_BUCKET_SIZE)
             ShrinkNew(nUBucket);
@@ -367,15 +356,15 @@ bool CAddrMan::Add_(const CAddress &addr, const CNetAddr& source, int64_t nTimeP
     return fNew;
 }
 
-void CAddrMan::Attempt_(const CService &addr, int64_t nTime)
+void CAddrMan::Attempt_(const CService& addr, int64_t nTime)
 {
-    CAddrInfo *pinfo = Find(addr);
+    CAddrInfo* pinfo = Find(addr);
 
     // if not found, bail out
     if (!pinfo)
         return;
 
-    CAddrInfo &info = *pinfo;
+    CAddrInfo& info = *pinfo;
 
     // check whether we are talking about the exact same CService (including same port)
     if (info != addr)
@@ -393,37 +382,36 @@ CAddress CAddrMan::Select_(int nUnkBias)
 
     double nCorTried = sqrt(nTried) * (100.0 - nUnkBias);
     double nCorNew = sqrt(nNew) * nUnkBias;
-    if ((nCorTried + nCorNew)*GetRandInt(1<<30)/(1<<30) < nCorTried)
-    {
+    if ((nCorTried + nCorNew) * GetRandInt(1 << 30) / (1 << 30) < nCorTried) {
         // use a tried node
         double fChanceFactor = 1.0;
-        while(1)
-        {
+        while (1) {
             int nKBucket = GetRandInt(vvTried.size());
-            std::vector<int> &vTried = vvTried[nKBucket];
-            if (vTried.size() == 0) continue;
+            std::vector<int>& vTried = vvTried[nKBucket];
+            if (vTried.size() == 0)
+                continue;
             int nPos = GetRandInt(vTried.size());
             assert(mapInfo.count(vTried[nPos]) == 1);
-            CAddrInfo &info = mapInfo[vTried[nPos]];
-            if (GetRandInt(1<<30) < fChanceFactor*info.GetChance()*(1<<30))
+            CAddrInfo& info = mapInfo[vTried[nPos]];
+            if (GetRandInt(1 << 30) < fChanceFactor * info.GetChance() * (1 << 30))
                 return info;
             fChanceFactor *= 1.2;
         }
     } else {
         // use a new node
         double fChanceFactor = 1.0;
-        while(1)
-        {
+        while (1) {
             int nUBucket = GetRandInt(vvNew.size());
-            std::set<int> &vNew = vvNew[nUBucket];
-            if (vNew.size() == 0) continue;
+            std::set<int>& vNew = vvNew[nUBucket];
+            if (vNew.size() == 0)
+                continue;
             int nPos = GetRandInt(vNew.size());
             std::set<int>::iterator it = vNew.begin();
             while (nPos--)
                 it++;
             assert(mapInfo.count(*it) == 1);
-            CAddrInfo &info = mapInfo[*it];
-            if (GetRandInt(1<<30) < fChanceFactor*info.GetChance()*(1<<30))
+            CAddrInfo& info = mapInfo[*it];
+            if (GetRandInt(1 << 30) < fChanceFactor * info.GetChance() * (1 << 30))
                 return info;
             fChanceFactor *= 1.2;
         }
@@ -436,69 +424,76 @@ int CAddrMan::Check_()
     std::set<int> setTried;
     std::map<int, int> mapNew;
 
-    if (vRandom.size() != nTried + nNew) return -7;
+    if (vRandom.size() != nTried + nNew)
+        return -7;
 
-    for (std::map<int, CAddrInfo>::iterator it = mapInfo.begin(); it != mapInfo.end(); it++)
-    {
+    for (std::map<int, CAddrInfo>::iterator it = mapInfo.begin(); it != mapInfo.end(); it++) {
         int n = (*it).first;
-        CAddrInfo &info = (*it).second;
-        if (info.fInTried)
-        {
-
-            if (!info.nLastSuccess) return -1;
-            if (info.nRefCount) return -2;
+        CAddrInfo& info = (*it).second;
+        if (info.fInTried) {
+            if (!info.nLastSuccess)
+                return -1;
+            if (info.nRefCount)
+                return -2;
             setTried.insert(n);
         } else {
-            if (info.nRefCount < 0 || info.nRefCount > ADDRMAN_NEW_BUCKETS_PER_ADDRESS) return -3;
-            if (!info.nRefCount) return -4;
+            if (info.nRefCount < 0 || info.nRefCount > ADDRMAN_NEW_BUCKETS_PER_ADDRESS)
+                return -3;
+            if (!info.nRefCount)
+                return -4;
             mapNew[n] = info.nRefCount;
         }
-        if (mapAddr[info] != n) return -5;
-        if (info.nRandomPos<0 || info.nRandomPos>=vRandom.size() || vRandom[info.nRandomPos] != n) return -14;
-        if (info.nLastTry < 0) return -6;
-        if (info.nLastSuccess < 0) return -8;
+        if (mapAddr[info] != n)
+            return -5;
+        if (info.nRandomPos < 0 || info.nRandomPos >= vRandom.size() || vRandom[info.nRandomPos] != n)
+            return -14;
+        if (info.nLastTry < 0)
+            return -6;
+        if (info.nLastSuccess < 0)
+            return -8;
     }
 
-    if (setTried.size() != nTried) return -9;
-    if (mapNew.size() != nNew) return -10;
+    if (setTried.size() != nTried)
+        return -9;
+    if (mapNew.size() != nNew)
+        return -10;
 
-    for (int n=0; n<vvTried.size(); n++)
-    {
-        std::vector<int> &vTried = vvTried[n];
-        for (std::vector<int>::iterator it = vTried.begin(); it != vTried.end(); it++)
-        {
-            if (!setTried.count(*it)) return -11;
+    for (int n = 0; n < vvTried.size(); n++) {
+        std::vector<int>& vTried = vvTried[n];
+        for (std::vector<int>::iterator it = vTried.begin(); it != vTried.end(); it++) {
+            if (!setTried.count(*it))
+                return -11;
             setTried.erase(*it);
         }
     }
 
-    for (int n=0; n<vvNew.size(); n++)
-    {
-        std::set<int> &vNew = vvNew[n];
-        for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++)
-        {
-            if (!mapNew.count(*it)) return -12;
+    for (int n = 0; n < vvNew.size(); n++) {
+        std::set<int>& vNew = vvNew[n];
+        for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++) {
+            if (!mapNew.count(*it))
+                return -12;
             if (--mapNew[*it] == 0)
                 mapNew.erase(*it);
         }
     }
 
-    if (setTried.size()) return -13;
-    if (mapNew.size()) return -15;
+    if (setTried.size())
+        return -13;
+    if (mapNew.size())
+        return -15;
 
     return 0;
 }
 #endif
 
-void CAddrMan::GetAddr_(std::vector<CAddress> &vAddr)
+void CAddrMan::GetAddr_(std::vector<CAddress>& vAddr)
 {
     unsigned int nNodes = ADDRMAN_GETADDR_MAX_PCT * vRandom.size() / 100;
     if (nNodes > ADDRMAN_GETADDR_MAX)
         nNodes = ADDRMAN_GETADDR_MAX;
 
     // gather a list of random nodes, skipping those of low quality
-    for (unsigned int n = 0; n < vRandom.size(); n++)
-    {
+    for (unsigned int n = 0; n < vRandom.size(); n++) {
         if (vAddr.size() >= nNodes)
             break;
 
@@ -512,15 +507,15 @@ void CAddrMan::GetAddr_(std::vector<CAddress> &vAddr)
     }
 }
 
-void CAddrMan::Connected_(const CService &addr, int64_t nTime)
+void CAddrMan::Connected_(const CService& addr, int64_t nTime)
 {
-    CAddrInfo *pinfo = Find(addr);
+    CAddrInfo* pinfo = Find(addr);
 
     // if not found, bail out
     if (!pinfo)
         return;
 
-    CAddrInfo &info = *pinfo;
+    CAddrInfo& info = *pinfo;
 
     // check whether we are talking about the exact same CService (including same port)
     if (info != addr)