[style] Run changed files through clang formatter.

amitiuttarwar · amitiuttarwar · commit 021f86953e8a · 2021-09-28T22:21:10.000-04:00
diff --git a/src/addrman.cpp b/src/addrman.cpp
@@ -41,7 +41,7 @@ static constexpr size_t ADDRMAN_SET_TRIED_COLLISION_SIZE{10};
 /** The maximum time we'll spend trying to resolve a tried table collision, in seconds */
 static constexpr int64_t ADDRMAN_TEST_WINDOW{40*60}; // 40 minutes
 
-int AddrInfo::GetTriedBucket(const uint256& nKey, const std::vector<bool> &asmap) const
+int AddrInfo::GetTriedBucket(const uint256& nKey, const std::vector<bool>& asmap) const
 {
     uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << GetKey()).GetCheapHash();
     uint64_t hash2 = (CHashWriter(SER_GETHASH, 0) << nKey << GetGroup(asmap) << (hash1 % ADDRMAN_TRIED_BUCKETS_PER_GROUP)).GetCheapHash();
@@ -51,7 +51,7 @@ int AddrInfo::GetTriedBucket(const uint256& nKey, const std::vector<bool> &asmap
     return tried_bucket;
 }
 
-int AddrInfo::GetNewBucket(const uint256& nKey, const CNetAddr& src, const std::vector<bool> &asmap) const
+int AddrInfo::GetNewBucket(const uint256& nKey, const CNetAddr& src, const std::vector<bool>& asmap) const
 {
     std::vector<unsigned char> vchSourceGroupKey = src.GetGroup(asmap);
     uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << GetGroup(asmap) << vchSourceGroupKey).GetCheapHash();
@@ -62,7 +62,7 @@ int AddrInfo::GetNewBucket(const uint256& nKey, const CNetAddr& src, const std::
     return new_bucket;
 }
 
-int AddrInfo::GetBucketPosition(const uint256 &nKey, bool fNew, int nBucket) const
+int AddrInfo::GetBucketPosition(const uint256& nKey, bool fNew, int nBucket) const
 {
     uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << (fNew ? uint8_t{'N'} : uint8_t{'K'}) << nBucket << GetKey()).GetCheapHash();
     return hash1 % ADDRMAN_BUCKET_SIZE;
@@ -190,7 +190,7 @@ void AddrManImpl::Serialize(Stream& s_) const
     int nIds = 0;
     for (const auto& entry : mapInfo) {
         mapUnkIds[entry.first] = nIds;
-        const AddrInfo &info = entry.second;
+        const AddrInfo& info = entry.second;
         if (info.nRefCount) {
             assert(nIds != nNew); // this means nNew was wrong, oh ow
             s << info;
@@ -199,7 +199,7 @@ void AddrManImpl::Serialize(Stream& s_) const
     }
     nIds = 0;
     for (const auto& entry : mapInfo) {
-        const AddrInfo &info = entry.second;
+        const AddrInfo& info = entry.second;
         if (info.fInTried) {
             assert(nIds != nTried); // this means nTried was wrong, oh ow
             s << info;
@@ -283,7 +283,7 @@ void AddrManImpl::Unserialize(Stream& s_)
 
     // Deserialize entries from the new table.
     for (int n = 0; n < nNew; n++) {
-        AddrInfo &info = mapInfo[n];
+        AddrInfo& info = mapInfo[n];
         s >> info;
         mapAddr[info] = n;
         info.nRandomPos = vRandom.size();
@@ -1024,7 +1024,7 @@ size_t AddrManImpl::size() const
     return vRandom.size();
 }
 
-bool AddrManImpl::Add(const std::vector<CAddress> &vAddr, const CNetAddr& source, int64_t nTimePenalty)
+bool AddrManImpl::Add(const std::vector<CAddress>& vAddr, const CNetAddr& source, int64_t nTimePenalty)
 {
     LOCK(cs);
     int nAdd = 0;
@@ -1038,15 +1038,15 @@ bool AddrManImpl::Add(const std::vector<CAddress> &vAddr, const CNetAddr& source
     return nAdd > 0;
 }
 
-void AddrManImpl::Good(const CService &addr, int64_t nTime)
+void AddrManImpl::Good(const CService& addr, int64_t nTime)
 {
     LOCK(cs);
     Check();
     Good_(addr, /* test_before_evict */ true, nTime);
     Check();
 }
 
-void AddrManImpl::Attempt(const CService &addr, bool fCountFailure, int64_t nTime)
+void AddrManImpl::Attempt(const CService& addr, bool fCountFailure, int64_t nTime)
 {
     LOCK(cs);
     Check();
@@ -1089,15 +1089,15 @@ std::vector<CAddress> AddrManImpl::GetAddr(size_t max_addresses, size_t max_pct,
     return addresses;
 }
 
-void AddrManImpl::Connected(const CService &addr, int64_t nTime)
+void AddrManImpl::Connected(const CService& addr, int64_t nTime)
 {
     LOCK(cs);
     Check();
     Connected_(addr, nTime);
     Check();
 }
 
-void AddrManImpl::SetServices(const CService &addr, ServiceFlags nServices)
+void AddrManImpl::SetServices(const CService& addr, ServiceFlags nServices)
 {
     LOCK(cs);
     Check();
@@ -1141,17 +1141,17 @@ size_t AddrMan::size() const
     return m_impl->size();
 }
 
-bool AddrMan::Add(const std::vector<CAddress> &vAddr, const CNetAddr& source, int64_t nTimePenalty)
+bool AddrMan::Add(const std::vector<CAddress>& vAddr, const CNetAddr& source, int64_t nTimePenalty)
 {
     return m_impl->Add(vAddr, source, nTimePenalty);
 }
 
-void AddrMan::Good(const CService &addr, int64_t nTime)
+void AddrMan::Good(const CService& addr, int64_t nTime)
 {
     m_impl->Good(addr, nTime);
 }
 
-void AddrMan::Attempt(const CService &addr, bool fCountFailure, int64_t nTime)
+void AddrMan::Attempt(const CService& addr, bool fCountFailure, int64_t nTime)
 {
     m_impl->Attempt(addr, fCountFailure, nTime);
 }
@@ -1176,12 +1176,12 @@ std::vector<CAddress> AddrMan::GetAddr(size_t max_addresses, size_t max_pct, std
     return m_impl->GetAddr(max_addresses, max_pct, network);
 }
 
-void AddrMan::Connected(const CService &addr, int64_t nTime)
+void AddrMan::Connected(const CService& addr, int64_t nTime)
 {
     m_impl->Connected(addr, nTime);
 }
 
-void AddrMan::SetServices(const CService &addr, ServiceFlags nServices)
+void AddrMan::SetServices(const CService& addr, ServiceFlags nServices)
 {
     m_impl->SetServices(addr, nServices);
 }
diff --git a/src/addrman.h b/src/addrman.h
@@ -70,13 +70,13 @@ class AddrMan
     size_t size() const;
 
     //! Add addresses to addrman's new table.
-    bool Add(const std::vector<CAddress> &vAddr, const CNetAddr& source, int64_t nTimePenalty = 0);
+    bool Add(const std::vector<CAddress>& vAddr, const CNetAddr& source, int64_t nTimePenalty = 0);
 
     //! Mark an entry as accessible, possibly moving it from "new" to "tried".
-    void Good(const CService &addr, int64_t nTime = GetAdjustedTime());
+    void Good(const CService& addr, int64_t nTime = GetAdjustedTime());
 
     //! Mark an entry as connection attempted to.
-    void Attempt(const CService &addr, bool fCountFailure, int64_t nTime = GetAdjustedTime());
+    void Attempt(const CService& addr, bool fCountFailure, int64_t nTime = GetAdjustedTime());
 
     //! See if any to-be-evicted tried table entries have been tested and if so resolve the collisions.
     void ResolveCollisions();
@@ -121,10 +121,10 @@ class AddrMan
      * @param[in]   addr     The address of the peer we were connected to
      * @param[in]   nTime    The time that we were last connected to this peer
      */
-    void Connected(const CService &addr, int64_t nTime = GetAdjustedTime());
+    void Connected(const CService& addr, int64_t nTime = GetAdjustedTime());
 
     //! Update an entry's service bits.
-    void SetServices(const CService &addr, ServiceFlags nServices);
+    void SetServices(const CService& addr, ServiceFlags nServices);
 
     const std::vector<bool>& GetAsmap() const;
 
diff --git a/src/addrman_impl.h b/src/addrman_impl.h
@@ -111,29 +111,29 @@ class AddrManImpl
 
     size_t size() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
-    bool Add(const std::vector<CAddress> &vAddr, const CNetAddr& source, int64_t nTimePenalty)
+    bool Add(const std::vector<CAddress>& vAddr, const CNetAddr& source, int64_t nTimePenalty)
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
-    void Good(const CService &addr, int64_t nTime)
+    void Good(const CService& addr, int64_t nTime)
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
-    void Attempt(const CService &addr, bool fCountFailure, int64_t nTime)
+    void Attempt(const CService& addr, bool fCountFailure, int64_t nTime)
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     void ResolveCollisions() EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     std::pair<CAddress, int64_t> SelectTriedCollision() EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
-    std::pair<CAddress, int64_t>  Select(bool newOnly) const
+    std::pair<CAddress, int64_t> Select(bool newOnly) const
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     std::vector<CAddress> GetAddr(size_t max_addresses, size_t max_pct, std::optional<Network> network) const
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
-    void Connected(const CService &addr, int64_t nTime)
+    void Connected(const CService& addr, int64_t nTime)
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
-    void SetServices(const CService &addr, ServiceFlags nServices)
+    void SetServices(const CService& addr, ServiceFlags nServices)
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     const std::vector<bool>& GetAsmap() const;
@@ -225,10 +225,10 @@ class AddrManImpl
     const std::vector<bool> m_asmap;
 
     //! Find an entry.
-    AddrInfo* Find(const CNetAddr& addr, int *pnId = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);
+    AddrInfo* Find(const CNetAddr& addr, int* pnId = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     //! Create a new entry and add it to the internal data structures mapInfo, mapAddr and vRandom.
-    AddrInfo* Create(const CAddress &addr, const CNetAddr &addrSource, int *pnId = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);
+    AddrInfo* Create(const CAddress& addr, const CNetAddr& addrSource, int* pnId = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     //! Swap two elements in vRandom.
     void SwapRandom(unsigned int nRandomPos1, unsigned int nRandomPos2) const EXCLUSIVE_LOCKS_REQUIRED(cs);
@@ -242,19 +242,19 @@ class AddrManImpl
     //! Move an entry from the "new" table(s) to the "tried" table
     void MakeTried(AddrInfo& info, int nId) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    void Good_(const CService &addr, bool test_before_evict, int64_t time) EXCLUSIVE_LOCKS_REQUIRED(cs);
+    void Good_(const CService& addr, bool test_before_evict, int64_t time) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    bool Add_(const CAddress &addr, const CNetAddr& source, int64_t nTimePenalty) EXCLUSIVE_LOCKS_REQUIRED(cs);
+    bool Add_(const CAddress& addr, const CNetAddr& source, int64_t nTimePenalty) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    void Attempt_(const CService &addr, bool fCountFailure, int64_t nTime) EXCLUSIVE_LOCKS_REQUIRED(cs);
+    void Attempt_(const CService& addr, bool fCountFailure, int64_t nTime) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     std::pair<CAddress, int64_t> Select_(bool newOnly) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     std::vector<CAddress> GetAddr_(size_t max_addresses, size_t max_pct, std::optional<Network> network) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     void Connected_(const CService& addr, int64_t nTime) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    void SetServices_(const CService &addr, ServiceFlags nServices) EXCLUSIVE_LOCKS_REQUIRED(cs);
+    void SetServices_(const CService& addr, ServiceFlags nServices) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     void ResolveCollisions_() EXCLUSIVE_LOCKS_REQUIRED(cs);
 
diff --git a/src/test/addrman_tests.cpp b/src/test/addrman_tests.cpp
@@ -83,7 +83,7 @@ class AddrManTest : public AddrMan
     bool deterministic;
 public:
     explicit AddrManTest(bool makeDeterministic = true,
-                          std::vector<bool> asmap = std::vector<bool>())
+                         std::vector<bool> asmap = std::vector<bool>())
         : AddrMan(asmap, makeDeterministic, /* consistency_check_ratio */ 100)
     {
         deterministic = makeDeterministic;

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ static constexpr size_t ADDRMAN_SET_TRIED_COLLISION_SIZE{10};`
`41`	`41`	`/** The maximum time we'll spend trying to resolve a tried table collision, in seconds */`
`42`	`42`	`static constexpr int64_t ADDRMAN_TEST_WINDOW{40*60}; // 40 minutes`
`43`	`43`
`44`		`-int AddrInfo::GetTriedBucket(const uint256& nKey, const std::vector<bool> &asmap) const`
	`44`	`+int AddrInfo::GetTriedBucket(const uint256& nKey, const std::vector<bool>& asmap) const`
`45`	`45`	`{`
`46`	`46`	`uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << GetKey()).GetCheapHash();`
`47`	`47`	`uint64_t hash2 = (CHashWriter(SER_GETHASH, 0) << nKey << GetGroup(asmap) << (hash1 % ADDRMAN_TRIED_BUCKETS_PER_GROUP)).GetCheapHash();`
`@@ -51,7 +51,7 @@ int AddrInfo::GetTriedBucket(const uint256& nKey, const std::vector<bool> &asmap`
`51`	`51`	`return tried_bucket;`
`52`	`52`	`}`
`53`	`53`
`54`		`-int AddrInfo::GetNewBucket(const uint256& nKey, const CNetAddr& src, const std::vector<bool> &asmap) const`
	`54`	`+int AddrInfo::GetNewBucket(const uint256& nKey, const CNetAddr& src, const std::vector<bool>& asmap) const`
`55`	`55`	`{`
`56`	`56`	`std::vector<unsigned char> vchSourceGroupKey = src.GetGroup(asmap);`
`57`	`57`	`uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << GetGroup(asmap) << vchSourceGroupKey).GetCheapHash();`
`@@ -62,7 +62,7 @@ int AddrInfo::GetNewBucket(const uint256& nKey, const CNetAddr& src, const std::`
`62`	`62`	`return new_bucket;`
`63`	`63`	`}`
`64`	`64`
`65`		`-int AddrInfo::GetBucketPosition(const uint256 &nKey, bool fNew, int nBucket) const`
	`65`	`+int AddrInfo::GetBucketPosition(const uint256& nKey, bool fNew, int nBucket) const`
`66`	`66`	`{`
`67`	`67`	`uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << (fNew ? uint8_t{'N'} : uint8_t{'K'}) << nBucket << GetKey()).GetCheapHash();`
`68`	`68`	`return hash1 % ADDRMAN_BUCKET_SIZE;`
`@@ -190,7 +190,7 @@ void AddrManImpl::Serialize(Stream& s_) const`
`190`	`190`	`int nIds = 0;`
`191`	`191`	`for (const auto& entry : mapInfo) {`
`192`	`192`	`mapUnkIds[entry.first] = nIds;`
`193`		`- const AddrInfo &info = entry.second;`
	`193`	`+ const AddrInfo& info = entry.second;`
`194`	`194`	`if (info.nRefCount) {`
`195`	`195`	`assert(nIds != nNew); // this means nNew was wrong, oh ow`
`196`	`196`	`s << info;`
`@@ -199,7 +199,7 @@ void AddrManImpl::Serialize(Stream& s_) const`
`199`	`199`	`}`
`200`	`200`	`nIds = 0;`
`201`	`201`	`for (const auto& entry : mapInfo) {`
`202`		`- const AddrInfo &info = entry.second;`
	`202`	`+ const AddrInfo& info = entry.second;`
`203`	`203`	`if (info.fInTried) {`
`204`	`204`	`assert(nIds != nTried); // this means nTried was wrong, oh ow`
`205`	`205`	`s << info;`
`@@ -283,7 +283,7 @@ void AddrManImpl::Unserialize(Stream& s_)`
`283`	`283`
`284`	`284`	`// Deserialize entries from the new table.`
`285`	`285`	`for (int n = 0; n < nNew; n++) {`
`286`		`- AddrInfo &info = mapInfo[n];`
	`286`	`+ AddrInfo& info = mapInfo[n];`
`287`	`287`	`s >> info;`
`288`	`288`	`mapAddr[info] = n;`
`289`	`289`	`info.nRandomPos = vRandom.size();`
`@@ -1024,7 +1024,7 @@ size_t AddrManImpl::size() const`
`1024`	`1024`	`return vRandom.size();`
`1025`	`1025`	`}`
`1026`	`1026`
`1027`		`-bool AddrManImpl::Add(const std::vector<CAddress> &vAddr, const CNetAddr& source, int64_t nTimePenalty)`
	`1027`	`+bool AddrManImpl::Add(const std::vector<CAddress>& vAddr, const CNetAddr& source, int64_t nTimePenalty)`
`1028`	`1028`	`{`
`1029`	`1029`	`LOCK(cs);`
`1030`	`1030`	`int nAdd = 0;`
`@@ -1038,15 +1038,15 @@ bool AddrManImpl::Add(const std::vector<CAddress> &vAddr, const CNetAddr& source`
`1038`	`1038`	`return nAdd > 0;`
`1039`	`1039`	`}`
`1040`	`1040`
`1041`		`-void AddrManImpl::Good(const CService &addr, int64_t nTime)`
	`1041`	`+void AddrManImpl::Good(const CService& addr, int64_t nTime)`
`1042`	`1042`	`{`
`1043`	`1043`	`LOCK(cs);`
`1044`	`1044`	`Check();`
`1045`	`1045`	`Good_(addr, /* test_before_evict */ true, nTime);`
`1046`	`1046`	`Check();`
`1047`	`1047`	`}`
`1048`	`1048`
`1049`		`-void AddrManImpl::Attempt(const CService &addr, bool fCountFailure, int64_t nTime)`
	`1049`	`+void AddrManImpl::Attempt(const CService& addr, bool fCountFailure, int64_t nTime)`
`1050`	`1050`	`{`
`1051`	`1051`	`LOCK(cs);`
`1052`	`1052`	`Check();`
`@@ -1089,15 +1089,15 @@ std::vector<CAddress> AddrManImpl::GetAddr(size_t max_addresses, size_t max_pct,`
`1089`	`1089`	`return addresses;`
`1090`	`1090`	`}`
`1091`	`1091`
`1092`		`-void AddrManImpl::Connected(const CService &addr, int64_t nTime)`
	`1092`	`+void AddrManImpl::Connected(const CService& addr, int64_t nTime)`
`1093`	`1093`	`{`
`1094`	`1094`	`LOCK(cs);`
`1095`	`1095`	`Check();`
`1096`	`1096`	`Connected_(addr, nTime);`
`1097`	`1097`	`Check();`
`1098`	`1098`	`}`
`1099`	`1099`
`1100`		`-void AddrManImpl::SetServices(const CService &addr, ServiceFlags nServices)`
	`1100`	`+void AddrManImpl::SetServices(const CService& addr, ServiceFlags nServices)`
`1101`	`1101`	`{`
`1102`	`1102`	`LOCK(cs);`
`1103`	`1103`	`Check();`
`@@ -1141,17 +1141,17 @@ size_t AddrMan::size() const`
`1141`	`1141`	`return m_impl->size();`
`1142`	`1142`	`}`
`1143`	`1143`
`1144`		`-bool AddrMan::Add(const std::vector<CAddress> &vAddr, const CNetAddr& source, int64_t nTimePenalty)`
	`1144`	`+bool AddrMan::Add(const std::vector<CAddress>& vAddr, const CNetAddr& source, int64_t nTimePenalty)`
`1145`	`1145`	`{`
`1146`	`1146`	`return m_impl->Add(vAddr, source, nTimePenalty);`
`1147`	`1147`	`}`
`1148`	`1148`
`1149`		`-void AddrMan::Good(const CService &addr, int64_t nTime)`
	`1149`	`+void AddrMan::Good(const CService& addr, int64_t nTime)`
`1150`	`1150`	`{`
`1151`	`1151`	`m_impl->Good(addr, nTime);`
`1152`	`1152`	`}`
`1153`	`1153`
`1154`		`-void AddrMan::Attempt(const CService &addr, bool fCountFailure, int64_t nTime)`
	`1154`	`+void AddrMan::Attempt(const CService& addr, bool fCountFailure, int64_t nTime)`
`1155`	`1155`	`{`
`1156`	`1156`	`m_impl->Attempt(addr, fCountFailure, nTime);`
`1157`	`1157`	`}`
`@@ -1176,12 +1176,12 @@ std::vector<CAddress> AddrMan::GetAddr(size_t max_addresses, size_t max_pct, std`
`1176`	`1176`	`return m_impl->GetAddr(max_addresses, max_pct, network);`
`1177`	`1177`	`}`
`1178`	`1178`
`1179`		`-void AddrMan::Connected(const CService &addr, int64_t nTime)`
	`1179`	`+void AddrMan::Connected(const CService& addr, int64_t nTime)`
`1180`	`1180`	`{`
`1181`	`1181`	`m_impl->Connected(addr, nTime);`
`1182`	`1182`	`}`
`1183`	`1183`
`1184`		`-void AddrMan::SetServices(const CService &addr, ServiceFlags nServices)`
	`1184`	`+void AddrMan::SetServices(const CService& addr, ServiceFlags nServices)`
`1185`	`1185`	`{`
`1186`	`1186`	`m_impl->SetServices(addr, nServices);`
`1187`	`1187`	`}`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ class AddrManTest : public AddrMan`
`83`	`83`	`bool deterministic;`
`84`	`84`	`public:`
`85`	`85`	`explicit AddrManTest(bool makeDeterministic = true,`
`86`		`- std::vector<bool> asmap = std::vector<bool>())`
	`86`	`+ std::vector<bool> asmap = std::vector<bool>())`
`87`	`87`	`: AddrMan(asmap, makeDeterministic, /* consistency_check_ratio */ 100)`
`88`	`88`	`{`
`89`	`89`	`deterministic = makeDeterministic;`