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.tags/v0.15.1
@@ -46,16 +46,16 @@ private: | |||
public: | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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; | |||
} | |||
@@ -46,26 +46,26 @@ public: | |||
std::string strStatusBar; | |||
std::string strReserved; | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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(LIMITED_STRING(thisPtr->strComment, 65536)); | |||
READWRITE(LIMITED_STRING(thisPtr->strStatusBar, 256)); | |||
READWRITE(LIMITED_STRING(thisPtr->strReserved, 256)); | |||
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(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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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; | |||
} | |||
@@ -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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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; | |||
} | |||
@@ -31,12 +31,12 @@ public: | |||
COutPoint() { SetNull(); } | |||
COutPoint(uint256 hashIn, uint32_t nIn) { hash = hashIn; n = nIn; } | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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<unsigned int>::max()); | |||
CTxIn(uint256 hashPrevTx, uint32_t nOut, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=std::numeric_limits<uint32_t>::max()); | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { | |||
size_t nSerSize = 0; | |||
bool fRead = boost::is_same<Operation, CSerActionUnserialize>(); | |||
READWRITE(*const_cast<int32_t*>(&thisPtr->nVersion)); | |||
nVersion = thisPtr->nVersion; | |||
READWRITE(*const_cast<std::vector<CTxIn>*>(&thisPtr->vin)); | |||
READWRITE(*const_cast<std::vector<CTxOut>*>(&thisPtr->vout)); | |||
READWRITE(*const_cast<uint32_t*>(&thisPtr->nLockTime)); | |||
READWRITE(*const_cast<int32_t*>(&this->nVersion)); | |||
nVersion = this->nVersion; | |||
READWRITE(*const_cast<std::vector<CTxIn>*>(&vin)); | |||
READWRITE(*const_cast<std::vector<CTxOut>*>(&vout)); | |||
READWRITE(*const_cast<uint32_t*>(&nLockTime)); | |||
if (fRead) | |||
thisPtr->UpdateHash(); | |||
UpdateHash(); | |||
return nSerSize; | |||
} | |||
@@ -324,17 +324,17 @@ struct CMutableTransaction | |||
CMutableTransaction(); | |||
CMutableTransaction(const CTransaction& tx); | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { | |||
bool fRead = boost::is_same<Operation, CSerActionUnserialize>(); | |||
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<CTxInUndo> vprevout; | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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; | |||
} |
@@ -43,16 +43,16 @@ public: | |||
// such as the various parameters to scrypt | |||
std::vector<unsigned char> vchOtherDerivationParameters; | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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; | |||
} | |||
@@ -197,13 +197,13 @@ struct CDiskBlockPos | |||
int nFile; | |||
unsigned int nPos; | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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<CTxUndo> vtxundo; // for all but the coinbase | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { | |||
size_t nSerSize = 0; | |||
bool fRead = boost::is_same<Operation, CSerActionUnserialize>(); | |||
READWRITE(thisPtr->nTransactions); | |||
READWRITE(thisPtr->vHash); | |||
READWRITE(nTransactions); | |||
READWRITE(vHash); | |||
std::vector<unsigned char> vBytes; | |||
if (fRead) { | |||
READWRITE(vBytes); | |||
CPartialMerkleTree &us = *(const_cast<CPartialMerkleTree*>(thisPtr)); | |||
CPartialMerkleTree &us = *(const_cast<CPartialMerkleTree*>(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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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; | |||
} | |||
}; |
@@ -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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { | |||
bool fRead = boost::is_same<Operation, CSerActionUnserialize>(); | |||
size_t nSerSize = 0; | |||
CService* pthis = const_cast<CService*>(thisPtr); | |||
READWRITE(FLATDATA(thisPtr->ip)); | |||
unsigned short portN = htons(thisPtr->port); | |||
CService* pthis = const_cast<CService*>(this); | |||
READWRITE(FLATDATA(ip)); | |||
unsigned short portN = htons(port); | |||
READWRITE(portN); | |||
if (fRead) | |||
pthis->port = ntohs(portN); |
@@ -35,15 +35,15 @@ class CMessageHeader | |||
std::string GetCommand() const; | |||
bool IsValid() const; | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { | |||
size_t nSerSize = 0; | |||
bool fRead = boost::is_same<Operation, CSerActionUnserialize>(); | |||
CAddress* pthis = const_cast<CAddress*>(thisPtr); | |||
CAddress* pthis = const_cast<CAddress*>(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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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; | |||
} | |||
@@ -24,22 +24,22 @@ public: | |||
QDateTime date; | |||
SendCoinsRecipient recipient; | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { | |||
size_t nSerSize = 0; | |||
bool fRead = boost::is_same<Operation, CSerActionUnserialize>(); | |||
RecentRequestEntry* pthis = const_cast<RecentRequestEntry*>(thisPtr); | |||
RecentRequestEntry* pthis = const_cast<RecentRequestEntry*>(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); |
@@ -59,14 +59,14 @@ public: | |||
static const int CURRENT_VERSION = 1; | |||
int nVersion; | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { | |||
size_t nSerSize = 0; | |||
bool fRead = boost::is_same<Operation, CSerActionUnserialize>(); | |||
SendCoinsRecipient* pthis = const_cast<SendCoinsRecipient*>(thisPtr); | |||
SendCoinsRecipient* pthis = const_cast<SendCoinsRecipient*>(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); |
@@ -38,12 +38,12 @@ inline T& REF(const T& val) | |||
return const_cast<T&>(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<typename T> | |||
inline T MAKE_CONST(T val) | |||
inline T* NCONST_PTR(const T* val) | |||
{ | |||
return const_cast<const T>(val); | |||
return const_cast<T*>(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<typename Stream> \ | |||
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<typename Stream> \ | |||
void Unserialize(Stream& s, int nType, int nVersion) { \ | |||
SerializationOp(this, s, CSerActionUnserialize(), nType, nVersion); \ | |||
SerializationOp(s, CSerActionUnserialize(), nType, nVersion); \ | |||
} | |||
@@ -63,15 +63,15 @@ public: | |||
CKeyPool(); | |||
CKeyPool(const CPubKey& vchPubKeyIn); | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { | |||
size_t nSerSize = 0; | |||
bool fRead = boost::is_same<Operation, CSerActionUnserialize>(); | |||
CWalletTx* pthis = const_cast<CWalletTx*>(thisPtr); | |||
CWalletTx* pthis = const_cast<CWalletTx*>(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<CMerkleTx> 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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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 <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
inline size_t SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { | |||
size_t nSerSize = 0; | |||
bool fRead = boost::is_same<Operation, CSerActionUnserialize>(); | |||
CAccountingEntry& me = *const_cast<CAccountingEntry*>(thisPtr); | |||
CAccountingEntry& me = *const_cast<CAccountingEntry*>(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<char>(thisPtr->strComment.begin() + nSepPos + 1, thisPtr->strComment.end()), nType, nVersion); | |||
CDataStream ss(std::vector<char>(strComment.begin() + nSepPos + 1, strComment.end()), nType, nVersion); | |||
ss >> me.mapValue; | |||
me._ssExtra = std::vector<char>(ss.begin(), ss.end()); | |||
} |
@@ -54,14 +54,14 @@ public: | |||
nCreateTime = nCreateTime_; | |||
} | |||
IMPLEMENT_SERIALIZE | |||
IMPLEMENT_SERIALIZE; | |||
template <typename T, typename Stream, typename Operation> | |||
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) { | |||
template <typename Stream, typename Operation> | |||
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; | |||
} | |||