X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=src%2Fserialize.h;h=6eb4f4ee4173094f6a142270b5869df3ab3587b9;hb=882164196e5b1971313493f95a6d027f05e2ec92;hp=383c9878647f39c33d6a44427394bff0338276cd;hpb=84c3fb07b0b8199c7f85c5de280e7100bad0786f;p=novacoin.git diff --git a/src/serialize.h b/src/serialize.h index 383c987..6eb4f4e 100644 --- a/src/serialize.h +++ b/src/serialize.h @@ -1,38 +1,66 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto +// Copyright (c) 2009-2012 The Bitcoin developers // Distributed under the MIT/X11 software license, see the accompanying // file license.txt or http://www.opensource.org/licenses/mit-license.php. +#ifndef BITCOIN_SERIALIZE_H +#define BITCOIN_SERIALIZE_H #include #include #include #include +#include +#include +#include +#include + #include #include #include #include -#if defined(_MSC_VER) || defined(__BORLANDC__) -typedef __int64 int64; -typedef unsigned __int64 uint64; -#else + typedef long long int64; typedef unsigned long long uint64; + +#ifdef WIN32 +#include +// This is used to attempt to keep keying material out of swap +// Note that VirtualLock does not provide this as a guarantee on Windows, +// but, in practice, memory that has been VirtualLock'd almost never gets written to +// the pagefile except in rare circumstances where memory is extremely low. +#include +#define mlock(p, n) VirtualLock((p), (n)); +#define munlock(p, n) VirtualUnlock((p), (n)); +#else +#include +#include +/* This comes from limits.h if it's not defined there set a sane default */ +#ifndef PAGESIZE +#include +#define PAGESIZE sysconf(_SC_PAGESIZE) #endif -#if defined(_MSC_VER) && _MSC_VER < 1300 -#define for if (false) ; else for +#define mlock(a,b) \ + mlock(((void *)(((size_t)(a)) & (~((PAGESIZE)-1)))),\ + (((((size_t)(a)) + (b) - 1) | ((PAGESIZE) - 1)) + 1) - (((size_t)(a)) & (~((PAGESIZE) - 1)))) +#define munlock(a,b) \ + munlock(((void *)(((size_t)(a)) & (~((PAGESIZE)-1)))),\ + (((((size_t)(a)) + (b) - 1) | ((PAGESIZE) - 1)) + 1) - (((size_t)(a)) & (~((PAGESIZE) - 1)))) #endif + class CScript; class CDataStream; class CAutoFile; static const unsigned int MAX_SIZE = 0x02000000; -static const int VERSION = 32100; -static const char* pszSubVer = ""; -static const bool VERSION_IS_BETA = true; - - - - +static const int PROTOCOL_VERSION = 60000; +// Used to bypass the rule against non-const reference to temporary +// where it makes sense with wrappers such as CFlatData or CTxDB +template +inline T& REF(const T& val) +{ + return const_cast(val); +} ///////////////////////////////////////////////////////////////// // @@ -53,7 +81,7 @@ enum }; #define IMPLEMENT_SERIALIZE(statements) \ - unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const \ + unsigned int GetSerializeSize(int nType=0, int nVersion=PROTOCOL_VERSION) const \ { \ CSerActionGetSerializeSize ser_action; \ const bool fGetSize = true; \ @@ -61,29 +89,32 @@ enum const bool fRead = false; \ unsigned int nSerSize = 0; \ ser_streamplaceholder s; \ + assert(fGetSize||fWrite||fRead); /* suppress warning */ \ s.nType = nType; \ s.nVersion = nVersion; \ {statements} \ return nSerSize; \ } \ template \ - void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const \ + void Serialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION) const \ { \ CSerActionSerialize ser_action; \ const bool fGetSize = false; \ const bool fWrite = true; \ const bool fRead = false; \ unsigned int nSerSize = 0; \ + assert(fGetSize||fWrite||fRead); /* suppress warning */ \ {statements} \ } \ template \ - void Unserialize(Stream& s, int nType=0, int nVersion=VERSION) \ + void Unserialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION) \ { \ CSerActionUnserialize ser_action; \ const bool fGetSize = false; \ const bool fWrite = false; \ const bool fRead = true; \ unsigned int nSerSize = 0; \ + assert(fGetSize||fWrite||fRead); /* suppress warning */ \ {statements} \ } @@ -161,8 +192,8 @@ template inline void Unserialize(Stream& s, bool& a, int, int=0 inline unsigned int GetSizeOfCompactSize(uint64 nSize) { if (nSize < 253) return sizeof(unsigned char); - else if (nSize <= USHRT_MAX) return sizeof(unsigned char) + sizeof(unsigned short); - else if (nSize <= UINT_MAX) return sizeof(unsigned char) + sizeof(unsigned int); + else if (nSize <= std::numeric_limits::max()) return sizeof(unsigned char) + sizeof(unsigned short); + else if (nSize <= std::numeric_limits::max()) return sizeof(unsigned char) + sizeof(unsigned int); else return sizeof(unsigned char) + sizeof(uint64); } @@ -174,14 +205,14 @@ void WriteCompactSize(Stream& os, uint64 nSize) unsigned char chSize = nSize; WRITEDATA(os, chSize); } - else if (nSize <= USHRT_MAX) + else if (nSize <= std::numeric_limits::max()) { unsigned char chSize = 253; unsigned short xSize = nSize; WRITEDATA(os, chSize); WRITEDATA(os, xSize); } - else if (nSize <= UINT_MAX) + else if (nSize <= std::numeric_limits::max()) { unsigned char chSize = 254; unsigned int xSize = nSize; @@ -277,11 +308,11 @@ template class CFixedFieldString { protected: - const string* pcstr; - string* pstr; + const std::string* pcstr; + std::string* pstr; public: - explicit CFixedFieldString(const string& str) : pcstr(&str), pstr(NULL) { } - explicit CFixedFieldString(string& str) : pcstr(&str), pstr(&str) { } + explicit CFixedFieldString(const std::string& str) : pcstr(&str), pstr(NULL) { } + explicit CFixedFieldString(std::string& str) : pcstr(&str), pstr(&str) { } unsigned int GetSerializeSize(int, int=0) const { @@ -317,50 +348,50 @@ public: // // string -template unsigned int GetSerializeSize(const basic_string& str, int, int=0); -template void Serialize(Stream& os, const basic_string& str, int, int=0); -template void Unserialize(Stream& is, basic_string& str, int, int=0); +template unsigned int GetSerializeSize(const std::basic_string& str, int, int=0); +template void Serialize(Stream& os, const std::basic_string& str, int, int=0); +template void Unserialize(Stream& is, std::basic_string& str, int, int=0); // vector template unsigned int GetSerializeSize_impl(const std::vector& v, int nType, int nVersion, const boost::true_type&); template unsigned int GetSerializeSize_impl(const std::vector& v, int nType, int nVersion, const boost::false_type&); -template inline unsigned int GetSerializeSize(const std::vector& v, int nType, int nVersion=VERSION); +template inline unsigned int GetSerializeSize(const std::vector& v, int nType, int nVersion=PROTOCOL_VERSION); template void Serialize_impl(Stream& os, const std::vector& v, int nType, int nVersion, const boost::true_type&); template void Serialize_impl(Stream& os, const std::vector& v, int nType, int nVersion, const boost::false_type&); -template inline void Serialize(Stream& os, const std::vector& v, int nType, int nVersion=VERSION); +template inline void Serialize(Stream& os, const std::vector& v, int nType, int nVersion=PROTOCOL_VERSION); template void Unserialize_impl(Stream& is, std::vector& v, int nType, int nVersion, const boost::true_type&); template void Unserialize_impl(Stream& is, std::vector& v, int nType, int nVersion, const boost::false_type&); -template inline void Unserialize(Stream& is, std::vector& v, int nType, int nVersion=VERSION); +template inline void Unserialize(Stream& is, std::vector& v, int nType, int nVersion=PROTOCOL_VERSION); // others derived from vector -extern inline unsigned int GetSerializeSize(const CScript& v, int nType, int nVersion=VERSION); -template void Serialize(Stream& os, const CScript& v, int nType, int nVersion=VERSION); -template void Unserialize(Stream& is, CScript& v, int nType, int nVersion=VERSION); +extern inline unsigned int GetSerializeSize(const CScript& v, int nType, int nVersion=PROTOCOL_VERSION); +template void Serialize(Stream& os, const CScript& v, int nType, int nVersion=PROTOCOL_VERSION); +template void Unserialize(Stream& is, CScript& v, int nType, int nVersion=PROTOCOL_VERSION); // pair -template unsigned int GetSerializeSize(const std::pair& item, int nType, int nVersion=VERSION); -template void Serialize(Stream& os, const std::pair& item, int nType, int nVersion=VERSION); -template void Unserialize(Stream& is, std::pair& item, int nType, int nVersion=VERSION); +template unsigned int GetSerializeSize(const std::pair& item, int nType, int nVersion=PROTOCOL_VERSION); +template void Serialize(Stream& os, const std::pair& item, int nType, int nVersion=PROTOCOL_VERSION); +template void Unserialize(Stream& is, std::pair& item, int nType, int nVersion=PROTOCOL_VERSION); // 3 tuple -template unsigned int GetSerializeSize(const boost::tuple& item, int nType, int nVersion=VERSION); -template void Serialize(Stream& os, const boost::tuple& item, int nType, int nVersion=VERSION); -template void Unserialize(Stream& is, boost::tuple& item, int nType, int nVersion=VERSION); +template unsigned int GetSerializeSize(const boost::tuple& item, int nType, int nVersion=PROTOCOL_VERSION); +template void Serialize(Stream& os, const boost::tuple& item, int nType, int nVersion=PROTOCOL_VERSION); +template void Unserialize(Stream& is, boost::tuple& item, int nType, int nVersion=PROTOCOL_VERSION); // 4 tuple -template unsigned int GetSerializeSize(const boost::tuple& item, int nType, int nVersion=VERSION); -template void Serialize(Stream& os, const boost::tuple& item, int nType, int nVersion=VERSION); -template void Unserialize(Stream& is, boost::tuple& item, int nType, int nVersion=VERSION); +template unsigned int GetSerializeSize(const boost::tuple& item, int nType, int nVersion=PROTOCOL_VERSION); +template void Serialize(Stream& os, const boost::tuple& item, int nType, int nVersion=PROTOCOL_VERSION); +template void Unserialize(Stream& is, boost::tuple& item, int nType, int nVersion=PROTOCOL_VERSION); // map -template unsigned int GetSerializeSize(const std::map& m, int nType, int nVersion=VERSION); -template void Serialize(Stream& os, const std::map& m, int nType, int nVersion=VERSION); -template void Unserialize(Stream& is, std::map& m, int nType, int nVersion=VERSION); +template unsigned int GetSerializeSize(const std::map& m, int nType, int nVersion=PROTOCOL_VERSION); +template void Serialize(Stream& os, const std::map& m, int nType, int nVersion=PROTOCOL_VERSION); +template void Unserialize(Stream& is, std::map& m, int nType, int nVersion=PROTOCOL_VERSION); // set -template unsigned int GetSerializeSize(const std::set& m, int nType, int nVersion=VERSION); -template void Serialize(Stream& os, const std::set& m, int nType, int nVersion=VERSION); -template void Unserialize(Stream& is, std::set& m, int nType, int nVersion=VERSION); +template unsigned int GetSerializeSize(const std::set& m, int nType, int nVersion=PROTOCOL_VERSION); +template void Serialize(Stream& os, const std::set& m, int nType, int nVersion=PROTOCOL_VERSION); +template void Unserialize(Stream& is, std::set& m, int nType, int nVersion=PROTOCOL_VERSION); @@ -373,19 +404,19 @@ template void Unserializ // Thanks to Boost serialization for this idea. // template -inline unsigned int GetSerializeSize(const T& a, long nType, int nVersion=VERSION) +inline unsigned int GetSerializeSize(const T& a, long nType, int nVersion=PROTOCOL_VERSION) { return a.GetSerializeSize((int)nType, nVersion); } template -inline void Serialize(Stream& os, const T& a, long nType, int nVersion=VERSION) +inline void Serialize(Stream& os, const T& a, long nType, int nVersion=PROTOCOL_VERSION) { a.Serialize(os, (int)nType, nVersion); } template -inline void Unserialize(Stream& is, T& a, long nType, int nVersion=VERSION) +inline void Unserialize(Stream& is, T& a, long nType, int nVersion=PROTOCOL_VERSION) { a.Unserialize(is, (int)nType, nVersion); } @@ -398,13 +429,13 @@ inline void Unserialize(Stream& is, T& a, long nType, int nVersion=VERSION) // string // template -unsigned int GetSerializeSize(const basic_string& str, int, int) +unsigned int GetSerializeSize(const std::basic_string& str, int, int) { return GetSizeOfCompactSize(str.size()) + str.size() * sizeof(str[0]); } template -void Serialize(Stream& os, const basic_string& str, int, int) +void Serialize(Stream& os, const std::basic_string& str, int, int) { WriteCompactSize(os, str.size()); if (!str.empty()) @@ -412,7 +443,7 @@ void Serialize(Stream& os, const basic_string& str, int, int) } template -void Unserialize(Stream& is, basic_string& str, int, int) +void Unserialize(Stream& is, std::basic_string& str, int, int) { unsigned int nSize = ReadCompactSize(is); str.resize(nSize); @@ -483,7 +514,7 @@ void Unserialize_impl(Stream& is, std::vector& v, int nType, int nVersion, unsigned int i = 0; while (i < nSize) { - unsigned int blk = min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T))); + unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T))); v.resize(i + blk); is.read((char*)&v[i], blk * sizeof(T)); i += blk; @@ -526,19 +557,19 @@ inline void Unserialize(Stream& is, std::vector& v, int nType, int nVersio // inline unsigned int GetSerializeSize(const CScript& v, int nType, int nVersion) { - return GetSerializeSize((const vector&)v, nType, nVersion); + return GetSerializeSize((const std::vector&)v, nType, nVersion); } template void Serialize(Stream& os, const CScript& v, int nType, int nVersion) { - Serialize(os, (const vector&)v, nType, nVersion); + Serialize(os, (const std::vector&)v, nType, nVersion); } template void Unserialize(Stream& is, CScript& v, int nType, int nVersion) { - Unserialize(is, (vector&)v, nType, nVersion); + Unserialize(is, (std::vector&)v, nType, nVersion); } @@ -575,26 +606,26 @@ template unsigned int GetSerializeSize(const boost::tuple& item, int nType, int nVersion) { unsigned int nSize = 0; - nSize += GetSerializeSize(get<0>(item), nType, nVersion); - nSize += GetSerializeSize(get<1>(item), nType, nVersion); - nSize += GetSerializeSize(get<2>(item), nType, nVersion); + nSize += GetSerializeSize(boost::get<0>(item), nType, nVersion); + nSize += GetSerializeSize(boost::get<1>(item), nType, nVersion); + nSize += GetSerializeSize(boost::get<2>(item), nType, nVersion); return nSize; } template void Serialize(Stream& os, const boost::tuple& item, int nType, int nVersion) { - Serialize(os, get<0>(item), nType, nVersion); - Serialize(os, get<1>(item), nType, nVersion); - Serialize(os, get<2>(item), nType, nVersion); + Serialize(os, boost::get<0>(item), nType, nVersion); + Serialize(os, boost::get<1>(item), nType, nVersion); + Serialize(os, boost::get<2>(item), nType, nVersion); } template void Unserialize(Stream& is, boost::tuple& item, int nType, int nVersion) { - Unserialize(is, get<0>(item), nType, nVersion); - Unserialize(is, get<1>(item), nType, nVersion); - Unserialize(is, get<2>(item), nType, nVersion); + Unserialize(is, boost::get<0>(item), nType, nVersion); + Unserialize(is, boost::get<1>(item), nType, nVersion); + Unserialize(is, boost::get<2>(item), nType, nVersion); } @@ -606,29 +637,29 @@ template unsigned int GetSerializeSize(const boost::tuple& item, int nType, int nVersion) { unsigned int nSize = 0; - nSize += GetSerializeSize(get<0>(item), nType, nVersion); - nSize += GetSerializeSize(get<1>(item), nType, nVersion); - nSize += GetSerializeSize(get<2>(item), nType, nVersion); - nSize += GetSerializeSize(get<3>(item), nType, nVersion); + nSize += GetSerializeSize(boost::get<0>(item), nType, nVersion); + nSize += GetSerializeSize(boost::get<1>(item), nType, nVersion); + nSize += GetSerializeSize(boost::get<2>(item), nType, nVersion); + nSize += GetSerializeSize(boost::get<3>(item), nType, nVersion); return nSize; } template void Serialize(Stream& os, const boost::tuple& item, int nType, int nVersion) { - Serialize(os, get<0>(item), nType, nVersion); - Serialize(os, get<1>(item), nType, nVersion); - Serialize(os, get<2>(item), nType, nVersion); - Serialize(os, get<3>(item), nType, nVersion); + Serialize(os, boost::get<0>(item), nType, nVersion); + Serialize(os, boost::get<1>(item), nType, nVersion); + Serialize(os, boost::get<2>(item), nType, nVersion); + Serialize(os, boost::get<3>(item), nType, nVersion); } template void Unserialize(Stream& is, boost::tuple& item, int nType, int nVersion) { - Unserialize(is, get<0>(item), nType, nVersion); - Unserialize(is, get<1>(item), nType, nVersion); - Unserialize(is, get<2>(item), nType, nVersion); - Unserialize(is, get<3>(item), nType, nVersion); + Unserialize(is, boost::get<0>(item), nType, nVersion); + Unserialize(is, boost::get<1>(item), nType, nVersion); + Unserialize(is, boost::get<2>(item), nType, nVersion); + Unserialize(is, boost::get<3>(item), nType, nVersion); } @@ -661,7 +692,7 @@ void Unserialize(Stream& is, std::map& m, int nType, int nVersion typename std::map::iterator mi = m.begin(); for (unsigned int i = 0; i < nSize; i++) { - pair item; + std::pair item; Unserialize(is, item, nType, nVersion); mi = m.insert(mi, item); } @@ -747,7 +778,8 @@ struct ser_streamplaceholder // -// Allocator that clears its contents before deletion +// Allocator that locks its contents from being paged +// out of memory and clears its contents before deletion. // template struct secure_allocator : public std::allocator @@ -769,11 +801,55 @@ struct secure_allocator : public std::allocator template struct rebind { typedef secure_allocator<_Other> other; }; + T* allocate(std::size_t n, const void *hint = 0) + { + T *p; + p = std::allocator::allocate(n, hint); + if (p != NULL) + mlock(p, sizeof(T) * n); + return p; + } + void deallocate(T* p, std::size_t n) { if (p != NULL) + { memset(p, 0, sizeof(T) * n); - allocator::deallocate(p, n); + munlock(p, sizeof(T) * n); + } + std::allocator::deallocate(p, n); + } +}; + + +// +// Allocator that clears its contents before deletion. +// +template +struct zero_after_free_allocator : public std::allocator +{ + // MSVC8 default copy constructor is broken + typedef std::allocator base; + typedef typename base::size_type size_type; + typedef typename base::difference_type difference_type; + typedef typename base::pointer pointer; + typedef typename base::const_pointer const_pointer; + typedef typename base::reference reference; + typedef typename base::const_reference const_reference; + typedef typename base::value_type value_type; + zero_after_free_allocator() throw() {} + zero_after_free_allocator(const zero_after_free_allocator& a) throw() : base(a) {} + template + zero_after_free_allocator(const zero_after_free_allocator& a) throw() : base(a) {} + ~zero_after_free_allocator() throw() {} + template struct rebind + { typedef zero_after_free_allocator<_Other> other; }; + + void deallocate(T* p, std::size_t n) + { + if (p != NULL) + memset(p, 0, sizeof(T) * n); + std::allocator::deallocate(p, n); } }; @@ -787,7 +863,7 @@ struct secure_allocator : public std::allocator class CDataStream { protected: - typedef vector > vector_type; + typedef std::vector > vector_type; vector_type vch; unsigned int nReadPos; short state; @@ -806,45 +882,45 @@ public: typedef vector_type::const_iterator const_iterator; typedef vector_type::reverse_iterator reverse_iterator; - explicit CDataStream(int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) + explicit CDataStream(int nTypeIn=SER_NETWORK, int nVersionIn=PROTOCOL_VERSION) { Init(nTypeIn, nVersionIn); } - CDataStream(const_iterator pbegin, const_iterator pend, int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) : vch(pbegin, pend) + CDataStream(const_iterator pbegin, const_iterator pend, int nTypeIn=SER_NETWORK, int nVersionIn=PROTOCOL_VERSION) : vch(pbegin, pend) { Init(nTypeIn, nVersionIn); } #if !defined(_MSC_VER) || _MSC_VER >= 1300 - CDataStream(const char* pbegin, const char* pend, int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) : vch(pbegin, pend) + CDataStream(const char* pbegin, const char* pend, int nTypeIn=SER_NETWORK, int nVersionIn=PROTOCOL_VERSION) : vch(pbegin, pend) { Init(nTypeIn, nVersionIn); } #endif - CDataStream(const vector_type& vchIn, int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) : vch(vchIn.begin(), vchIn.end()) + CDataStream(const vector_type& vchIn, int nTypeIn=SER_NETWORK, int nVersionIn=PROTOCOL_VERSION) : vch(vchIn.begin(), vchIn.end()) { Init(nTypeIn, nVersionIn); } - CDataStream(const vector& vchIn, int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) : vch(vchIn.begin(), vchIn.end()) + CDataStream(const std::vector& vchIn, int nTypeIn=SER_NETWORK, int nVersionIn=PROTOCOL_VERSION) : vch(vchIn.begin(), vchIn.end()) { Init(nTypeIn, nVersionIn); } - CDataStream(const vector& vchIn, int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) : vch((char*)&vchIn.begin()[0], (char*)&vchIn.end()[0]) + CDataStream(const std::vector& vchIn, int nTypeIn=SER_NETWORK, int nVersionIn=PROTOCOL_VERSION) : vch((char*)&vchIn.begin()[0], (char*)&vchIn.end()[0]) { Init(nTypeIn, nVersionIn); } - void Init(int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) + void Init(int nTypeIn=SER_NETWORK, int nVersionIn=PROTOCOL_VERSION) { nReadPos = 0; nType = nTypeIn; nVersion = nVersionIn; state = 0; - exceptmask = ios::badbit | ios::failbit; + exceptmask = std::ios::badbit | std::ios::failbit; } CDataStream& operator+=(const CDataStream& b) @@ -860,9 +936,9 @@ public: return (ret); } - string str() const + std::string str() const { - return (string(begin(), end())); + return (std::string(begin(), end())); } @@ -895,7 +971,7 @@ public: vch.insert(it, first, last); } - void insert(iterator it, vector::const_iterator first, vector::const_iterator last) + void insert(iterator it, std::vector::const_iterator first, std::vector::const_iterator last) { if (it == vch.begin() + nReadPos && last - first <= nReadPos) { @@ -985,7 +1061,7 @@ public: } bool eof() const { return size() == 0; } - bool fail() const { return state & (ios::badbit | ios::failbit); } + bool fail() const { return state & (std::ios::badbit | std::ios::failbit); } bool good() const { return !eof() && (state == 0); } void clear(short n) { state = n; } // name conflict with vector clear() short exceptions() { return exceptmask; } @@ -1009,7 +1085,7 @@ public: { if (nReadPosNext > vch.size()) { - setstate(ios::failbit, "CDataStream::read() : end of data"); + setstate(std::ios::failbit, "CDataStream::read() : end of data"); memset(pch, 0, nSize); nSize = vch.size() - nReadPos; } @@ -1032,7 +1108,7 @@ public: { if (nReadPosNext > vch.size()) { - setstate(ios::failbit, "CDataStream::ignore() : end of data"); + setstate(std::ios::failbit, "CDataStream::ignore() : end of data"); nSize = vch.size() - nReadPos; } nReadPos = 0; @@ -1052,7 +1128,7 @@ public: } template - void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const + void Serialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION) const { // Special case: stream << stream concatenates like stream += stream if (!vch.empty()) @@ -1161,13 +1237,13 @@ public: typedef FILE element_type; - CAutoFile(FILE* filenew=NULL, int nTypeIn=SER_DISK, int nVersionIn=VERSION) + CAutoFile(FILE* filenew=NULL, int nTypeIn=SER_DISK, int nVersionIn=PROTOCOL_VERSION) { file = filenew; nType = nTypeIn; nVersion = nVersionIn; state = 0; - exceptmask = ios::badbit | ios::failbit; + exceptmask = std::ios::badbit | std::ios::failbit; } ~CAutoFile() @@ -1201,7 +1277,7 @@ public: throw std::ios_base::failure(psz); } - bool fail() const { return state & (ios::badbit | ios::failbit); } + bool fail() const { return state & (std::ios::badbit | std::ios::failbit); } bool good() const { return state == 0; } void clear(short n = 0) { state = n; } short exceptions() { return exceptmask; } @@ -1219,7 +1295,7 @@ public: if (!file) throw std::ios_base::failure("CAutoFile::read : file handle is NULL"); if (fread(pch, 1, nSize, file) != nSize) - setstate(ios::failbit, feof(file) ? "CAutoFile::read : end of file" : "CAutoFile::read : fread failed"); + setstate(std::ios::failbit, feof(file) ? "CAutoFile::read : end of file" : "CAutoFile::read : fread failed"); return (*this); } @@ -1228,7 +1304,7 @@ public: if (!file) throw std::ios_base::failure("CAutoFile::write : file handle is NULL"); if (fwrite(pch, 1, nSize, file) != nSize) - setstate(ios::failbit, "CAutoFile::write : write failed"); + setstate(std::ios::failbit, "CAutoFile::write : write failed"); return (*this); } @@ -1259,3 +1335,5 @@ public: return (*this); } }; + +#endif