Skip to content

Commit dd8f7f2

Browse files
amitiuttarwaramitiuttarwar
committed
scripted-diff: Rename CAddrMan to AddrMan
-BEGIN VERIFY SCRIPT- git grep -l CAddrMan src/ test/ | xargs sed -i 's/CAddrMan/AddrMan/g' -END VERIFY SCRIPT-
1 parent 3c263d3 commit dd8f7f2

19 files changed

+122
-122
lines changed

‎src/addrdb.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -170,21 +170,21 @@ bool CBanDB::Read(banmap_t& banSet)
170170
return true;
171171
}
172172

173-
bool DumpPeerAddresses(const ArgsManager& args, const CAddrMan& addr)
173+
bool DumpPeerAddresses(const ArgsManager& args, const AddrMan& addr)
174174
{
175175
const auto pathAddr = args.GetDataDirNet() / "peers.dat";
176176
return SerializeFileDB("peers", pathAddr, addr, CLIENT_VERSION);
177177
}
178178

179-
void ReadFromStream(CAddrMan& addr, CDataStream& ssPeers)
179+
void ReadFromStream(AddrMan& addr, CDataStream& ssPeers)
180180
{
181181
DeserializeDB(ssPeers, addr, false);
182182
}
183183

184-
std::optional<bilingual_str> LoadAddrman(const std::vector<bool>& asmap, const ArgsManager& args, std::unique_ptr<CAddrMan>& addrman)
184+
std::optional<bilingual_str> LoadAddrman(const std::vector<bool>& asmap, const ArgsManager& args, std::unique_ptr<AddrMan>& addrman)
185185
{
186186
auto check_addrman = std::clamp<int32_t>(args.GetIntArg("-checkaddrman", DEFAULT_ADDRMAN_CONSISTENCY_CHECKS), 0, 1000000);
187-
addrman = std::make_unique<CAddrMan>(asmap, /* deterministic */ false, /* consistency_check_ratio */ check_addrman);
187+
addrman = std::make_unique<AddrMan>(asmap, /* deterministic */ false, /* consistency_check_ratio */ check_addrman);
188188

189189
int64_t nStart = GetTimeMillis();
190190
const auto path_addr{args.GetDataDirNet() / "peers.dat"};
@@ -193,7 +193,7 @@ std::optional<bilingual_str> LoadAddrman(const std::vector<bool>& asmap, const A
193193
LogPrintf("Loaded %i addresses from peers.dat %dms\n", addrman->size(), GetTimeMillis() - nStart);
194194
} catch (const DbNotFoundError&) {
195195
// Addrman can be in an inconsistent state after failure, reset it
196-
addrman = std::make_unique<CAddrMan>(asmap, /* deterministic */ false, /* consistency_check_ratio */ check_addrman);
196+
addrman = std::make_unique<AddrMan>(asmap, /* deterministic */ false, /* consistency_check_ratio */ check_addrman);
197197
LogPrintf("Creating peers.dat because the file was not found (%s)\n", path_addr);
198198
DumpPeerAddresses(args, *addrman);
199199
} catch (const std::exception& e) {

‎src/addrdb.h

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -14,14 +14,14 @@
1414
#include <vector>
1515

1616
class ArgsManager;
17-
class CAddrMan;
17+
class AddrMan;
1818
class CAddress;
1919
class CDataStream;
2020
struct bilingual_str;
2121

22-
bool DumpPeerAddresses(const ArgsManager& args, const CAddrMan& addr);
22+
bool DumpPeerAddresses(const ArgsManager& args, const AddrMan& addr);
2323
/** Only used by tests. */
24-
void ReadFromStream(CAddrMan& addr, CDataStream& ssPeers);
24+
void ReadFromStream(AddrMan& addr, CDataStream& ssPeers);
2525

2626
/** Access to the banlist database (banlist.json) */
2727
class CBanDB
@@ -48,7 +48,7 @@ class CBanDB
4848
};
4949

5050
/** Returns an error string on failure */
51-
std::optional<bilingual_str> LoadAddrman(const std::vector<bool>& asmap, const ArgsManager& args, std::unique_ptr<CAddrMan>& addrman);
51+
std::optional<bilingual_str> LoadAddrman(const std::vector<bool>& asmap, const ArgsManager& args, std::unique_ptr<AddrMan>& addrman);
5252

5353
/**
5454
* Dump the anchor IP address database (anchors.dat)

‎src/addrman.cpp

Lines changed: 25 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -269,14 +269,14 @@ void AddrManImpl::Unserialize(Stream& s_)
269269

270270
if (nNew > ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nNew < 0) {
271271
throw std::ios_base::failure(
272-
strprintf("Corrupt CAddrMan serialization: nNew=%d, should be in [0, %d]",
272+
strprintf("Corrupt AddrMan serialization: nNew=%d, should be in [0, %d]",
273273
nNew,
274274
ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));
275275
}
276276

277277
if (nTried > ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nTried < 0) {
278278
throw std::ios_base::failure(
279-
strprintf("Corrupt CAddrMan serialization: nTried=%d, should be in [0, %d]",
279+
strprintf("Corrupt AddrMan serialization: nTried=%d, should be in [0, %d]",
280280
nTried,
281281
ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));
282282
}
@@ -1110,83 +1110,83 @@ const std::vector<bool>& AddrManImpl::GetAsmap() const
11101110
return m_asmap;
11111111
}
11121112

1113-
CAddrMan::CAddrMan(std::vector<bool> asmap, bool deterministic, int32_t consistency_check_ratio)
1113+
AddrMan::AddrMan(std::vector<bool> asmap, bool deterministic, int32_t consistency_check_ratio)
11141114
: m_impl(std::make_unique<AddrManImpl>(std::move(asmap), deterministic, consistency_check_ratio)) {}
11151115

1116-
CAddrMan::~CAddrMan() = default;
1116+
AddrMan::~AddrMan() = default;
11171117

11181118
template <typename Stream>
1119-
void CAddrMan::Serialize(Stream& s_) const
1119+
void AddrMan::Serialize(Stream& s_) const
11201120
{
11211121
m_impl->Serialize<Stream>(s_);
11221122
}
11231123

11241124
template <typename Stream>
1125-
void CAddrMan::Unserialize(Stream& s_)
1125+
void AddrMan::Unserialize(Stream& s_)
11261126
{
11271127
m_impl->Unserialize<Stream>(s_);
11281128
}
11291129

11301130
// explicit instantiation
1131-
template void CAddrMan::Serialize(CHashWriter& s) const;
1132-
template void CAddrMan::Serialize(CAutoFile& s) const;
1133-
template void CAddrMan::Serialize(CDataStream& s) const;
1134-
template void CAddrMan::Unserialize(CAutoFile& s);
1135-
template void CAddrMan::Unserialize(CHashVerifier<CAutoFile>& s);
1136-
template void CAddrMan::Unserialize(CDataStream& s);
1137-
template void CAddrMan::Unserialize(CHashVerifier<CDataStream>& s);
1138-
1139-
size_t CAddrMan::size() const
1131+
template void AddrMan::Serialize(CHashWriter& s) const;
1132+
template void AddrMan::Serialize(CAutoFile& s) const;
1133+
template void AddrMan::Serialize(CDataStream& s) const;
1134+
template void AddrMan::Unserialize(CAutoFile& s);
1135+
template void AddrMan::Unserialize(CHashVerifier<CAutoFile>& s);
1136+
template void AddrMan::Unserialize(CDataStream& s);
1137+
template void AddrMan::Unserialize(CHashVerifier<CDataStream>& s);
1138+
1139+
size_t AddrMan::size() const
11401140
{
11411141
return m_impl->size();
11421142
}
11431143

1144-
bool CAddrMan::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)
11451145
{
11461146
return m_impl->Add(vAddr, source, nTimePenalty);
11471147
}
11481148

1149-
void CAddrMan::Good(const CService &addr, int64_t nTime)
1149+
void AddrMan::Good(const CService &addr, int64_t nTime)
11501150
{
11511151
m_impl->Good(addr, nTime);
11521152
}
11531153

1154-
void CAddrMan::Attempt(const CService &addr, bool fCountFailure, int64_t nTime)
1154+
void AddrMan::Attempt(const CService &addr, bool fCountFailure, int64_t nTime)
11551155
{
11561156
m_impl->Attempt(addr, fCountFailure, nTime);
11571157
}
11581158

1159-
void CAddrMan::ResolveCollisions()
1159+
void AddrMan::ResolveCollisions()
11601160
{
11611161
m_impl->ResolveCollisions();
11621162
}
11631163

1164-
std::pair<CAddress, int64_t> CAddrMan::SelectTriedCollision()
1164+
std::pair<CAddress, int64_t> AddrMan::SelectTriedCollision()
11651165
{
11661166
return m_impl->SelectTriedCollision();
11671167
}
11681168

1169-
std::pair<CAddress, int64_t> CAddrMan::Select(bool newOnly) const
1169+
std::pair<CAddress, int64_t> AddrMan::Select(bool newOnly) const
11701170
{
11711171
return m_impl->Select(newOnly);
11721172
}
11731173

1174-
std::vector<CAddress> CAddrMan::GetAddr(size_t max_addresses, size_t max_pct, std::optional<Network> network) const
1174+
std::vector<CAddress> AddrMan::GetAddr(size_t max_addresses, size_t max_pct, std::optional<Network> network) const
11751175
{
11761176
return m_impl->GetAddr(max_addresses, max_pct, network);
11771177
}
11781178

1179-
void CAddrMan::Connected(const CService &addr, int64_t nTime)
1179+
void AddrMan::Connected(const CService &addr, int64_t nTime)
11801180
{
11811181
m_impl->Connected(addr, nTime);
11821182
}
11831183

1184-
void CAddrMan::SetServices(const CService &addr, ServiceFlags nServices)
1184+
void AddrMan::SetServices(const CService &addr, ServiceFlags nServices)
11851185
{
11861186
m_impl->SetServices(addr, nServices);
11871187
}
11881188

1189-
const std::vector<bool>& CAddrMan::GetAsmap() const
1189+
const std::vector<bool>& AddrMan::GetAsmap() const
11901190
{
11911191
return m_impl->GetAsmap();
11921192
}

‎src/addrman.h

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -51,14 +51,14 @@ static constexpr int32_t DEFAULT_ADDRMAN_CONSISTENCY_CHECKS{0};
5151
* * Several indexes are kept for high performance. Setting m_consistency_check_ratio with the -checkaddrman
5252
* configuration option will introduce (expensive) consistency checks for the entire data structure.
5353
*/
54-
class CAddrMan
54+
class AddrMan
5555
{
5656
const std::unique_ptr<AddrManImpl> m_impl;
5757

5858
public:
59-
explicit CAddrMan(std::vector<bool> asmap, bool deterministic, int32_t consistency_check_ratio);
59+
explicit AddrMan(std::vector<bool> asmap, bool deterministic, int32_t consistency_check_ratio);
6060

61-
~CAddrMan();
61+
~AddrMan();
6262

6363
template <typename Stream>
6464
void Serialize(Stream& s_) const;
@@ -128,8 +128,8 @@ class CAddrMan
128128

129129
const std::vector<bool>& GetAsmap() const;
130130

131-
friend class CAddrManTest;
132-
friend class CAddrManDeterministic;
131+
friend class AddrManTest;
132+
friend class AddrManDeterministic;
133133
};
134134

135135
#endif // BITCOIN_ADDRMAN_H

‎src/addrman_impl.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -138,8 +138,8 @@ class AddrManImpl
138138

139139
const std::vector<bool>& GetAsmap() const;
140140

141-
friend class CAddrManTest;
142-
friend class CAddrManDeterministic;
141+
friend class AddrManTest;
142+
friend class AddrManDeterministic;
143143

144144
private:
145145
//! A mutex to protect the inner data structures.

‎src/bench/addrman.cpp

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -53,14 +53,14 @@ static void CreateAddresses()
5353
}
5454
}
5555

56-
static void AddAddressesToAddrMan(CAddrMan& addrman)
56+
static void AddAddressesToAddrMan(AddrMan& addrman)
5757
{
5858
for (size_t source_i = 0; source_i < NUM_SOURCES; ++source_i) {
5959
addrman.Add(g_addresses[source_i], g_sources[source_i]);
6060
}
6161
}
6262

63-
static void FillAddrMan(CAddrMan& addrman)
63+
static void FillAddrMan(AddrMan& addrman)
6464
{
6565
CreateAddresses();
6666

@@ -74,14 +74,14 @@ static void AddrManAdd(benchmark::Bench& bench)
7474
CreateAddresses();
7575

7676
bench.run([&] {
77-
CAddrMan addrman{/* asmap */ std::vector<bool>(), /* deterministic */ false, /* consistency_check_ratio */ 0};
77+
AddrMan addrman{/* asmap */ std::vector<bool>(), /* deterministic */ false, /* consistency_check_ratio */ 0};
7878
AddAddressesToAddrMan(addrman);
7979
});
8080
}
8181

8282
static void AddrManSelect(benchmark::Bench& bench)
8383
{
84-
CAddrMan addrman(/* asmap */ std::vector<bool>(), /* deterministic */ false, /* consistency_check_ratio */ 0);
84+
AddrMan addrman(/* asmap */ std::vector<bool>(), /* deterministic */ false, /* consistency_check_ratio */ 0);
8585

8686
FillAddrMan(addrman);
8787

@@ -93,7 +93,7 @@ static void AddrManSelect(benchmark::Bench& bench)
9393

9494
static void AddrManGetAddr(benchmark::Bench& bench)
9595
{
96-
CAddrMan addrman(/* asmap */ std::vector<bool>(), /* deterministic */ false, /* consistency_check_ratio */ 0);
96+
AddrMan addrman(/* asmap */ std::vector<bool>(), /* deterministic */ false, /* consistency_check_ratio */ 0);
9797

9898
FillAddrMan(addrman);
9999

@@ -105,7 +105,7 @@ static void AddrManGetAddr(benchmark::Bench& bench)
105105

106106
static void AddrManAddThenGood(benchmark::Bench& bench)
107107
{
108-
auto markSomeAsGood = [](CAddrMan& addrman) {
108+
auto markSomeAsGood = [](AddrMan& addrman) {
109109
for (size_t source_i = 0; source_i < NUM_SOURCES; ++source_i) {
110110
for (size_t addr_i = 0; addr_i < NUM_ADDRESSES_PER_SOURCE; ++addr_i) {
111111
addrman.Good(g_addresses[source_i][addr_i]);
@@ -117,12 +117,12 @@ static void AddrManAddThenGood(benchmark::Bench& bench)
117117

118118
bench.run([&] {
119119
// To make the benchmark independent of the number of evaluations, we always prepare a new addrman.
120-
// This is necessary because CAddrMan::Good() method modifies the object, affecting the timing of subsequent calls
120+
// This is necessary because AddrMan::Good() method modifies the object, affecting the timing of subsequent calls
121121
// to the same method and we want to do the same amount of work in every loop iteration.
122122
//
123123
// This has some overhead (exactly the result of AddrManAdd benchmark), but that overhead is constant so improvements in
124-
// CAddrMan::Good() will still be noticeable.
125-
CAddrMan addrman(/* asmap */ std::vector<bool>(), /* deterministic */ false, /* consistency_check_ratio */ 0);
124+
// AddrMan::Good() will still be noticeable.
125+
AddrMan addrman(/* asmap */ std::vector<bool>(), /* deterministic */ false, /* consistency_check_ratio */ 0);
126126
AddAddressesToAddrMan(addrman);
127127

128128
markSomeAsGood(addrman);

‎src/net.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2438,7 +2438,7 @@ void CConnman::SetNetworkActive(bool active)
24382438
}
24392439
}
24402440

2441-
CConnman::CConnman(uint64_t nSeed0In, uint64_t nSeed1In, CAddrMan& addrman_in, bool network_active)
2441+
CConnman::CConnman(uint64_t nSeed0In, uint64_t nSeed1In, AddrMan& addrman_in, bool network_active)
24422442
: addrman(addrman_in), nSeed0(nSeed0In), nSeed1(nSeed1In)
24432443
{
24442444
SetTryNewOutboundPeer(false);

‎src/net.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -797,7 +797,7 @@ class CConnman
797797
m_onion_binds = connOptions.onion_binds;
798798
}
799799

800-
CConnman(uint64_t seed0, uint64_t seed1, CAddrMan& addrman, bool network_active = true);
800+
CConnman(uint64_t seed0, uint64_t seed1, AddrMan& addrman, bool network_active = true);
801801
~CConnman();
802802
bool Start(CScheduler& scheduler, const Options& options);
803803

@@ -1049,7 +1049,7 @@ class CConnman
10491049
std::vector<ListenSocket> vhListenSocket;
10501050
std::atomic<bool> fNetworkActive{true};
10511051
bool fAddressesInitialized{false};
1052-
CAddrMan& addrman;
1052+
AddrMan& addrman;
10531053
std::deque<std::string> m_addr_fetches GUARDED_BY(m_addr_fetches_mutex);
10541054
RecursiveMutex m_addr_fetches_mutex;
10551055
std::vector<std::string> vAddedNodes GUARDED_BY(cs_vAddedNodes);

‎src/net_processing.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -291,7 +291,7 @@ using PeerRef = std::shared_ptr<Peer>;
291291
class PeerManagerImpl final : public PeerManager
292292
{
293293
public:
294-
PeerManagerImpl(const CChainParams& chainparams, CConnman& connman, CAddrMan& addrman,
294+
PeerManagerImpl(const CChainParams& chainparams, CConnman& connman, AddrMan& addrman,
295295
BanMan* banman, ChainstateManager& chainman,
296296
CTxMemPool& pool, bool ignore_incoming_txs);
297297

@@ -409,7 +409,7 @@ class PeerManagerImpl final : public PeerManager
409409

410410
const CChainParams& m_chainparams;
411411
CConnman& m_connman;
412-
CAddrMan& m_addrman;
412+
AddrMan& m_addrman;
413413
/** Pointer to this node's banman. May be nullptr - check existence before dereferencing. */
414414
BanMan* const m_banman;
415415
ChainstateManager& m_chainman;
@@ -1419,14 +1419,14 @@ bool PeerManagerImpl::BlockRequestAllowed(const CBlockIndex* pindex)
14191419
(GetBlockProofEquivalentTime(*pindexBestHeader, *pindex, *pindexBestHeader, m_chainparams.GetConsensus()) < STALE_RELAY_AGE_LIMIT);
14201420
}
14211421

1422-
std::unique_ptr<PeerManager> PeerManager::make(const CChainParams& chainparams, CConnman& connman, CAddrMan& addrman,
1422+
std::unique_ptr<PeerManager> PeerManager::make(const CChainParams& chainparams, CConnman& connman, AddrMan& addrman,
14231423
BanMan* banman, ChainstateManager& chainman,
14241424
CTxMemPool& pool, bool ignore_incoming_txs)
14251425
{
14261426
return std::make_unique<PeerManagerImpl>(chainparams, connman, addrman, banman, chainman, pool, ignore_incoming_txs);
14271427
}
14281428

1429-
PeerManagerImpl::PeerManagerImpl(const CChainParams& chainparams, CConnman& connman, CAddrMan& addrman,
1429+
PeerManagerImpl::PeerManagerImpl(const CChainParams& chainparams, CConnman& connman, AddrMan& addrman,
14301430
BanMan* banman, ChainstateManager& chainman,
14311431
CTxMemPool& pool, bool ignore_incoming_txs)
14321432
: m_chainparams(chainparams),
@@ -2653,7 +2653,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
26532653
// table is also potentially detrimental because new-table entries
26542654
// are subject to eviction in the event of addrman collisions. We
26552655
// mitigate the information-leak by never calling
2656-
// CAddrMan::Connected() on block-relay-only peers; see
2656+
// AddrMan::Connected() on block-relay-only peers; see
26572657
// FinalizeNode().
26582658
//
26592659
// This moves an address from New to Tried table in Addrman,

‎src/net_processing.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@
99
#include <net.h>
1010
#include <validationinterface.h>
1111

12-
class CAddrMan;
12+
class AddrMan;
1313
class CChainParams;
1414
class CTxMemPool;
1515
class ChainstateManager;
@@ -37,7 +37,7 @@ struct CNodeStateStats {
3737
class PeerManager : public CValidationInterface, public NetEventsInterface
3838
{
3939
public:
40-
static std::unique_ptr<PeerManager> make(const CChainParams& chainparams, CConnman& connman, CAddrMan& addrman,
40+
static std::unique_ptr<PeerManager> make(const CChainParams& chainparams, CConnman& connman, AddrMan& addrman,
4141
BanMan* banman, ChainstateManager& chainman,
4242
CTxMemPool& pool, bool ignore_incoming_txs);
4343
virtual ~PeerManager() { }

0 commit comments

Comments
 (0)