From 84881f8c472cc67dc757686eb7dc3b495b13cab8 Mon Sep 17 00:00:00 2001 From: Kamil Domanski Date: Wed, 20 Aug 2014 22:44:38 +0200 Subject: [PATCH] rework overhauled serialization methods to non-static Thanks to Pieter Wuille for most of the work on this commit. I did not fixup the overhaul commit, because a rebase conflicted with "remove fields of ser_streamplaceholder". I prefer not to risk making a mistake while resolving it. --- src/addrman.h | 14 ++-- src/alert.h | 44 +++++----- src/bloom.h | 14 ++-- src/core.h | 130 +++++++++++++++--------------- src/crypter.h | 16 ++-- src/main.h | 112 ++++++++++++------------- src/netbase.h | 20 ++--- src/protocol.h | 36 ++++----- src/qt/recentrequeststablemodel.h | 14 ++-- src/qt/walletmodel.h | 10 +-- src/serialize.h | 14 ++-- src/wallet.h | 102 +++++++++++------------ src/walletdb.h | 12 +-- 13 files changed, 269 insertions(+), 269 deletions(-) diff --git a/src/addrman.h b/src/addrman.h index 4287cbc1b..05af436ae 100644 --- a/src/addrman.h +++ b/src/addrman.h @@ -46,16 +46,16 @@ private: public: - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - CAddress* pthis = (CAddress*)(thisPtr); + CAddress* pthis = (CAddress*)(this); READWRITE(*pthis); - READWRITE(thisPtr->source); - READWRITE(thisPtr->nLastSuccess); - READWRITE(thisPtr->nAttempts); + READWRITE(source); + READWRITE(nLastSuccess); + READWRITE(nAttempts); return nSerSize; } diff --git a/src/alert.h b/src/alert.h index 4c8267fd0..46ec4fbde 100644 --- a/src/alert.h +++ b/src/alert.h @@ -46,26 +46,26 @@ public: std::string strStatusBar; std::string strReserved; - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->nVersion); - nVersion = thisPtr->nVersion; - READWRITE(thisPtr->nRelayUntil); - READWRITE(thisPtr->nExpiration); - READWRITE(thisPtr->nID); - READWRITE(thisPtr->nCancel); - READWRITE(thisPtr->setCancel); - READWRITE(thisPtr->nMinVer); - READWRITE(thisPtr->nMaxVer); - READWRITE(thisPtr->setSubVer); - READWRITE(thisPtr->nPriority); + READWRITE(this->nVersion); + nVersion = this->nVersion; + READWRITE(nRelayUntil); + READWRITE(nExpiration); + READWRITE(nID); + READWRITE(nCancel); + READWRITE(setCancel); + READWRITE(nMinVer); + READWRITE(nMaxVer); + READWRITE(setSubVer); + READWRITE(nPriority); - READWRITE(LIMITED_STRING(thisPtr->strComment, 65536)); - READWRITE(LIMITED_STRING(thisPtr->strStatusBar, 256)); - READWRITE(LIMITED_STRING(thisPtr->strReserved, 256)); + READWRITE(LIMITED_STRING(strComment, 65536)); + READWRITE(LIMITED_STRING(strStatusBar, 256)); + READWRITE(LIMITED_STRING(strReserved, 256)); return nSerSize; } @@ -86,13 +86,13 @@ public: SetNull(); } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->vchMsg); - READWRITE(thisPtr->vchSig); + READWRITE(vchMsg); + READWRITE(vchSig); return nSerSize; } diff --git a/src/bloom.h b/src/bloom.h index dafea6702..8dbf74f49 100644 --- a/src/bloom.h +++ b/src/bloom.h @@ -62,15 +62,15 @@ public: CBloomFilter(unsigned int nElements, double nFPRate, unsigned int nTweak, unsigned char nFlagsIn); CBloomFilter() : isFull(true), isEmpty(false), nHashFuncs(0), nTweak(0), nFlags(0) {} - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->vData); - READWRITE(thisPtr->nHashFuncs); - READWRITE(thisPtr->nTweak); - READWRITE(thisPtr->nFlags); + READWRITE(vData); + READWRITE(nHashFuncs); + READWRITE(nTweak); + READWRITE(nFlags); return nSerSize; } diff --git a/src/core.h b/src/core.h index 1caf9da6c..e56be1a4e 100644 --- a/src/core.h +++ b/src/core.h @@ -31,12 +31,12 @@ public: COutPoint() { SetNull(); } COutPoint(uint256 hashIn, uint32_t nIn) { hash = hashIn; n = nIn; } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(FLATDATA(*thisPtr)); + READWRITE(FLATDATA(*this)); return nSerSize; } @@ -93,14 +93,14 @@ public: explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=std::numeric_limits::max()); CTxIn(uint256 hashPrevTx, uint32_t nOut, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=std::numeric_limits::max()); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->prevout); - READWRITE(thisPtr->scriptSig); - READWRITE(thisPtr->nSequence); + READWRITE(prevout); + READWRITE(scriptSig); + READWRITE(nSequence); return nSerSize; } @@ -149,12 +149,12 @@ public: friend bool operator>=(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK >= b.nSatoshisPerK; } std::string ToString() const; - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->nSatoshisPerK); + READWRITE(nSatoshisPerK); return nSerSize; } }; @@ -176,13 +176,13 @@ public: CTxOut(int64_t nValueIn, CScript scriptPubKeyIn); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->nValue); - READWRITE(thisPtr->scriptPubKey); + READWRITE(nValue); + READWRITE(scriptPubKey); return nSerSize; } @@ -261,20 +261,20 @@ public: CTransaction& operator=(const CTransaction& tx); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; bool fRead = boost::is_same(); - READWRITE(*const_cast(&thisPtr->nVersion)); - nVersion = thisPtr->nVersion; - READWRITE(*const_cast*>(&thisPtr->vin)); - READWRITE(*const_cast*>(&thisPtr->vout)); - READWRITE(*const_cast(&thisPtr->nLockTime)); + READWRITE(*const_cast(&this->nVersion)); + nVersion = this->nVersion; + READWRITE(*const_cast*>(&vin)); + READWRITE(*const_cast*>(&vout)); + READWRITE(*const_cast(&nLockTime)); if (fRead) - thisPtr->UpdateHash(); + UpdateHash(); return nSerSize; } @@ -324,17 +324,17 @@ struct CMutableTransaction CMutableTransaction(); CMutableTransaction(const CTransaction& tx); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->nVersion); - nVersion = thisPtr->nVersion; - READWRITE(thisPtr->vin); - READWRITE(thisPtr->vout); - READWRITE(thisPtr->nLockTime); + READWRITE(this->nVersion); + nVersion = this->nVersion; + READWRITE(vin); + READWRITE(vout); + READWRITE(nLockTime); return nSerSize; } @@ -357,21 +357,21 @@ public: CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) { } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { bool fRead = boost::is_same(); size_t nSerSize = 0; if (!fRead) { - uint64_t nVal = CompressAmount(thisPtr->txout.nValue); + uint64_t nVal = CompressAmount(txout.nValue); READWRITE(VARINT(nVal)); } else { uint64_t nVal = 0; READWRITE(VARINT(nVal)); - thisPtr->txout.nValue = DecompressAmount(nVal); + txout.nValue = DecompressAmount(nVal); } - CScriptCompressor cscript(REF(thisPtr->txout.scriptPubKey)); + CScriptCompressor cscript(REF(txout.scriptPubKey)); READWRITE(cscript); return nSerSize; } @@ -427,12 +427,12 @@ public: // undo information for all txins std::vector vprevout; - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->vprevout); + READWRITE(vprevout); return nSerSize; } }; @@ -462,19 +462,19 @@ public: SetNull(); } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->nVersion); - nVersion = thisPtr->nVersion; - READWRITE(thisPtr->hashPrevBlock); - READWRITE(thisPtr->hashMerkleRoot); - READWRITE(thisPtr->nTime); - READWRITE(thisPtr->nBits); - READWRITE(thisPtr->nNonce); + READWRITE(this->nVersion); + nVersion = this->nVersion; + READWRITE(hashPrevBlock); + READWRITE(hashMerkleRoot); + READWRITE(nTime); + READWRITE(nBits); + READWRITE(nNonce); return nSerSize; } @@ -523,14 +523,14 @@ public: *((CBlockHeader*)this) = header; } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(*(CBlockHeader*)thisPtr); - READWRITE(thisPtr->vtx); + READWRITE(*(CBlockHeader*)this); + READWRITE(vtx); return nSerSize; } @@ -577,15 +577,15 @@ struct CBlockLocator vHave = vHaveIn; } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; if (!(nType & SER_GETHASH)) READWRITE(nVersion); - READWRITE(thisPtr->vHave); + READWRITE(vHave); return nSerSize; } diff --git a/src/crypter.h b/src/crypter.h index c3f4ed971..ce4c6315a 100644 --- a/src/crypter.h +++ b/src/crypter.h @@ -43,16 +43,16 @@ public: // such as the various parameters to scrypt std::vector vchOtherDerivationParameters; - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->vchCryptedKey); - READWRITE(thisPtr->vchSalt); - READWRITE(thisPtr->nDerivationMethod); - READWRITE(thisPtr->nDeriveIterations); - READWRITE(thisPtr->vchOtherDerivationParameters); + READWRITE(vchCryptedKey); + READWRITE(vchSalt); + READWRITE(nDerivationMethod); + READWRITE(nDeriveIterations); + READWRITE(vchOtherDerivationParameters); return nSerSize; } diff --git a/src/main.h b/src/main.h index 88e3159e3..8a5fa0e7e 100644 --- a/src/main.h +++ b/src/main.h @@ -197,13 +197,13 @@ struct CDiskBlockPos int nFile; unsigned int nPos; - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(VARINT(thisPtr->nFile)); - READWRITE(VARINT(thisPtr->nPos)); + READWRITE(VARINT(nFile)); + READWRITE(VARINT(nPos)); return nSerSize; } @@ -232,13 +232,13 @@ struct CDiskTxPos : public CDiskBlockPos { unsigned int nTxOffset; // after header - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(*(CDiskBlockPos*)thisPtr); - READWRITE(VARINT(thisPtr->nTxOffset)); + READWRITE(*(CDiskBlockPos*)this); + READWRITE(VARINT(nTxOffset)); return nSerSize; } @@ -317,12 +317,12 @@ class CBlockUndo public: std::vector vtxundo; // for all but the coinbase - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->vtxundo); + READWRITE(vtxundo); return nSerSize; } @@ -426,27 +426,27 @@ protected: public: // serialization implementation - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; bool fRead = boost::is_same(); - READWRITE(thisPtr->nTransactions); - READWRITE(thisPtr->vHash); + READWRITE(nTransactions); + READWRITE(vHash); std::vector vBytes; if (fRead) { READWRITE(vBytes); - CPartialMerkleTree &us = *(const_cast(thisPtr)); + CPartialMerkleTree &us = *(const_cast(this)); us.vBits.resize(vBytes.size() * 8); for (unsigned int p = 0; p < us.vBits.size(); p++) us.vBits[p] = (vBytes[p / 8] & (1 << (p % 8))) != 0; us.fBad = false; } else { - vBytes.resize((thisPtr->vBits.size()+7)/8); - for (unsigned int p = 0; p < thisPtr->vBits.size(); p++) - vBytes[p / 8] |= thisPtr->vBits[p] << (p % 8); + vBytes.resize((vBits.size()+7)/8); + for (unsigned int p = 0; p < vBits.size(); p++) + vBytes[p / 8] |= vBits[p] << (p % 8); READWRITE(vBytes); } @@ -507,19 +507,19 @@ public: uint64_t nTimeFirst; // earliest time of block in file uint64_t nTimeLast; // latest time of block in file - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(VARINT(thisPtr->nBlocks)); - READWRITE(VARINT(thisPtr->nSize)); - READWRITE(VARINT(thisPtr->nUndoSize)); - READWRITE(VARINT(thisPtr->nHeightFirst)); - READWRITE(VARINT(thisPtr->nHeightLast)); - READWRITE(VARINT(thisPtr->nTimeFirst)); - READWRITE(VARINT(thisPtr->nTimeLast)); + READWRITE(VARINT(nBlocks)); + READWRITE(VARINT(nSize)); + READWRITE(VARINT(nUndoSize)); + READWRITE(VARINT(nHeightFirst)); + READWRITE(VARINT(nHeightLast)); + READWRITE(VARINT(nTimeFirst)); + READWRITE(VARINT(nTimeLast)); return nSerSize; } @@ -785,32 +785,32 @@ public: hashPrev = (pprev ? pprev->GetBlockHash() : 0); } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; if (!(nType & SER_GETHASH)) READWRITE(VARINT(nVersion)); - READWRITE(VARINT(thisPtr->nHeight)); - READWRITE(VARINT(thisPtr->nStatus)); - READWRITE(VARINT(thisPtr->nTx)); - if (thisPtr->nStatus & (BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO)) - READWRITE(VARINT(thisPtr->nFile)); - if (thisPtr->nStatus & BLOCK_HAVE_DATA) - READWRITE(VARINT(thisPtr->nDataPos)); - if (thisPtr->nStatus & BLOCK_HAVE_UNDO) - READWRITE(VARINT(thisPtr->nUndoPos)); + READWRITE(VARINT(nHeight)); + READWRITE(VARINT(nStatus)); + READWRITE(VARINT(nTx)); + if (nStatus & (BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO)) + READWRITE(VARINT(nFile)); + if (nStatus & BLOCK_HAVE_DATA) + READWRITE(VARINT(nDataPos)); + if (nStatus & BLOCK_HAVE_UNDO) + READWRITE(VARINT(nUndoPos)); // block header - READWRITE(thisPtr->nVersion); - READWRITE(thisPtr->hashPrev); - READWRITE(thisPtr->hashMerkleRoot); - READWRITE(thisPtr->nTime); - READWRITE(thisPtr->nBits); - READWRITE(thisPtr->nNonce); + READWRITE(this->nVersion); + READWRITE(hashPrev); + READWRITE(hashMerkleRoot); + READWRITE(nTime); + READWRITE(nBits); + READWRITE(nNonce); return nSerSize; } @@ -1011,13 +1011,13 @@ public: // thus the filter will likely be modified. CMerkleBlock(const CBlock& block, CBloomFilter& filter); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->header); - READWRITE(thisPtr->txn); + READWRITE(header); + READWRITE(txn); return nSerSize; } }; diff --git a/src/netbase.h b/src/netbase.h index 6f8c13250..b4ba71126 100644 --- a/src/netbase.h +++ b/src/netbase.h @@ -88,12 +88,12 @@ class CNetAddr friend bool operator!=(const CNetAddr& a, const CNetAddr& b); friend bool operator<(const CNetAddr& a, const CNetAddr& b); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(FLATDATA(thisPtr->ip)); + READWRITE(FLATDATA(ip)); return nSerSize; } }; @@ -152,15 +152,15 @@ class CService : public CNetAddr CService(const struct in6_addr& ipv6Addr, unsigned short port); CService(const struct sockaddr_in6& addr); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { bool fRead = boost::is_same(); size_t nSerSize = 0; - CService* pthis = const_cast(thisPtr); - READWRITE(FLATDATA(thisPtr->ip)); - unsigned short portN = htons(thisPtr->port); + CService* pthis = const_cast(this); + READWRITE(FLATDATA(ip)); + unsigned short portN = htons(port); READWRITE(portN); if (fRead) pthis->port = ntohs(portN); diff --git a/src/protocol.h b/src/protocol.h index 851fca9d9..0f5c5559d 100644 --- a/src/protocol.h +++ b/src/protocol.h @@ -35,15 +35,15 @@ class CMessageHeader std::string GetCommand() const; bool IsValid() const; - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(FLATDATA(thisPtr->pchMessageStart)); - READWRITE(FLATDATA(thisPtr->pchCommand)); - READWRITE(thisPtr->nMessageSize); - READWRITE(thisPtr->nChecksum); + READWRITE(FLATDATA(pchMessageStart)); + READWRITE(FLATDATA(pchCommand)); + READWRITE(nMessageSize); + READWRITE(nChecksum); return nSerSize; } @@ -87,14 +87,14 @@ class CAddress : public CService void Init(); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; bool fRead = boost::is_same(); - CAddress* pthis = const_cast(thisPtr); + CAddress* pthis = const_cast(this); CService* pip = (CService*)pthis; if (fRead) pthis->Init(); @@ -102,8 +102,8 @@ class CAddress : public CService READWRITE(nVersion); if ((nType & SER_DISK) || (nVersion >= CADDR_TIME_VERSION && !(nType & SER_GETHASH))) - READWRITE(thisPtr->nTime); - READWRITE(thisPtr->nServices); + READWRITE(nTime); + READWRITE(nServices); READWRITE(*pip); return nSerSize; @@ -128,13 +128,13 @@ class CInv CInv(int typeIn, const uint256& hashIn); CInv(const std::string& strType, const uint256& hashIn); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->type); - READWRITE(thisPtr->hash); + READWRITE(type); + READWRITE(hash); return nSerSize; } diff --git a/src/qt/recentrequeststablemodel.h b/src/qt/recentrequeststablemodel.h index 50962334f..581d7b2c5 100644 --- a/src/qt/recentrequeststablemodel.h +++ b/src/qt/recentrequeststablemodel.h @@ -24,22 +24,22 @@ public: QDateTime date; SendCoinsRecipient recipient; - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; bool fRead = boost::is_same(); - RecentRequestEntry* pthis = const_cast(thisPtr); + RecentRequestEntry* pthis = const_cast(this); - unsigned int nDate = thisPtr->date.toTime_t(); + unsigned int nDate = date.toTime_t(); READWRITE(pthis->nVersion); nVersion = pthis->nVersion; - READWRITE(thisPtr->id); + READWRITE(id); READWRITE(nDate); - READWRITE(thisPtr->recipient); + READWRITE(recipient); if (fRead) pthis->date = QDateTime::fromTime_t(nDate); diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h index 543843733..553b56654 100644 --- a/src/qt/walletmodel.h +++ b/src/qt/walletmodel.h @@ -59,14 +59,14 @@ public: static const int CURRENT_VERSION = 1; int nVersion; - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; bool fRead = boost::is_same(); - SendCoinsRecipient* pthis = const_cast(thisPtr); + SendCoinsRecipient* pthis = const_cast(this); std::string sAddress = pthis->address.toStdString(); std::string sLabel = pthis->label.toStdString(); @@ -80,7 +80,7 @@ public: nVersion = pthis->nVersion; READWRITE(sAddress); READWRITE(sLabel); - READWRITE(thisPtr->amount); + READWRITE(amount); READWRITE(sMessage); READWRITE(sPaymentRequest); READWRITE(sAuthenticatedMerchant); diff --git a/src/serialize.h b/src/serialize.h index c0666d30a..6eefa1813 100644 --- a/src/serialize.h +++ b/src/serialize.h @@ -38,12 +38,12 @@ inline T& REF(const T& val) return const_cast(val); } -// Used to acquire a const pointer "this" and generate a const -// serialization operation from a template +// Used to acquire a non-const pointer "this" to generate bodies +// of const serialization operations from a template template -inline T MAKE_CONST(T val) +inline T* NCONST_PTR(const T* val) { - return const_cast(val); + return const_cast(val); } /** Get begin pointer of vector (non-const version). @@ -97,15 +97,15 @@ enum #define IMPLEMENT_SERIALIZE \ size_t GetSerializeSize(int nType, int nVersion) const { \ ser_streamplaceholder s; \ - return SerializationOp(MAKE_CONST(this), s, CSerActionGetSerializeSize(), nType, nVersion); \ + return NCONST_PTR(this)->SerializationOp(s, CSerActionGetSerializeSize(), nType, nVersion); \ } \ template \ void Serialize(Stream& s, int nType, int nVersion) const { \ - SerializationOp(MAKE_CONST(this), s, CSerActionSerialize(), nType, nVersion); \ + NCONST_PTR(this)->SerializationOp(s, CSerActionSerialize(), nType, nVersion); \ } \ template \ void Unserialize(Stream& s, int nType, int nVersion) { \ - SerializationOp(this, s, CSerActionUnserialize(), nType, nVersion); \ + SerializationOp(s, CSerActionUnserialize(), nType, nVersion); \ } diff --git a/src/wallet.h b/src/wallet.h index 36b0bafe5..d30a28218 100644 --- a/src/wallet.h +++ b/src/wallet.h @@ -63,15 +63,15 @@ public: CKeyPool(); CKeyPool(const CPubKey& vchPubKeyIn); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; if (!(nType & SER_GETHASH)) READWRITE(nVersion); - READWRITE(thisPtr->nTime); - READWRITE(thisPtr->vchPubKey); + READWRITE(nTime); + READWRITE(vchPubKey); return nSerSize; } }; @@ -493,17 +493,17 @@ public: fMerkleVerified = false; } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - nSerSize += SerReadWrite(s, *(CTransaction*)thisPtr, nType, nVersion, ser_action); - nVersion = thisPtr->nVersion; - READWRITE(thisPtr->hashBlock); - READWRITE(thisPtr->vMerkleBranch); - READWRITE(thisPtr->nIndex); + nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action); + nVersion = this->nVersion; + READWRITE(hashBlock); + READWRITE(vMerkleBranch); + READWRITE(nIndex); return nSerSize; } @@ -610,14 +610,14 @@ public: nOrderPos = -1; } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; bool fRead = boost::is_same(); - CWalletTx* pthis = const_cast(thisPtr); + CWalletTx* pthis = const_cast(this); if (fRead) pthis->Init(NULL); char fSpent = false; @@ -628,18 +628,18 @@ public: WriteOrderPos(pthis->nOrderPos, pthis->mapValue); - if (thisPtr->nTimeSmart) - pthis->mapValue["timesmart"] = strprintf("%u", thisPtr->nTimeSmart); + if (nTimeSmart) + pthis->mapValue["timesmart"] = strprintf("%u", nTimeSmart); } - nSerSize += SerReadWrite(s, *(CMerkleTx*)thisPtr, nType, nVersion,ser_action); + nSerSize += SerReadWrite(s, *(CMerkleTx*)this, nType, nVersion,ser_action); std::vector vUnused; // Used to be vtxPrev READWRITE(vUnused); - READWRITE(thisPtr->mapValue); - READWRITE(thisPtr->vOrderForm); - READWRITE(thisPtr->fTimeReceivedIsTxTime); - READWRITE(thisPtr->nTimeReceived); - READWRITE(thisPtr->fFromMe); + READWRITE(mapValue); + READWRITE(vOrderForm); + READWRITE(fTimeReceivedIsTxTime); + READWRITE(nTimeReceived); + READWRITE(fFromMe); READWRITE(fSpent); if (fRead) @@ -648,7 +648,7 @@ public: ReadOrderPos(pthis->nOrderPos, pthis->mapValue); - pthis->nTimeSmart = thisPtr->mapValue.count("timesmart") ? (unsigned int)atoi64(pthis->mapValue["timesmart"]) : 0; + pthis->nTimeSmart = mapValue.count("timesmart") ? (unsigned int)atoi64(pthis->mapValue["timesmart"]) : 0; } pthis->mapValue.erase("fromaccount"); @@ -904,17 +904,17 @@ public: CWalletKey(int64_t nExpires=0); - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; if (!(nType & SER_GETHASH)) READWRITE(nVersion); - READWRITE(thisPtr->vchPrivKey); - READWRITE(thisPtr->nTimeCreated); - READWRITE(thisPtr->nTimeExpires); - READWRITE(LIMITED_STRING(thisPtr->strComment, 65536)); + READWRITE(vchPrivKey); + READWRITE(nTimeCreated); + READWRITE(nTimeExpires); + READWRITE(LIMITED_STRING(strComment, 65536)); return nSerSize; } }; @@ -942,14 +942,14 @@ public: vchPubKey = CPubKey(); } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; if (!(nType & SER_GETHASH)) READWRITE(nVersion); - READWRITE(thisPtr->vchPubKey); + READWRITE(vchPubKey); return nSerSize; } }; @@ -987,44 +987,44 @@ public: nEntryNo = 0; } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; bool fRead = boost::is_same(); - CAccountingEntry& me = *const_cast(thisPtr); + CAccountingEntry& me = *const_cast(this); if (!(nType & SER_GETHASH)) READWRITE(nVersion); // Note: strAccount is serialized as part of the key, not here. - READWRITE(thisPtr->nCreditDebit); - READWRITE(thisPtr->nTime); - READWRITE(LIMITED_STRING(thisPtr->strOtherAccount, 65536)); + READWRITE(nCreditDebit); + READWRITE(nTime); + READWRITE(LIMITED_STRING(strOtherAccount, 65536)); if (!fRead) { - WriteOrderPos(thisPtr->nOrderPos, me.mapValue); + WriteOrderPos(nOrderPos, me.mapValue); - if (!(thisPtr->mapValue.empty() && thisPtr->_ssExtra.empty())) + if (!(mapValue.empty() && _ssExtra.empty())) { CDataStream ss(nType, nVersion); ss.insert(ss.begin(), '\0'); - ss << thisPtr->mapValue; - ss.insert(ss.end(), thisPtr->_ssExtra.begin(), thisPtr->_ssExtra.end()); + ss << mapValue; + ss.insert(ss.end(), _ssExtra.begin(), _ssExtra.end()); me.strComment.append(ss.str()); } } - READWRITE(LIMITED_STRING(thisPtr->strComment, 65536)); + READWRITE(LIMITED_STRING(strComment, 65536)); - size_t nSepPos = thisPtr->strComment.find("\0", 0, 1); + size_t nSepPos = strComment.find("\0", 0, 1); if (fRead) { me.mapValue.clear(); if (std::string::npos != nSepPos) { - CDataStream ss(std::vector(thisPtr->strComment.begin() + nSepPos + 1, thisPtr->strComment.end()), nType, nVersion); + CDataStream ss(std::vector(strComment.begin() + nSepPos + 1, strComment.end()), nType, nVersion); ss >> me.mapValue; me._ssExtra = std::vector(ss.begin(), ss.end()); } diff --git a/src/walletdb.h b/src/walletdb.h index e14c137ba..2dd257c2c 100644 --- a/src/walletdb.h +++ b/src/walletdb.h @@ -54,14 +54,14 @@ public: nCreateTime = nCreateTime_; } - IMPLEMENT_SERIALIZE + IMPLEMENT_SERIALIZE; - template - inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { + template + inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { size_t nSerSize = 0; - READWRITE(thisPtr->nVersion); - nVersion = thisPtr->nVersion; - READWRITE(thisPtr->nCreateTime); + READWRITE(this->nVersion); + nVersion = this->nVersion; + READWRITE(nCreateTime); return nSerSize; }