DragonX/dragonx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Get rid of nType and nVersion

Browse Source 
Remove the nType and nVersion as parameters to all serialization methods
and functions. There is only one place where it's read and has an impact
(in CAddress), and even there it does not impact any of the recursively
invoked serializers.

Instead, the few places that need nType or nVersion are changed to read
it directly from the stream object, through GetType() and GetVersion()
methods which are added to all stream classes.
This commit is contained in:
Pieter Wuille
2016-10-28 16:29:17 -07:00
committed by Jack Grigg
parent a8e5ae92ba
commit 242f1421db
29 changed files with 267 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/addrman.h
View File

@@ -54,7 +54,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(*(CAddress*)this); READWRITE(*(CAddress*)this);
READWRITE(source); READWRITE(source);
READWRITE(nLastSuccess); READWRITE(nLastSuccess);
@@ -279,7 +279,7 @@ public:
* very little in common. * very little in common.
*/ */
template<typename Stream> template<typename Stream>
void Serialize(Stream &s, int nType, int nVersionDummy) const void Serialize(Stream &s) const
{ {
LOCK(cs); LOCK(cs);
@@ -329,7 +329,7 @@ public:
} }
template<typename Stream> template<typename Stream>
void Unserialize(Stream& s, int nType, int nVersionDummy) void Unserialize(Stream& s)
{ {
LOCK(cs); LOCK(cs);

2
src/amount.h
View File

@@ -56,7 +56,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(nSatoshisPerK); READWRITE(nSatoshisPerK);
} }
}; };

2
src/bloom.h
View File

@@ -73,7 +73,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(vData); READWRITE(vData);
READWRITE(nHashFuncs); READWRITE(nHashFuncs);
READWRITE(nTweak); READWRITE(nTweak);

7
src/chain.h
View File

@@ -26,7 +26,7 @@ struct CDiskBlockPos
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(VARINT(nFile)); READWRITE(VARINT(nFile));
READWRITE(VARINT(nPos)); READWRITE(VARINT(nPos));
} }
@@ -340,8 +340,9 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (!(nType & SER_GETHASH)) int nVersion = s.GetVersion();
if (!(s.GetType() & SER_GETHASH))
READWRITE(VARINT(nVersion)); READWRITE(VARINT(nVersion));
READWRITE(VARINT(nHeight)); READWRITE(VARINT(nHeight));

24
src/coins.h
View File

@@ -154,7 +154,7 @@ public:
} }
template<typename Stream> template<typename Stream>
void Serialize(Stream &s, int nType, int nVersion) const { void Serialize(Stream &s) const {
unsigned int nMaskSize = 0, nMaskCode = 0; unsigned int nMaskSize = 0, nMaskCode = 0;
CalcMaskSize(nMaskSize, nMaskCode); CalcMaskSize(nMaskSize, nMaskCode);
bool fFirst = vout.size() > 0 && !vout[0].IsNull(); bool fFirst = vout.size() > 0 && !vout[0].IsNull();
@@ -162,33 +162,33 @@ public:
assert(fFirst || fSecond || nMaskCode); assert(fFirst || fSecond || nMaskCode);
unsigned int nCode = 8*(nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fCoinBase ? 1 : 0) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0); unsigned int nCode = 8*(nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fCoinBase ? 1 : 0) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
// version // version
::Serialize(s, VARINT(this->nVersion), nType, nVersion); ::Serialize(s, VARINT(this->nVersion));
// header code // header code
::Serialize(s, VARINT(nCode), nType, nVersion); ::Serialize(s, VARINT(nCode));
// spentness bitmask // spentness bitmask
for (unsigned int b = 0; b<nMaskSize; b++) { for (unsigned int b = 0; b<nMaskSize; b++) {
unsigned char chAvail = 0; unsigned char chAvail = 0;
for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++) for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++)
if (!vout[2+b*8+i].IsNull()) if (!vout[2+b*8+i].IsNull())
chAvail |= (1 << i); chAvail |= (1 << i);
::Serialize(s, chAvail, nType, nVersion); ::Serialize(s, chAvail);
} }
// txouts themself // txouts themself
for (unsigned int i = 0; i < vout.size(); i++) { for (unsigned int i = 0; i < vout.size(); i++) {
if (!vout[i].IsNull()) if (!vout[i].IsNull())
::Serialize(s, CTxOutCompressor(REF(vout[i])), nType, nVersion); ::Serialize(s, CTxOutCompressor(REF(vout[i])));
} }
// coinbase height // coinbase height
::Serialize(s, VARINT(nHeight), nType, nVersion); ::Serialize(s, VARINT(nHeight));
} }
template<typename Stream> template<typename Stream>
void Unserialize(Stream &s, int nType, int nVersion) { void Unserialize(Stream &s) {
unsigned int nCode = 0; unsigned int nCode = 0;
// version // version
::Unserialize(s, VARINT(this->nVersion), nType, nVersion); ::Unserialize(s, VARINT(this->nVersion));
// header code // header code
::Unserialize(s, VARINT(nCode), nType, nVersion); ::Unserialize(s, VARINT(nCode));
fCoinBase = nCode & 1; fCoinBase = nCode & 1;
std::vector<bool> vAvail(2, false); std::vector<bool> vAvail(2, false);
vAvail[0] = (nCode & 2) != 0; vAvail[0] = (nCode & 2) != 0;
@@ -197,7 +197,7 @@ public:
// spentness bitmask // spentness bitmask
while (nMaskCode > 0) { while (nMaskCode > 0) {
unsigned char chAvail = 0; unsigned char chAvail = 0;
::Unserialize(s, chAvail, nType, nVersion); ::Unserialize(s, chAvail);
for (unsigned int p = 0; p < 8; p++) { for (unsigned int p = 0; p < 8; p++) {
bool f = (chAvail & (1 << p)) != 0; bool f = (chAvail & (1 << p)) != 0;
vAvail.push_back(f); vAvail.push_back(f);
@@ -209,10 +209,10 @@ public:
vout.assign(vAvail.size(), CTxOut()); vout.assign(vAvail.size(), CTxOut());
for (unsigned int i = 0; i < vAvail.size(); i++) { for (unsigned int i = 0; i < vAvail.size(); i++) {
if (vAvail[i]) if (vAvail[i])
::Unserialize(s, REF(CTxOutCompressor(vout[i])), nType, nVersion); ::Unserialize(s, REF(CTxOutCompressor(vout[i])));
} }
// coinbase height // coinbase height
::Unserialize(s, VARINT(nHeight), nType, nVersion); ::Unserialize(s, VARINT(nHeight));
Cleanup(); Cleanup();
} }

6
src/compressor.h
View File

@@ -56,7 +56,7 @@ public:
CScriptCompressor(CScript &scriptIn) : script(scriptIn) { } CScriptCompressor(CScript &scriptIn) : script(scriptIn) { }
template<typename Stream> template<typename Stream>
void Serialize(Stream &s, int nType, int nVersion) const { void Serialize(Stream &s) const {
std::vector<unsigned char> compr; std::vector<unsigned char> compr;
if (Compress(compr)) { if (Compress(compr)) {
s << CFlatData(compr); s << CFlatData(compr);
@@ -68,7 +68,7 @@ public:
} }
template<typename Stream> template<typename Stream>
void Unserialize(Stream &s, int nType, int nVersion) { void Unserialize(Stream &s) {
unsigned int nSize = 0; unsigned int nSize = 0;
s >> VARINT(nSize); s >> VARINT(nSize);
if (nSize < nSpecialScripts) { if (nSize < nSpecialScripts) {
@@ -104,7 +104,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (!ser_action.ForRead()) { if (!ser_action.ForRead()) {
uint64_t nVal = CompressAmount(txout.nValue); uint64_t nVal = CompressAmount(txout.nValue);
READWRITE(VARINT(nVal)); READWRITE(VARINT(nVal));

5
src/hash.h
View File

@@ -140,6 +140,9 @@ public:
CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {} CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
int GetType() const { return nType; }
int GetVersion() const { return nVersion; }
void write(const char *pch, size_t size) { void write(const char *pch, size_t size) {
ctx.Write((const unsigned char*)pch, size); ctx.Write((const unsigned char*)pch, size);
} }
@@ -154,7 +157,7 @@ public:
template<typename T> template<typename T>
CHashWriter& operator<<(const T& obj) { CHashWriter& operator<<(const T& obj) {
// Serialize to this stream // Serialize to this stream
::Serialize(*this, obj, nType, nVersion); ::Serialize(*this, obj);
return (*this); return (*this);
} }
}; };

4
src/key.h
View File

@@ -176,7 +176,7 @@ struct CExtKey {
CExtPubKey Neuter() const; CExtPubKey Neuter() const;
void SetMaster(const unsigned char* seed, unsigned int nSeedLen); void SetMaster(const unsigned char* seed, unsigned int nSeedLen);
template <typename Stream> template <typename Stream>
void Serialize(Stream& s, int nType, int nVersion) const void Serialize(Stream& s) const
{ {
unsigned int len = BIP32_EXTKEY_SIZE; unsigned int len = BIP32_EXTKEY_SIZE;
::WriteCompactSize(s, len); ::WriteCompactSize(s, len);
@@ -185,7 +185,7 @@ struct CExtKey {
s.write((const char *)&code[0], len); s.write((const char *)&code[0], len);
} }
template <typename Stream> template <typename Stream>
void Unserialize(Stream& s, int nType, int nVersion) void Unserialize(Stream& s)
{ {
unsigned int len = ::ReadCompactSize(s); unsigned int len = ::ReadCompactSize(s);
unsigned char code[BIP32_EXTKEY_SIZE]; unsigned char code[BIP32_EXTKEY_SIZE];

4
src/main.h
View File

@@ -273,7 +273,7 @@ struct CDiskTxPos : public CDiskBlockPos
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(*(CDiskBlockPos*)this); READWRITE(*(CDiskBlockPos*)this);
READWRITE(VARINT(nTxOffset)); READWRITE(VARINT(nTxOffset));
} }
@@ -493,7 +493,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(VARINT(nBlocks)); READWRITE(VARINT(nBlocks));
READWRITE(VARINT(nSize)); READWRITE(VARINT(nSize));
READWRITE(VARINT(nUndoSize)); READWRITE(VARINT(nUndoSize));

4
src/merkleblock.h
View File

@@ -85,7 +85,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(nTransactions); READWRITE(nTransactions);
READWRITE(vHash); READWRITE(vHash);
std::vector<unsigned char> vBytes; std::vector<unsigned char> vBytes;
@@ -147,7 +147,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(header); READWRITE(header);
READWRITE(txn); READWRITE(txn);
} }

4
src/netbase.h
View File

@@ -97,7 +97,7 @@ class CNetAddr
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(FLATDATA(ip)); READWRITE(FLATDATA(ip));
} }
@@ -162,7 +162,7 @@ class CService : public CNetAddr
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(FLATDATA(ip)); READWRITE(FLATDATA(ip));
unsigned short portN = htons(port); unsigned short portN = htons(port);
READWRITE(FLATDATA(portN)); READWRITE(FLATDATA(portN));

9
src/primitives/block.h
View File

@@ -40,7 +40,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(this->nVersion); READWRITE(this->nVersion);
nVersion = this->nVersion; nVersion = this->nVersion;
READWRITE(hashPrevBlock); READWRITE(hashPrevBlock);
@@ -101,7 +101,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(*(CBlockHeader*)this); READWRITE(*(CBlockHeader*)this);
READWRITE(vtx); READWRITE(vtx);
} }
@@ -185,8 +185,9 @@ struct CBlockLocator
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (!(nType & SER_GETHASH)) int nVersion = s.GetVersion();
if (!(s.GetType() & SER_GETHASH))
READWRITE(nVersion); READWRITE(nVersion);
READWRITE(vHave); READWRITE(vHave);
} }

10
src/primitives/transaction.h
View File

@@ -157,7 +157,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(hash); READWRITE(hash);
READWRITE(n); READWRITE(n);
} }
@@ -205,7 +205,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(prevout); READWRITE(prevout);
READWRITE(*(CScriptBase*)(&scriptSig)); READWRITE(*(CScriptBase*)(&scriptSig));
READWRITE(nSequence); READWRITE(nSequence);
@@ -250,7 +250,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(nValue); READWRITE(nValue);
READWRITE(*(CScriptBase*)(&scriptPubKey)); READWRITE(*(CScriptBase*)(&scriptPubKey));
} }
@@ -372,7 +372,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (ser_action.ForRead()) { if (ser_action.ForRead()) {
// When deserializing, unpack the 4 byte header to extract fOverwintered and nVersion. // When deserializing, unpack the 4 byte header to extract fOverwintered and nVersion.
uint32_t header; uint32_t header;
@@ -482,7 +482,7 @@ struct CMutableTransaction
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (ser_action.ForRead()) { if (ser_action.ForRead()) {
// When deserializing, unpack the 4 byte header to extract fOverwintered and nVersion. // When deserializing, unpack the 4 byte header to extract fOverwintered and nVersion.
uint32_t header; uint32_t header;

13
src/protocol.h
View File

@@ -40,7 +40,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) inline void SerializationOp(Stream& s, Operation ser_action)
{ {
READWRITE(FLATDATA(pchMessageStart)); READWRITE(FLATDATA(pchMessageStart));
READWRITE(FLATDATA(pchCommand)); READWRITE(FLATDATA(pchCommand));
@@ -97,14 +97,15 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) inline void SerializationOp(Stream& s, Operation ser_action)
{ {
if (ser_action.ForRead()) if (ser_action.ForRead())
Init(); Init();
if (nType & SER_DISK) int nVersion = s.GetVersion();
if (s.GetType() & SER_DISK)
READWRITE(nVersion); READWRITE(nVersion);
if ((nType & SER_DISK) || if ((s.GetType() & SER_DISK) ||
(nVersion >= CADDR_TIME_VERSION && !(nType & SER_GETHASH))) (nVersion >= CADDR_TIME_VERSION && !(s.GetType() & SER_GETHASH)))
READWRITE(nTime); READWRITE(nTime);
READWRITE(nServices); READWRITE(nServices);
READWRITE(*(CService*)this); READWRITE(*(CService*)this);
@@ -129,7 +130,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) inline void SerializationOp(Stream& s, Operation ser_action)
{ {
READWRITE(type); READWRITE(type);
READWRITE(hash); READWRITE(hash);

8
src/pubkey.h
View File

@@ -124,14 +124,14 @@ public:
//! Implement serialization, as if this was a byte vector. //! Implement serialization, as if this was a byte vector.
template <typename Stream> template <typename Stream>
void Serialize(Stream& s, int nType, int nVersion) const void Serialize(Stream& s) const
{ {
unsigned int len = size(); unsigned int len = size();
::WriteCompactSize(s, len); ::WriteCompactSize(s, len);
s.write((char*)vch, len); s.write((char*)vch, len);
} }
template <typename Stream> template <typename Stream>
void Unserialize(Stream& s, int nType, int nVersion) void Unserialize(Stream& s)
{ {
unsigned int len = ::ReadCompactSize(s); unsigned int len = ::ReadCompactSize(s);
if (len <= PUBLIC_KEY_SIZE) { if (len <= PUBLIC_KEY_SIZE) {
@@ -215,7 +215,7 @@ struct CExtPubKey {
bool Derive(CExtPubKey& out, unsigned int nChild) const; bool Derive(CExtPubKey& out, unsigned int nChild) const;
template <typename Stream> template <typename Stream>
void Serialize(Stream& s, int nType, int nVersion) const void Serialize(Stream& s) const
{ {
unsigned int len = BIP32_EXTKEY_SIZE; unsigned int len = BIP32_EXTKEY_SIZE;
::WriteCompactSize(s, len); ::WriteCompactSize(s, len);
@@ -224,7 +224,7 @@ struct CExtPubKey {
s.write((const char *)&code[0], len); s.write((const char *)&code[0], len);
} }
template <typename Stream> template <typename Stream>
void Unserialize(Stream& s, int nType, int nVersion) void Unserialize(Stream& s)
{ {
unsigned int len = ::ReadCompactSize(s); unsigned int len = ::ReadCompactSize(s);
unsigned char code[BIP32_EXTKEY_SIZE]; unsigned char code[BIP32_EXTKEY_SIZE];

2
src/rest.cpp
View File

@@ -48,7 +48,7 @@ struct CCoin {
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) inline void SerializationOp(Stream& s, Operation ser_action)
{ {
READWRITE(nTxVer); READWRITE(nTxVer);
READWRITE(nHeight); READWRITE(nHeight);

30
src/script/interpreter.cpp
View File

@@ -981,7 +981,7 @@ public:
/** Serialize the passed scriptCode */ /** Serialize the passed scriptCode */
template<typename S> template<typename S>
void SerializeScriptCode(S &s, int nType, int nVersion) const { void SerializeScriptCode(S &s) const {
auto size = scriptCode.size(); auto size = scriptCode.size();
::WriteCompactSize(s, size); ::WriteCompactSize(s, size);
s.write((char*)&scriptCode.begin()[0], size); s.write((char*)&scriptCode.begin()[0], size);
@@ -989,54 +989,54 @@ public:
/** Serialize an input of txTo */ /** Serialize an input of txTo */
template<typename S> template<typename S>
void SerializeInput(S &s, unsigned int nInput, int nType, int nVersion) const { void SerializeInput(S &s, unsigned int nInput) const {
// In case of SIGHASH_ANYONECANPAY, only the input being signed is serialized // In case of SIGHASH_ANYONECANPAY, only the input being signed is serialized
if (fAnyoneCanPay) if (fAnyoneCanPay)
nInput = nIn; nInput = nIn;
// Serialize the prevout // Serialize the prevout
::Serialize(s, txTo.vin[nInput].prevout, nType, nVersion); ::Serialize(s, txTo.vin[nInput].prevout);
// Serialize the script // Serialize the script
assert(nInput != NOT_AN_INPUT); assert(nInput != NOT_AN_INPUT);
if (nInput != nIn) if (nInput != nIn)
// Blank out other inputs' signatures // Blank out other inputs' signatures
::Serialize(s, CScriptBase(), nType, nVersion); ::Serialize(s, CScriptBase());
else else
SerializeScriptCode(s, nType, nVersion); SerializeScriptCode(s);
// Serialize the nSequence // Serialize the nSequence
if (nInput != nIn && (fHashSingle || fHashNone)) if (nInput != nIn && (fHashSingle || fHashNone))
// let the others update at will // let the others update at will
::Serialize(s, (int)0, nType, nVersion); ::Serialize(s, (int)0);
else else
::Serialize(s, txTo.vin[nInput].nSequence, nType, nVersion); ::Serialize(s, txTo.vin[nInput].nSequence);
} }
/** Serialize an output of txTo */ /** Serialize an output of txTo */
template<typename S> template<typename S>
void SerializeOutput(S &s, unsigned int nOutput, int nType, int nVersion) const { void SerializeOutput(S &s, unsigned int nOutput) const {
if (fHashSingle && nOutput != nIn) if (fHashSingle && nOutput != nIn)
// Do not lock-in the txout payee at other indices as txin // Do not lock-in the txout payee at other indices as txin
::Serialize(s, CTxOut(), nType, nVersion); ::Serialize(s, CTxOut());
else else
::Serialize(s, txTo.vout[nOutput], nType, nVersion); ::Serialize(s, txTo.vout[nOutput]);
} }
/** Serialize txTo */ /** Serialize txTo */
template<typename S> template<typename S>
void Serialize(S &s, int nType, int nVersion) const { void Serialize(S &s) const {
// Serialize nVersion // Serialize nVersion
::Serialize(s, txTo.nVersion, nType, nVersion); ::Serialize(s, txTo.nVersion);
// Serialize vin // Serialize vin
unsigned int nInputs = fAnyoneCanPay ? 1 : txTo.vin.size(); unsigned int nInputs = fAnyoneCanPay ? 1 : txTo.vin.size();
::WriteCompactSize(s, nInputs); ::WriteCompactSize(s, nInputs);
for (unsigned int nInput = 0; nInput < nInputs; nInput++) for (unsigned int nInput = 0; nInput < nInputs; nInput++)
SerializeInput(s, nInput, nType, nVersion); SerializeInput(s, nInput);
// Serialize vout // Serialize vout
unsigned int nOutputs = fHashNone ? 0 : (fHashSingle ? nIn+1 : txTo.vout.size()); unsigned int nOutputs = fHashNone ? 0 : (fHashSingle ? nIn+1 : txTo.vout.size());
::WriteCompactSize(s, nOutputs); ::WriteCompactSize(s, nOutputs);
for (unsigned int nOutput = 0; nOutput < nOutputs; nOutput++) for (unsigned int nOutput = 0; nOutput < nOutputs; nOutput++)
SerializeOutput(s, nOutput, nType, nVersion); SerializeOutput(s, nOutput);
// Serialize nLockTime // Serialize nLockTime
::Serialize(s, txTo.nLockTime, nType, nVersion); ::Serialize(s, txTo.nLockTime);
// Serialize vjoinsplit // Serialize vjoinsplit
if (txTo.nVersion >= 2) { if (txTo.nVersion >= 2) {

4
src/script/zcashconsensus.cpp
View File

@@ -43,10 +43,12 @@ public:
template<typename T> template<typename T>
TxInputStream& operator>>(T& obj) TxInputStream& operator>>(T& obj)
{ {
::Unserialize(*this, obj, m_type, m_version); ::Unserialize(*this, obj);
return *this; return *this;
} }
int GetVersion() const { return m_version; }
int GetType() const { return m_type; }
private: private:
const int m_type; const int m_type;
const int m_version; const int m_version;

256
src/serialize.h
View File

@@ -164,8 +164,8 @@ enum
SER_GETHASH = (1 << 2), SER_GETHASH = (1 << 2),
}; };
#define READWRITE(obj) (::SerReadWrite(s, (obj), nType, nVersion, ser_action)) #define READWRITE(obj) (::SerReadWrite(s, (obj), ser_action))
#define READWRITEMANY(...) (::SerReadWriteMany(s, nType, nVersion, ser_action, __VA_ARGS__)) #define READWRITEMANY(...) (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
/** /**
* Implement three methods for serializable objects. These are actually wrappers over * Implement three methods for serializable objects. These are actually wrappers over
@@ -173,45 +173,42 @@ enum
* code. Adding "ADD_SERIALIZE_METHODS" in the body of the class causes these wrappers to be * code. Adding "ADD_SERIALIZE_METHODS" in the body of the class causes these wrappers to be
* added as members. * added as members.
*/ */
#define ADD_SERIALIZE_METHODS \ #define ADD_SERIALIZE_METHODS \
template<typename Stream> \ template<typename Stream> \
void Serialize(Stream& s, int nType, int nVersion) const { \ void Serialize(Stream& s) const { \
NCONST_PTR(this)->SerializationOp(s, CSerActionSerialize(), nType, nVersion);\ NCONST_PTR(this)->SerializationOp(s, CSerActionSerialize()); \
} \ } \
template<typename Stream> \ template<typename Stream> \
void Unserialize(Stream& s, int nType, int nVersion) { \ void Unserialize(Stream& s) { \
SerializationOp(s, CSerActionUnserialize(), nType, nVersion); \ SerializationOp(s, CSerActionUnserialize()); \
} }
/* template<typename Stream> inline void Serialize(Stream& s, char a ) { ser_writedata8(s, a); } // TODO Get rid of bare char
* Basic Types template<typename Stream> inline void Serialize(Stream& s, int8_t a ) { ser_writedata8(s, a); }
*/ template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
template<typename Stream> inline void Serialize(Stream& s, char a, int, int=0) { ser_writedata8(s, a); } // TODO Get rid of bare char template<typename Stream> inline void Serialize(Stream& s, int16_t a ) { ser_writedata16(s, a); }
template<typename Stream> inline void Serialize(Stream& s, int8_t a, int, int=0) { ser_writedata8(s, a); } template<typename Stream> inline void Serialize(Stream& s, uint16_t a) { ser_writedata16(s, a); }
template<typename Stream> inline void Serialize(Stream& s, uint8_t a, int, int=0) { ser_writedata8(s, a); } template<typename Stream> inline void Serialize(Stream& s, int32_t a ) { ser_writedata32(s, a); }
template<typename Stream> inline void Serialize(Stream& s, int16_t a, int, int=0) { ser_writedata16(s, a); } template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
template<typename Stream> inline void Serialize(Stream& s, uint16_t a, int, int=0) { ser_writedata16(s, a); } template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
template<typename Stream> inline void Serialize(Stream& s, int32_t a, int, int=0) { ser_writedata32(s, a); } template<typename Stream> inline void Serialize(Stream& s, uint64_t a) { ser_writedata64(s, a); }
template<typename Stream> inline void Serialize(Stream& s, uint32_t a, int, int=0) { ser_writedata32(s, a); } template<typename Stream> inline void Serialize(Stream& s, float a ) { ser_writedata32(s, ser_float_to_uint32(a)); }
template<typename Stream> inline void Serialize(Stream& s, int64_t a, int, int=0) { ser_writedata64(s, a); } template<typename Stream> inline void Serialize(Stream& s, double a ) { ser_writedata64(s, ser_double_to_uint64(a)); }
template<typename Stream> inline void Serialize(Stream& s, uint64_t a, int, int=0) { ser_writedata64(s, a); }
template<typename Stream> inline void Serialize(Stream& s, float a, int, int=0) { ser_writedata32(s, ser_float_to_uint32(a)); }
template<typename Stream> inline void Serialize(Stream& s, double a, int, int=0) { ser_writedata64(s, ser_double_to_uint64(a)); }
template<typename Stream> inline void Unserialize(Stream& s, char& a, int, int=0) { a = ser_readdata8(s); } // TODO Get rid of bare char template<typename Stream> inline void Unserialize(Stream& s, char& a ) { a = ser_readdata8(s); } // TODO Get rid of bare char
template<typename Stream> inline void Unserialize(Stream& s, int8_t& a, int, int=0) { a = ser_readdata8(s); } template<typename Stream> inline void Unserialize(Stream& s, int8_t& a ) { a = ser_readdata8(s); }
template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a, int, int=0) { a = ser_readdata8(s); } template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a ) { a = ser_readdata8(s); }
template<typename Stream> inline void Unserialize(Stream& s, int16_t& a, int, int=0) { a = ser_readdata16(s); } template<typename Stream> inline void Unserialize(Stream& s, int16_t& a ) { a = ser_readdata16(s); }
template<typename Stream> inline void Unserialize(Stream& s, uint16_t& a, int, int=0) { a = ser_readdata16(s); } template<typename Stream> inline void Unserialize(Stream& s, uint16_t& a) { a = ser_readdata16(s); }
template<typename Stream> inline void Unserialize(Stream& s, int32_t& a, int, int=0) { a = ser_readdata32(s); } template<typename Stream> inline void Unserialize(Stream& s, int32_t& a ) { a = ser_readdata32(s); }
template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a, int, int=0) { a = ser_readdata32(s); } template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
template<typename Stream> inline void Unserialize(Stream& s, int64_t& a, int, int=0) { a = ser_readdata64(s); } template<typename Stream> inline void Unserialize(Stream& s, int64_t& a ) { a = ser_readdata64(s); }
template<typename Stream> inline void Unserialize(Stream& s, uint64_t& a, int, int=0) { a = ser_readdata64(s); } template<typename Stream> inline void Unserialize(Stream& s, uint64_t& a) { a = ser_readdata64(s); }
template<typename Stream> inline void Unserialize(Stream& s, float& a, int, int=0) { a = ser_uint32_to_float(ser_readdata32(s)); } template<typename Stream> inline void Unserialize(Stream& s, float& a ) { a = ser_uint32_to_float(ser_readdata32(s)); }
template<typename Stream> inline void Unserialize(Stream& s, double& a, int, int=0) { a = ser_uint64_to_double(ser_readdata64(s)); } template<typename Stream> inline void Unserialize(Stream& s, double& a ) { a = ser_uint64_to_double(ser_readdata64(s)); }
template<typename Stream> inline void Serialize(Stream& s, bool a, int, int=0) { char f=a; ser_writedata8(s, f); } template<typename Stream> inline void Serialize(Stream& s, bool a) { char f=a; ser_writedata8(s, f); }
template<typename Stream> inline void Unserialize(Stream& s, bool& a, int, int=0) { char f=ser_readdata8(s); a=f; } template<typename Stream> inline void Unserialize(Stream& s, bool& a) { char f=ser_readdata8(s); a=f; }
@@ -390,13 +387,13 @@ public:
const char* end() const { return pend; } const char* end() const { return pend; }
template<typename Stream> template<typename Stream>
void Serialize(Stream& s, int, int=0) const void Serialize(Stream& s) const
{ {
s.write(pbegin, pend - pbegin); s.write(pbegin, pend - pbegin);
} }
template<typename Stream> template<typename Stream>
void Unserialize(Stream& s, int, int=0) void Unserialize(Stream& s)
{ {
s.read(pbegin, pend - pbegin); s.read(pbegin, pend - pbegin);
} }
@@ -411,12 +408,12 @@ public:
CVarInt(I& nIn) : n(nIn) { } CVarInt(I& nIn) : n(nIn) { }
template<typename Stream> template<typename Stream>
void Serialize(Stream &s, int, int) const { void Serialize(Stream &s) const {
WriteVarInt<Stream,I>(s, n); WriteVarInt<Stream,I>(s, n);
} }
template<typename Stream> template<typename Stream>
void Unserialize(Stream& s, int, int) { void Unserialize(Stream& s) {
n = ReadVarInt<Stream,I>(s); n = ReadVarInt<Stream,I>(s);
} }
}; };
@@ -429,12 +426,12 @@ public:
CCompactSize(uint64_t& nIn) : n(nIn) { } CCompactSize(uint64_t& nIn) : n(nIn) { }
template<typename Stream> template<typename Stream>
void Serialize(Stream &s, int, int) const { void Serialize(Stream &s) const {
WriteCompactSize<Stream>(s, n); WriteCompactSize<Stream>(s, n);
} }
template<typename Stream> template<typename Stream>
void Unserialize(Stream& s, int, int) { void Unserialize(Stream& s) {
n = ReadCompactSize<Stream>(s); n = ReadCompactSize<Stream>(s);
} }
}; };
@@ -448,7 +445,7 @@ public:
LimitedString(std::string& string) : string(string) {} LimitedString(std::string& string) : string(string) {}
template<typename Stream> template<typename Stream>
void Unserialize(Stream& s, int, int=0) void Unserialize(Stream& s)
{ {
size_t size = ReadCompactSize(s); size_t size = ReadCompactSize(s);
if (size > Limit) { if (size > Limit) {
@@ -460,7 +457,7 @@ public:
} }
template<typename Stream> template<typename Stream>
void Serialize(Stream& s, int, int=0) const void Serialize(Stream& s) const
{ {
WriteCompactSize(s, string.size()); WriteCompactSize(s, string.size());
if (!string.empty()) if (!string.empty())
@@ -478,30 +475,30 @@ CVarInt<I> WrapVarInt(I& n) { return CVarInt<I>(n); }
/** /**
* string * string
*/ */
template<typename Stream, typename C> void Serialize(Stream& os, const std::basic_string<C>& str, int, int=0); template<typename Stream, typename C> void Serialize(Stream& os, const std::basic_string<C>& str);
template<typename Stream, typename C> void Unserialize(Stream& is, std::basic_string<C>& str, int, int=0); template<typename Stream, typename C> void Unserialize(Stream& is, std::basic_string<C>& str);
/** /**
* prevector * prevector
* prevectors of unsigned char are a special case and are intended to be serialized as a single opaque blob. * prevectors of unsigned char are a special case and are intended to be serialized as a single opaque blob.
*/ */
template<typename Stream, unsigned int N, typename T> void Serialize_impl(Stream& os, const prevector<N, T>& v, int nType, int nVersion, const unsigned char&); template<typename Stream, unsigned int N, typename T> void Serialize_impl(Stream& os, const prevector<N, T>& v, const unsigned char&);
template<typename Stream, unsigned int N, typename T, typename V> void Serialize_impl(Stream& os, const prevector<N, T>& v, int nType, int nVersion, const V&); template<typename Stream, unsigned int N, typename T, typename V> void Serialize_impl(Stream& os, const prevector<N, T>& v, const V&);
template<typename Stream, unsigned int N, typename T> inline void Serialize(Stream& os, const prevector<N, T>& v, int nType, int nVersion); template<typename Stream, unsigned int N, typename T> inline void Serialize(Stream& os, const prevector<N, T>& v);
template<typename Stream, unsigned int N, typename T> void Unserialize_impl(Stream& is, prevector<N, T>& v, int nType, int nVersion, const unsigned char&); template<typename Stream, unsigned int N, typename T> void Unserialize_impl(Stream& is, prevector<N, T>& v, const unsigned char&);
template<typename Stream, unsigned int N, typename T, typename V> void Unserialize_impl(Stream& is, prevector<N, T>& v, int nType, int nVersion, const V&); template<typename Stream, unsigned int N, typename T, typename V> void Unserialize_impl(Stream& is, prevector<N, T>& v, const V&);
template<typename Stream, unsigned int N, typename T> inline void Unserialize(Stream& is, prevector<N, T>& v, int nType, int nVersion); template<typename Stream, unsigned int N, typename T> inline void Unserialize(Stream& is, prevector<N, T>& v);
/** /**
* vector * vector
* vectors of unsigned char are a special case and are intended to be serialized as a single opaque blob. * vectors of unsigned char are a special case and are intended to be serialized as a single opaque blob.
*/ */
template<typename Stream, typename T, typename A> void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const unsigned char&); template<typename Stream, typename T, typename A> void Serialize_impl(Stream& os, const std::vector<T, A>& v, const unsigned char&);
template<typename Stream, typename T, typename A, typename V> void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const V&); template<typename Stream, typename T, typename A, typename V> void Serialize_impl(Stream& os, const std::vector<T, A>& v, const V&);
template<typename Stream, typename T, typename A> inline void Serialize(Stream& os, const std::vector<T, A>& v, int nType, int nVersion); template<typename Stream, typename T, typename A> inline void Serialize(Stream& os, const std::vector<T, A>& v);
template<typename Stream, typename T, typename A> void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const unsigned char&); template<typename Stream, typename T, typename A> void Unserialize_impl(Stream& is, std::vector<T, A>& v, const unsigned char&);
template<typename Stream, typename T, typename A, typename V> void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const V&); template<typename Stream, typename T, typename A, typename V> void Unserialize_impl(Stream& is, std::vector<T, A>& v, const V&);
template<typename Stream, typename T, typename A> inline void Unserialize(Stream& is, std::vector<T, A>& v, int nType, int nVersion); template<typename Stream, typename T, typename A> inline void Unserialize(Stream& is, std::vector<T, A>& v);
/** /**
* optional * optional
@@ -518,20 +515,20 @@ template<typename Stream, typename T, std::size_t N> void Unserialize(Stream& is
/** /**
* pair * pair
*/ */
template<typename Stream, typename K, typename T> void Serialize(Stream& os, const std::pair<K, T>& item, int nType, int nVersion); template<typename Stream, typename K, typename T> void Serialize(Stream& os, const std::pair<K, T>& item);
template<typename Stream, typename K, typename T> void Unserialize(Stream& is, std::pair<K, T>& item, int nType, int nVersion); template<typename Stream, typename K, typename T> void Unserialize(Stream& is, std::pair<K, T>& item);
/** /**
* map * map
*/ */
template<typename Stream, typename K, typename T, typename Pred, typename A> void Serialize(Stream& os, const std::map<K, T, Pred, A>& m, int nType, int nVersion); template<typename Stream, typename K, typename T, typename Pred, typename A> void Serialize(Stream& os, const std::map<K, T, Pred, A>& m);
template<typename Stream, typename K, typename T, typename Pred, typename A> void Unserialize(Stream& is, std::map<K, T, Pred, A>& m, int nType, int nVersion); template<typename Stream, typename K, typename T, typename Pred, typename A> void Unserialize(Stream& is, std::map<K, T, Pred, A>& m);
/** /**
* set * set
*/ */
template<typename Stream, typename K, typename Pred, typename A> void Serialize(Stream& os, const std::set<K, Pred, A>& m, int nType, int nVersion); template<typename Stream, typename K, typename Pred, typename A> void Serialize(Stream& os, const std::set<K, Pred, A>& m);
template<typename Stream, typename K, typename Pred, typename A> void Unserialize(Stream& is, std::set<K, Pred, A>& m, int nType, int nVersion); template<typename Stream, typename K, typename Pred, typename A> void Unserialize(Stream& is, std::set<K, Pred, A>& m);
/** /**
* list * list
@@ -545,20 +542,17 @@ template<typename Stream, typename T, typename A> void Unserialize(Stream& is, s
/** /**
* If none of the specialized versions above matched, default to calling member function. * If none of the specialized versions above matched, default to calling member function.
* "int nType" is changed to "long nType" to keep from getting an ambiguous overload error.
* The compiler will only cast int to long if none of the other templates matched.
* Thanks to Boost serialization for this idea.
*/ */
template<typename Stream, typename T> template<typename Stream, typename T>
inline void Serialize(Stream& os, const T& a, long nType, int nVersion) inline void Serialize(Stream& os, const T& a)
{ {
a.Serialize(os, (int)nType, nVersion); a.Serialize(os);
} }
template<typename Stream, typename T> template<typename Stream, typename T>
inline void Unserialize(Stream& is, T& a, long nType, int nVersion) inline void Unserialize(Stream& is, T& a)
{ {
a.Unserialize(is, (int)nType, nVersion); a.Unserialize(is);
} }
@@ -569,7 +563,7 @@ inline void Unserialize(Stream& is, T& a, long nType, int nVersion)
* string * string
*/ */
template<typename Stream, typename C> template<typename Stream, typename C>
void Serialize(Stream& os, const std::basic_string<C>& str, int, int) void Serialize(Stream& os, const std::basic_string<C>& str)
{ {
WriteCompactSize(os, str.size()); WriteCompactSize(os, str.size());
if (!str.empty()) if (!str.empty())
@@ -577,7 +571,7 @@ void Serialize(Stream& os, const std::basic_string<C>& str, int, int)
} }
template<typename Stream, typename C> template<typename Stream, typename C>
void Unserialize(Stream& is, std::basic_string<C>& str, int, int) void Unserialize(Stream& is, std::basic_string<C>& str)
{ {
unsigned int nSize = ReadCompactSize(is); unsigned int nSize = ReadCompactSize(is);
str.resize(nSize); str.resize(nSize);
@@ -591,7 +585,7 @@ void Unserialize(Stream& is, std::basic_string<C>& str, int, int)
* prevector * prevector
*/ */
template<typename Stream, unsigned int N, typename T> template<typename Stream, unsigned int N, typename T>
void Serialize_impl(Stream& os, const prevector<N, T>& v, int nType, int nVersion, const unsigned char&) void Serialize_impl(Stream& os, const prevector<N, T>& v, const unsigned char&)
{ {
WriteCompactSize(os, v.size()); WriteCompactSize(os, v.size());
if (!v.empty()) if (!v.empty())
@@ -599,22 +593,22 @@ void Serialize_impl(Stream& os, const prevector<N, T>& v, int nType, int nVersio
} }
template<typename Stream, unsigned int N, typename T, typename V> template<typename Stream, unsigned int N, typename T, typename V>
void Serialize_impl(Stream& os, const prevector<N, T>& v, int nType, int nVersion, const V&) void Serialize_impl(Stream& os, const prevector<N, T>& v, const V&)
{ {
WriteCompactSize(os, v.size()); WriteCompactSize(os, v.size());
for (typename prevector<N, T>::const_iterator vi = v.begin(); vi != v.end(); ++vi) for (typename prevector<N, T>::const_iterator vi = v.begin(); vi != v.end(); ++vi)
::Serialize(os, (*vi), nType, nVersion); ::Serialize(os, (*vi));
} }
template<typename Stream, unsigned int N, typename T> template<typename Stream, unsigned int N, typename T>
inline void Serialize(Stream& os, const prevector<N, T>& v, int nType, int nVersion) inline void Serialize(Stream& os, const prevector<N, T>& v)
{ {
Serialize_impl(os, v, nType, nVersion, T()); Serialize_impl(os, v, T());
} }
template<typename Stream, unsigned int N, typename T> template<typename Stream, unsigned int N, typename T>
void Unserialize_impl(Stream& is, prevector<N, T>& v, int nType, int nVersion, const unsigned char&) void Unserialize_impl(Stream& is, prevector<N, T>& v, const unsigned char&)
{ {
// Limit size per read so bogus size value won't cause out of memory // Limit size per read so bogus size value won't cause out of memory
v.clear(); v.clear();
@@ -630,7 +624,7 @@ void Unserialize_impl(Stream& is, prevector<N, T>& v, int nType, int nVersion, c
} }
template<typename Stream, unsigned int N, typename T, typename V> template<typename Stream, unsigned int N, typename T, typename V>
void Unserialize_impl(Stream& is, prevector<N, T>& v, int nType, int nVersion, const V&) void Unserialize_impl(Stream& is, prevector<N, T>& v, const V&)
{ {
v.clear(); v.clear();
unsigned int nSize = ReadCompactSize(is); unsigned int nSize = ReadCompactSize(is);
@@ -643,14 +637,14 @@ void Unserialize_impl(Stream& is, prevector<N, T>& v, int nType, int nVersion, c
nMid = nSize; nMid = nSize;
v.resize(nMid); v.resize(nMid);
for (; i < nMid; i++) for (; i < nMid; i++)
Unserialize(is, v[i], nType, nVersion); Unserialize(is, v[i]);
} }
} }
template<typename Stream, unsigned int N, typename T> template<typename Stream, unsigned int N, typename T>
inline void Unserialize(Stream& is, prevector<N, T>& v, int nType, int nVersion) inline void Unserialize(Stream& is, prevector<N, T>& v)
{ {
Unserialize_impl(is, v, nType, nVersion, T()); Unserialize_impl(is, v, T());
} }
@@ -659,7 +653,7 @@ inline void Unserialize(Stream& is, prevector<N, T>& v, int nType, int nVersion)
* vector * vector
*/ */
template<typename Stream, typename T, typename A> template<typename Stream, typename T, typename A>
void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const unsigned char&) void Serialize_impl(Stream& os, const std::vector<T, A>& v, const unsigned char&)
{ {
WriteCompactSize(os, v.size()); WriteCompactSize(os, v.size());
if (!v.empty()) if (!v.empty())
@@ -667,22 +661,22 @@ void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVers
} }
template<typename Stream, typename T, typename A, typename V> template<typename Stream, typename T, typename A, typename V>
void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const V&) void Serialize_impl(Stream& os, const std::vector<T, A>& v, const V&)
{ {
WriteCompactSize(os, v.size()); WriteCompactSize(os, v.size());
for (typename std::vector<T, A>::const_iterator vi = v.begin(); vi != v.end(); ++vi) for (typename std::vector<T, A>::const_iterator vi = v.begin(); vi != v.end(); ++vi)
::Serialize(os, (*vi), nType, nVersion); ::Serialize(os, (*vi));
} }
template<typename Stream, typename T, typename A> template<typename Stream, typename T, typename A>
inline void Serialize(Stream& os, const std::vector<T, A>& v, int nType, int nVersion) inline void Serialize(Stream& os, const std::vector<T, A>& v)
{ {
Serialize_impl(os, v, nType, nVersion, T()); Serialize_impl(os, v, T());
} }
template<typename Stream, typename T, typename A> template<typename Stream, typename T, typename A>
void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const unsigned char&) void Unserialize_impl(Stream& is, std::vector<T, A>& v, const unsigned char&)
{ {
// Limit size per read so bogus size value won't cause out of memory // Limit size per read so bogus size value won't cause out of memory
v.clear(); v.clear();
@@ -698,7 +692,7 @@ void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion,
} }
template<typename Stream, typename T, typename A, typename V> template<typename Stream, typename T, typename A, typename V>
void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const V&) void Unserialize_impl(Stream& is, std::vector<T, A>& v, const V&)
{ {
v.clear(); v.clear();
unsigned int nSize = ReadCompactSize(is); unsigned int nSize = ReadCompactSize(is);
@@ -711,14 +705,14 @@ void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion,
nMid = nSize; nMid = nSize;
v.resize(nMid); v.resize(nMid);
for (; i < nMid; i++) for (; i < nMid; i++)
Unserialize(is, v[i], nType, nVersion); Unserialize(is, v[i]);
} }
} }
template<typename Stream, typename T, typename A> template<typename Stream, typename T, typename A>
inline void Unserialize(Stream& is, std::vector<T, A>& v, int nType, int nVersion) inline void Unserialize(Stream& is, std::vector<T, A>& v)
{ {
Unserialize_impl(is, v, nType, nVersion, T()); Unserialize_impl(is, v, T());
} }
@@ -784,17 +778,17 @@ void Unserialize(Stream& is, boost::array<T, N>& item, int nType, int nVersion)
* pair * pair
*/ */
template<typename Stream, typename K, typename T> template<typename Stream, typename K, typename T>
void Serialize(Stream& os, const std::pair<K, T>& item, int nType, int nVersion) void Serialize(Stream& os, const std::pair<K, T>& item)
{ {
Serialize(os, item.first, nType, nVersion); Serialize(os, item.first);
Serialize(os, item.second, nType, nVersion); Serialize(os, item.second);
} }
template<typename Stream, typename K, typename T> template<typename Stream, typename K, typename T>
void Unserialize(Stream& is, std::pair<K, T>& item, int nType, int nVersion) void Unserialize(Stream& is, std::pair<K, T>& item)
{ {
Unserialize(is, item.first, nType, nVersion); Unserialize(is, item.first);
Unserialize(is, item.second, nType, nVersion); Unserialize(is, item.second);
} }
@@ -803,15 +797,15 @@ void Unserialize(Stream& is, std::pair<K, T>& item, int nType, int nVersion)
* map * map
*/ */
template<typename Stream, typename K, typename T, typename Pred, typename A> template<typename Stream, typename K, typename T, typename Pred, typename A>
void Serialize(Stream& os, const std::map<K, T, Pred, A>& m, int nType, int nVersion) void Serialize(Stream& os, const std::map<K, T, Pred, A>& m)
{ {
WriteCompactSize(os, m.size()); WriteCompactSize(os, m.size());
for (typename std::map<K, T, Pred, A>::const_iterator mi = m.begin(); mi != m.end(); ++mi) for (typename std::map<K, T, Pred, A>::const_iterator mi = m.begin(); mi != m.end(); ++mi)
Serialize(os, (*mi), nType, nVersion); Serialize(os, (*mi));
} }
template<typename Stream, typename K, typename T, typename Pred, typename A> template<typename Stream, typename K, typename T, typename Pred, typename A>
void Unserialize(Stream& is, std::map<K, T, Pred, A>& m, int nType, int nVersion) void Unserialize(Stream& is, std::map<K, T, Pred, A>& m)
{ {
m.clear(); m.clear();
unsigned int nSize = ReadCompactSize(is); unsigned int nSize = ReadCompactSize(is);
@@ -819,7 +813,7 @@ void Unserialize(Stream& is, std::map<K, T, Pred, A>& m, int nType, int nVersion
for (unsigned int i = 0; i < nSize; i++) for (unsigned int i = 0; i < nSize; i++)
{ {
std::pair<K, T> item; std::pair<K, T> item;
Unserialize(is, item, nType, nVersion); Unserialize(is, item);
mi = m.insert(mi, item); mi = m.insert(mi, item);
} }
} }
@@ -830,15 +824,15 @@ void Unserialize(Stream& is, std::map<K, T, Pred, A>& m, int nType, int nVersion
* set * set
*/ */
template<typename Stream, typename K, typename Pred, typename A> template<typename Stream, typename K, typename Pred, typename A>
void Serialize(Stream& os, const std::set<K, Pred, A>& m, int nType, int nVersion) void Serialize(Stream& os, const std::set<K, Pred, A>& m)
{ {
WriteCompactSize(os, m.size()); WriteCompactSize(os, m.size());
for (typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it) for (typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
Serialize(os, (*it), nType, nVersion); Serialize(os, (*it));
} }
template<typename Stream, typename K, typename Pred, typename A> template<typename Stream, typename K, typename Pred, typename A>
void Unserialize(Stream& is, std::set<K, Pred, A>& m, int nType, int nVersion) void Unserialize(Stream& is, std::set<K, Pred, A>& m)
{ {
m.clear(); m.clear();
unsigned int nSize = ReadCompactSize(is); unsigned int nSize = ReadCompactSize(is);
@@ -846,7 +840,7 @@ void Unserialize(Stream& is, std::set<K, Pred, A>& m, int nType, int nVersion)
for (unsigned int i = 0; i < nSize; i++) for (unsigned int i = 0; i < nSize; i++)
{ {
K key; K key;
Unserialize(is, key, nType, nVersion); Unserialize(is, key);
it = m.insert(it, key); it = m.insert(it, key);
} }
} }
@@ -893,15 +887,15 @@ struct CSerActionUnserialize
}; };
template<typename Stream, typename T> template<typename Stream, typename T>
inline void SerReadWrite(Stream& s, const T& obj, int nType, int nVersion, CSerActionSerialize ser_action) inline void SerReadWrite(Stream& s, const T& obj, CSerActionSerialize ser_action)
{ {
::Serialize(s, obj, nType, nVersion); ::Serialize(s, obj);
} }
template<typename Stream, typename T> template<typename Stream, typename T>
inline void SerReadWrite(Stream& s, T& obj, int nType, int nVersion, CSerActionUnserialize ser_action) inline void SerReadWrite(Stream& s, T& obj, CSerActionUnserialize ser_action)
{ {
::Unserialize(s, obj, nType, nVersion); ::Unserialize(s, obj);
} }
@@ -920,7 +914,6 @@ protected:
const int nType; const int nType;
const int nVersion; const int nVersion;
public: public:
CSizeComputer(int nTypeIn, int nVersionIn) : nSize(0), nType(nTypeIn), nVersion(nVersionIn) {} CSizeComputer(int nTypeIn, int nVersionIn) : nSize(0), nType(nTypeIn), nVersion(nVersionIn) {}
void write(const char *psz, size_t nSize) void write(const char *psz, size_t nSize)
@@ -931,61 +924,64 @@ public:
template<typename T> template<typename T>
CSizeComputer& operator<<(const T& obj) CSizeComputer& operator<<(const T& obj)
{ {
::Serialize(*this, obj, nType, nVersion); ::Serialize(*this, obj);
return (*this); return (*this);
} }
size_t size() const { size_t size() const {
return nSize; return nSize;
} }
int GetVersion() const { return nVersion; }
int GetType() const { return nType; }
}; };
template<typename Stream> template<typename Stream>
void SerializeMany(Stream& s, int nType, int nVersion) void SerializeMany(Stream& s)
{ {
} }
template<typename Stream, typename Arg> template<typename Stream, typename Arg>
void SerializeMany(Stream& s, int nType, int nVersion, Arg&& arg) void SerializeMany(Stream& s, Arg&& arg)
{ {
::Serialize(s, std::forward<Arg>(arg), nType, nVersion); ::Serialize(s, std::forward<Arg>(arg));
} }
template<typename Stream, typename Arg, typename... Args> template<typename Stream, typename Arg, typename... Args>
void SerializeMany(Stream& s, int nType, int nVersion, Arg&& arg, Args&&... args) void SerializeMany(Stream& s, Arg&& arg, Args&&... args)
{ {
::Serialize(s, std::forward<Arg>(arg), nType, nVersion); ::Serialize(s, std::forward<Arg>(arg));
::SerializeMany(s, nType, nVersion, std::forward<Args>(args)...); ::SerializeMany(s, std::forward<Args>(args)...);
} }
template<typename Stream> template<typename Stream>
inline void UnserializeMany(Stream& s, int nType, int nVersion) inline void UnserializeMany(Stream& s)
{ {
} }
template<typename Stream, typename Arg> template<typename Stream, typename Arg>
inline void UnserializeMany(Stream& s, int nType, int nVersion, Arg& arg) inline void UnserializeMany(Stream& s, Arg& arg)
{ {
::Unserialize(s, arg, nType, nVersion); ::Unserialize(s, arg);
} }
template<typename Stream, typename Arg, typename... Args> template<typename Stream, typename Arg, typename... Args>
inline void UnserializeMany(Stream& s, int nType, int nVersion, Arg& arg, Args&... args) inline void UnserializeMany(Stream& s, Arg& arg, Args&... args)
{ {
::Unserialize(s, arg, nType, nVersion); ::Unserialize(s, arg);
::UnserializeMany(s, nType, nVersion, args...); ::UnserializeMany(s, args...);
} }
template<typename Stream, typename... Args> template<typename Stream, typename... Args>
inline void SerReadWriteMany(Stream& s, int nType, int nVersion, CSerActionSerialize ser_action, Args&&... args) inline void SerReadWriteMany(Stream& s, CSerActionSerialize ser_action, Args&&... args)
{ {
::SerializeMany(s, nType, nVersion, std::forward<Args>(args)...); ::SerializeMany(s, std::forward<Args>(args)...);
} }
template<typename Stream, typename... Args> template<typename Stream, typename... Args>
inline void SerReadWriteMany(Stream& s, int nType, int nVersion, CSerActionUnserialize ser_action, Args&... args) inline void SerReadWriteMany(Stream& s, CSerActionUnserialize ser_action, Args&... args)
{ {
::UnserializeMany(s, nType, nVersion, args...); ::UnserializeMany(s, args...);
} }
template <typename T> template <typename T>

17
src/streams.h
View File

@@ -85,7 +85,7 @@ public:
CBaseDataStream(int nTypeIn, int nVersionIn, Args&&... args) CBaseDataStream(int nTypeIn, int nVersionIn, Args&&... args)
{ {
Init(nTypeIn, nVersionIn); Init(nTypeIn, nVersionIn);
::SerializeMany(*this, nType, nVersion, std::forward<Args>(args)...); ::SerializeMany(*this, std::forward<Args>(args)...);
} }
void Init(int nTypeIn, int nVersionIn) void Init(int nTypeIn, int nVersionIn)
@@ -268,7 +268,7 @@ public:
} }
template<typename Stream> template<typename Stream>
void Serialize(Stream& s, int nType, int nVersion) const void Serialize(Stream& s) const
{ {
// Special case: stream << stream concatenates like stream += stream // Special case: stream << stream concatenates like stream += stream
if (!vch.empty()) if (!vch.empty())
@@ -279,7 +279,7 @@ public:
CBaseDataStream& operator<<(const T& obj) CBaseDataStream& operator<<(const T& obj)
{ {
// Serialize to this stream // Serialize to this stream
::Serialize(*this, obj, nType, nVersion); ::Serialize(*this, obj);
return (*this); return (*this);
} }
@@ -287,7 +287,7 @@ public:
CBaseDataStream& operator>>(T& obj) CBaseDataStream& operator>>(T& obj)
{ {
// Unserialize from this stream // Unserialize from this stream
::Unserialize(*this, obj, nType, nVersion); ::Unserialize(*this, obj);
return (*this); return (*this);
} }
@@ -428,7 +428,7 @@ public:
// Serialize to this stream // Serialize to this stream
if (!file) if (!file)
throw std::ios_base::failure("CAutoFile::operator<<: file handle is NULL"); throw std::ios_base::failure("CAutoFile::operator<<: file handle is NULL");
::Serialize(*this, obj, nType, nVersion); ::Serialize(*this, obj);
return (*this); return (*this);
} }
@@ -438,7 +438,7 @@ public:
// Unserialize from this stream // Unserialize from this stream
if (!file) if (!file)
throw std::ios_base::failure("CAutoFile::operator>>: file handle is NULL"); throw std::ios_base::failure("CAutoFile::operator>>: file handle is NULL");
::Unserialize(*this, obj, nType, nVersion); ::Unserialize(*this, obj);
return (*this); return (*this);
} }
}; };
@@ -497,6 +497,9 @@ public:
fclose(); fclose();
} }
int GetVersion() const { return nVersion; }
int GetType() const { return nType; }
void fclose() void fclose()
{ {
if (src) { if (src) {
@@ -575,7 +578,7 @@ public:
template<typename T> template<typename T>
CBufferedFile& operator>>(T& obj) { CBufferedFile& operator>>(T& obj) {
// Unserialize from this stream // Unserialize from this stream
::Unserialize(*this, obj, nType, nVersion); ::Unserialize(*this, obj);
return (*this); return (*this);
} }

6
src/test/bloom_tests.cpp
View File

@@ -41,7 +41,7 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize)
BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")), "BloomFilter doesn't contain just-inserted object (3)!"); BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")), "BloomFilter doesn't contain just-inserted object (3)!");
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
filter.Serialize(stream, SER_NETWORK, PROTOCOL_VERSION); stream << filter;
vector<unsigned char> vch = ParseHex("03614e9b050000000000000001"); vector<unsigned char> vch = ParseHex("03614e9b050000000000000001");
vector<char> expected(vch.size()); vector<char> expected(vch.size());
@@ -73,7 +73,7 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize_with_tweak)
BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")), "BloomFilter doesn't contain just-inserted object (3)!"); BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")), "BloomFilter doesn't contain just-inserted object (3)!");
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
filter.Serialize(stream, SER_NETWORK, PROTOCOL_VERSION); stream << filter;
vector<unsigned char> vch = ParseHex("03ce4299050000000100008001"); vector<unsigned char> vch = ParseHex("03ce4299050000000100008001");
vector<char> expected(vch.size()); vector<char> expected(vch.size());
@@ -100,7 +100,7 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_key)
filter.insert(vector<unsigned char>(hash.begin(), hash.end())); filter.insert(vector<unsigned char>(hash.begin(), hash.end()));
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
filter.Serialize(stream, SER_NETWORK, PROTOCOL_VERSION); stream << filter;
vector<unsigned char> vch = ParseHex("038fc16b080000000000000001"); vector<unsigned char> vch = ParseHex("038fc16b080000000000000001");
vector<char> expected(vch.size()); vector<char> expected(vch.size());

2
src/test/dbwrapper_tests.cpp
View File

@@ -163,7 +163,7 @@ struct StringContentsSerializer {
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (ser_action.ForRead()) { if (ser_action.ForRead()) {
str.clear(); str.clear();
char c = 0; char c = 0;

4
src/test/serialize_tests.cpp
View File

@@ -50,7 +50,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(intval); READWRITE(intval);
READWRITE(boolval); READWRITE(boolval);
READWRITE(stringval); READWRITE(stringval);
@@ -75,7 +75,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITEMANY(intval, boolval, stringval, FLATDATA(charstrval), txval); READWRITEMANY(intval, boolval, stringval, FLATDATA(charstrval), txval);
} }
}; };

38
src/test/uint256_tests.cpp
View File

@@ -187,22 +187,22 @@ BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 G
BOOST_CHECK(GetSerializeSize(R1L, 0, PROTOCOL_VERSION) == 32); BOOST_CHECK(GetSerializeSize(R1L, 0, PROTOCOL_VERSION) == 32);
BOOST_CHECK(GetSerializeSize(ZeroL, 0, PROTOCOL_VERSION) == 32); BOOST_CHECK(GetSerializeSize(ZeroL, 0, PROTOCOL_VERSION) == 32);
std::stringstream ss; CDataStream ss(0, PROTOCOL_VERSION);
R1L.Serialize(ss,0,PROTOCOL_VERSION); ss << R1L;
BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+32)); BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+32));
TmpL.Unserialize(ss,0,PROTOCOL_VERSION); ss >> TmpL;
BOOST_CHECK(R1L == TmpL); BOOST_CHECK(R1L == TmpL);
ss.str(""); ss.clear();
ZeroL.Serialize(ss,0,PROTOCOL_VERSION); ss << ZeroL;
BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+32)); BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+32));
TmpL.Unserialize(ss,0,PROTOCOL_VERSION); ss >> TmpL;
BOOST_CHECK(ZeroL == TmpL); BOOST_CHECK(ZeroL == TmpL);
ss.str(""); ss.clear();
MaxL.Serialize(ss,0,PROTOCOL_VERSION); ss << MaxL;
BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+32)); BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+32));
TmpL.Unserialize(ss,0,PROTOCOL_VERSION); ss >> TmpL;
BOOST_CHECK(MaxL == TmpL); BOOST_CHECK(MaxL == TmpL);
ss.str(""); ss.clear();
BOOST_CHECK(R1S.GetHex() == R1S.ToString()); BOOST_CHECK(R1S.GetHex() == R1S.ToString());
BOOST_CHECK(R2S.GetHex() == R2S.ToString()); BOOST_CHECK(R2S.GetHex() == R2S.ToString());
@@ -233,21 +233,21 @@ BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 G
BOOST_CHECK(GetSerializeSize(R1S, 0, PROTOCOL_VERSION) == 20); BOOST_CHECK(GetSerializeSize(R1S, 0, PROTOCOL_VERSION) == 20);
BOOST_CHECK(GetSerializeSize(ZeroS, 0, PROTOCOL_VERSION) == 20); BOOST_CHECK(GetSerializeSize(ZeroS, 0, PROTOCOL_VERSION) == 20);
R1S.Serialize(ss,0,PROTOCOL_VERSION); ss << R1S;
BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+20)); BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+20));
TmpS.Unserialize(ss,0,PROTOCOL_VERSION); ss >> TmpS;
BOOST_CHECK(R1S == TmpS); BOOST_CHECK(R1S == TmpS);
ss.str(""); ss.clear();
ZeroS.Serialize(ss,0,PROTOCOL_VERSION); ss << ZeroS;
BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+20)); BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+20));
TmpS.Unserialize(ss,0,PROTOCOL_VERSION); ss >> TmpS;
BOOST_CHECK(ZeroS == TmpS); BOOST_CHECK(ZeroS == TmpS);
ss.str(""); ss.clear();
MaxS.Serialize(ss,0,PROTOCOL_VERSION); ss << MaxS;
BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+20)); BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+20));
TmpS.Unserialize(ss,0,PROTOCOL_VERSION); ss >> TmpS;
BOOST_CHECK(MaxS == TmpS); BOOST_CHECK(MaxS == TmpS);
ss.str(""); ss.clear();
} }
BOOST_AUTO_TEST_CASE( conversion ) BOOST_AUTO_TEST_CASE( conversion )

4
src/uint256.h
View File

@@ -76,13 +76,13 @@ public:
} }
template<typename Stream> template<typename Stream>
void Serialize(Stream& s, int nType, int nVersion) const void Serialize(Stream& s) const
{ {
s.write((char*)data, sizeof(data)); s.write((char*)data, sizeof(data));
} }
template<typename Stream> template<typename Stream>
void Unserialize(Stream& s, int nType, int nVersion) void Unserialize(Stream& s)
{ {
s.read((char*)data, sizeof(data)); s.read((char*)data, sizeof(data));
} }

20
src/undo.h
View File

@@ -28,22 +28,22 @@ public:
CTxInUndo(const CTxOut &txoutIn, bool fCoinBaseIn = false, unsigned int nHeightIn = 0, int nVersionIn = 0) : txout(txoutIn), fCoinBase(fCoinBaseIn), nHeight(nHeightIn), nVersion(nVersionIn) { } CTxInUndo(const CTxOut &txoutIn, bool fCoinBaseIn = false, unsigned int nHeightIn = 0, int nVersionIn = 0) : txout(txoutIn), fCoinBase(fCoinBaseIn), nHeight(nHeightIn), nVersion(nVersionIn) { }
template<typename Stream> template<typename Stream>
void Serialize(Stream &s, int nType, int nVersion) const { void Serialize(Stream &s) const {
::Serialize(s, VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion); ::Serialize(s, VARINT(nHeight*2+(fCoinBase ? 1 : 0)));
if (nHeight > 0) if (nHeight > 0)
::Serialize(s, VARINT(this->nVersion), nType, nVersion); ::Serialize(s, VARINT(this->nVersion));
::Serialize(s, CTxOutCompressor(REF(txout)), nType, nVersion); ::Serialize(s, CTxOutCompressor(REF(txout)));
} }
template<typename Stream> template<typename Stream>
void Unserialize(Stream &s, int nType, int nVersion) { void Unserialize(Stream &s) {
unsigned int nCode = 0; unsigned int nCode = 0;
::Unserialize(s, VARINT(nCode), nType, nVersion); ::Unserialize(s, VARINT(nCode));
nHeight = nCode / 2; nHeight = nCode / 2;
fCoinBase = nCode & 1; fCoinBase = nCode & 1;
if (nHeight > 0) if (nHeight > 0)
::Unserialize(s, VARINT(this->nVersion), nType, nVersion); ::Unserialize(s, VARINT(this->nVersion));
::Unserialize(s, REF(CTxOutCompressor(REF(txout))), nType, nVersion); ::Unserialize(s, REF(CTxOutCompressor(REF(txout))));
} }
}; };
@@ -57,7 +57,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(vprevout); READWRITE(vprevout);
} }
}; };
@@ -72,7 +72,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(vtxundo); READWRITE(vtxundo);
READWRITE(old_tree_root); READWRITE(old_tree_root);
} }

2
src/wallet/crypter.h
View File

@@ -48,7 +48,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(vchCryptedKey); READWRITE(vchCryptedKey);
READWRITE(vchSalt); READWRITE(vchSalt);
READWRITE(nDerivationMethod); READWRITE(nDerivationMethod);

28
src/wallet/wallet.h
View File

@@ -93,8 +93,9 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (!(nType & SER_GETHASH)) int nVersion = s.GetVersion();
if (!(s.GetType() & SER_GETHASH))
READWRITE(nVersion); READWRITE(nVersion);
READWRITE(nTime); READWRITE(nTime);
READWRITE(vchPubKey); READWRITE(vchPubKey);
@@ -314,7 +315,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(*(CTransaction*)this); READWRITE(*(CTransaction*)this);
READWRITE(hashBlock); READWRITE(hashBlock);
READWRITE(vMerkleBranch); READWRITE(vMerkleBranch);
@@ -432,7 +433,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (ser_action.ForRead()) if (ser_action.ForRead())
Init(NULL); Init(NULL);
char fSpent = false; char fSpent = false;
@@ -565,8 +566,9 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (!(nType & SER_GETHASH)) int nVersion = s.GetVersion();
if (!(s.GetType() & SER_GETHASH))
READWRITE(nVersion); READWRITE(nVersion);
READWRITE(vchPrivKey); READWRITE(vchPrivKey);
READWRITE(nTimeCreated); READWRITE(nTimeCreated);
@@ -610,8 +612,9 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (!(nType & SER_GETHASH)) int nVersion = s.GetVersion();
if (!(s.GetType() & SER_GETHASH))
READWRITE(nVersion); READWRITE(nVersion);
//! Note: strAccount is serialized as part of the key, not here. //! Note: strAccount is serialized as part of the key, not here.
READWRITE(nCreditDebit); READWRITE(nCreditDebit);
@@ -624,7 +627,7 @@ public:
if (!(mapValue.empty() && _ssExtra.empty())) if (!(mapValue.empty() && _ssExtra.empty()))
{ {
CDataStream ss(nType, nVersion); CDataStream ss(s.GetType(), s.GetVersion());
ss.insert(ss.begin(), '\0'); ss.insert(ss.begin(), '\0');
ss << mapValue; ss << mapValue;
ss.insert(ss.end(), _ssExtra.begin(), _ssExtra.end()); ss.insert(ss.end(), _ssExtra.begin(), _ssExtra.end());
@@ -640,7 +643,7 @@ public:
mapValue.clear(); mapValue.clear();
if (std::string::npos != nSepPos) if (std::string::npos != nSepPos)
{ {
CDataStream ss(std::vector<char>(strComment.begin() + nSepPos + 1, strComment.end()), nType, nVersion); CDataStream ss(std::vector<char>(strComment.begin() + nSepPos + 1, strComment.end()), s.GetType(), s.GetVersion());
ss >> mapValue; ss >> mapValue;
_ssExtra = std::vector<char>(ss.begin(), ss.end()); _ssExtra = std::vector<char>(ss.begin(), ss.end());
} }
@@ -1204,8 +1207,9 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
if (!(nType & SER_GETHASH)) int nVersion = s.GetVersion();
if (!(s.GetType() & SER_GETHASH))
READWRITE(nVersion); READWRITE(nVersion);
READWRITE(vchPubKey); READWRITE(vchPubKey);
} }

2
src/wallet/walletdb.h
View File

@@ -60,7 +60,7 @@ public:
ADD_SERIALIZE_METHODS; ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation> template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(this->nVersion); READWRITE(this->nVersion);
READWRITE(nCreateTime); READWRITE(nCreateTime);
} }