6 #ifndef BITCOIN_SERIALIZE_H
7 #define BITCOIN_SERIALIZE_H
23 #include <boost/tuple/tuple.hpp>
24 #include <boost/type_traits/is_fundamental.hpp>
30 static const unsigned int MAX_SIZE = 0x02000000;
35 inline T&
REF(
const T& val)
37 return const_cast<T&
>(val);
54 #define IMPLEMENT_SERIALIZE(statements) \
55 unsigned int GetSerializeSize(int nType, int nVersion) const \
57 CSerActionGetSerializeSize ser_action; \
58 const bool fGetSize = true; \
59 const bool fWrite = false; \
60 const bool fRead = false; \
61 unsigned int nSerSize = 0; \
62 ser_streamplaceholder s; \
63 assert(fGetSize||fWrite||fRead); \
65 s.nVersion = nVersion; \
69 template<typename Stream> \
70 void Serialize(Stream& s, int nType, int nVersion) const \
72 CSerActionSerialize ser_action; \
73 const bool fGetSize = false; \
74 const bool fWrite = true; \
75 const bool fRead = false; \
76 unsigned int nSerSize = 0; \
77 assert(fGetSize||fWrite||fRead); \
80 template<typename Stream> \
81 void Unserialize(Stream& s, int nType, int nVersion) \
83 CSerActionUnserialize ser_action; \
84 const bool fGetSize = false; \
85 const bool fWrite = false; \
86 const bool fRead = true; \
87 unsigned int nSerSize = 0; \
88 assert(fGetSize||fWrite||fRead); \
92 #define READWRITE(obj) (nSerSize += ::SerReadWrite(s, (obj), nType, nVersion, ser_action))
102 #define WRITEDATA(s, obj) s.write((char*)&(obj), sizeof(obj))
103 #define READDATA(s, obj) s.read((char*)&(obj), sizeof(obj))
115 inline unsigned int GetSerializeSize(
unsigned long long a,
int,
int=0) {
return sizeof(a); }
120 template<
typename Stream>
inline void Serialize(Stream& s,
signed char a,
int,
int=0) {
WRITEDATA(s, a); }
121 template<
typename Stream>
inline void Serialize(Stream& s,
unsigned char a,
int,
int=0) {
WRITEDATA(s, a); }
122 template<
typename Stream>
inline void Serialize(Stream& s,
signed short a,
int,
int=0) {
WRITEDATA(s, a); }
123 template<
typename Stream>
inline void Serialize(Stream& s,
unsigned short a,
int,
int=0) {
WRITEDATA(s, a); }
124 template<
typename Stream>
inline void Serialize(Stream& s,
signed int a,
int,
int=0) {
WRITEDATA(s, a); }
125 template<
typename Stream>
inline void Serialize(Stream& s,
unsigned int a,
int,
int=0) {
WRITEDATA(s, a); }
126 template<
typename Stream>
inline void Serialize(Stream& s,
signed long a,
int,
int=0) {
WRITEDATA(s, a); }
127 template<
typename Stream>
inline void Serialize(Stream& s,
unsigned long a,
int,
int=0) {
WRITEDATA(s, a); }
128 template<
typename Stream>
inline void Serialize(Stream& s,
signed long long a,
int,
int=0) {
WRITEDATA(s, a); }
129 template<
typename Stream>
inline void Serialize(Stream& s,
unsigned long long a,
int,
int=0) {
WRITEDATA(s, a); }
131 template<
typename Stream>
inline void Serialize(Stream& s,
double a,
int,
int=0) {
WRITEDATA(s, a); }
134 template<
typename Stream>
inline void Unserialize(Stream& s,
signed char& a,
int,
int=0) {
READDATA(s, a); }
135 template<
typename Stream>
inline void Unserialize(Stream& s,
unsigned char& a,
int,
int=0) {
READDATA(s, a); }
136 template<
typename Stream>
inline void Unserialize(Stream& s,
signed short& a,
int,
int=0) {
READDATA(s, a); }
137 template<
typename Stream>
inline void Unserialize(Stream& s,
unsigned short& a,
int,
int=0) {
READDATA(s, a); }
138 template<
typename Stream>
inline void Unserialize(Stream& s,
signed int& a,
int,
int=0) {
READDATA(s, a); }
139 template<
typename Stream>
inline void Unserialize(Stream& s,
unsigned int& a,
int,
int=0) {
READDATA(s, a); }
140 template<
typename Stream>
inline void Unserialize(Stream& s,
signed long& a,
int,
int=0) {
READDATA(s, a); }
141 template<
typename Stream>
inline void Unserialize(Stream& s,
unsigned long& a,
int,
int=0) {
READDATA(s, a); }
142 template<
typename Stream>
inline void Unserialize(Stream& s,
signed long long& a,
int,
int=0) {
READDATA(s, a); }
143 template<
typename Stream>
inline void Unserialize(Stream& s,
unsigned long long& a,
int,
int=0) {
READDATA(s, a); }
148 template<
typename Stream>
inline void Serialize(Stream& s,
bool a,
int,
int=0) {
char f=a;
WRITEDATA(s, f); }
149 template<
typename Stream>
inline void Unserialize(Stream& s,
bool& a,
int,
int=0) {
char f;
READDATA(s, f); a=f; }
165 if (nSize < 253)
return sizeof(
unsigned char);
166 else if (nSize <= std::numeric_limits<unsigned short>::max())
return sizeof(
unsigned char) +
sizeof(
unsigned short);
167 else if (nSize <= std::numeric_limits<unsigned int>::max())
return sizeof(
unsigned char) +
sizeof(
unsigned int);
168 else return sizeof(
unsigned char) +
sizeof(uint64_t);
171 template<
typename Stream>
176 unsigned char chSize = nSize;
179 else if (nSize <= std::numeric_limits<unsigned short>::max())
181 unsigned char chSize = 253;
182 unsigned short xSize = nSize;
186 else if (nSize <= std::numeric_limits<unsigned int>::max())
188 unsigned char chSize = 254;
189 unsigned int xSize = nSize;
195 unsigned char chSize = 255;
196 uint64_t xSize = nSize;
203 template<
typename Stream>
206 unsigned char chSize;
208 uint64_t nSizeRet = 0;
213 else if (chSize == 253)
215 unsigned short xSize;
219 throw std::ios_base::failure(
"non-canonical ReadCompactSize()");
221 else if (chSize == 254)
226 if (nSizeRet < 0x10000u)
227 throw std::ios_base::failure(
"non-canonical ReadCompactSize()");
234 if (nSizeRet < 0x100000000LLu)
235 throw std::ios_base::failure(
"non-canonical ReadCompactSize()");
238 throw std::ios_base::failure(
"ReadCompactSize() : size too large");
277 template<
typename Stream,
typename I>
280 unsigned char tmp[(
sizeof(n)*8+6)/7];
283 tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
294 template<
typename Stream,
typename I>
299 unsigned char chData;
301 n = (n << 7) | (chData & 0x7F);
309 #define FLATDATA(obj) REF(CFlatData((char*)&(obj), (char*)&(obj) + sizeof(obj)))
310 #define VARINT(obj) REF(WrapVarInt(REF(obj)))
311 #define LIMITED_STRING(obj,n) REF(LimitedString< n >(REF(obj)))
321 CFlatData(
void* pbeginIn,
void* pendIn) : pbegin((char*)pbeginIn), pend((char*)pendIn) { }
332 template<
typename Stream>
335 s.write(pbegin, pend - pbegin);
338 template<
typename Stream>
341 s.read(pbegin, pend - pbegin);
354 return GetSizeOfVarInt<I>(
n);
357 template<
typename Stream>
359 WriteVarInt<Stream,I>(s,
n);
362 template<
typename Stream>
364 n = ReadVarInt<Stream,I>(s);
368 template<
size_t Limit>
376 template<
typename Stream>
381 throw std::ios_base::failure(
"String length limit exceeded");
385 s.read((
char*)&
string[0], size);
388 template<
typename Stream>
393 s.write((
char*)&
string[0],
string.size());
410 template<
typename C>
unsigned int GetSerializeSize(
const std::basic_string<C>& str,
int,
int=0);
411 template<
typename Stream,
typename C>
void Serialize(Stream& os,
const std::basic_string<C>& str,
int,
int=0);
412 template<
typename Stream,
typename C>
void Unserialize(Stream& is, std::basic_string<C>& str,
int,
int=0);
415 template<
typename T,
typename A>
unsigned int GetSerializeSize_impl(
const std::vector<T, A>& v,
int nType,
int nVersion,
const boost::true_type&);
416 template<
typename T,
typename A>
unsigned int GetSerializeSize_impl(
const std::vector<T, A>& v,
int nType,
int nVersion,
const boost::false_type&);
417 template<
typename T,
typename A>
inline unsigned int GetSerializeSize(
const std::vector<T, A>& v,
int nType,
int nVersion);
418 template<
typename Stream,
typename T,
typename A>
void Serialize_impl(Stream& os,
const std::vector<T, A>& v,
int nType,
int nVersion,
const boost::true_type&);
419 template<
typename Stream,
typename T,
typename A>
void Serialize_impl(Stream& os,
const std::vector<T, A>& v,
int nType,
int nVersion,
const boost::false_type&);
420 template<
typename Stream,
typename T,
typename A>
inline void Serialize(Stream& os,
const std::vector<T, A>& v,
int nType,
int nVersion);
421 template<
typename Stream,
typename T,
typename A>
void Unserialize_impl(Stream& is, std::vector<T, A>& v,
int nType,
int nVersion,
const boost::true_type&);
422 template<
typename Stream,
typename T,
typename A>
void Unserialize_impl(Stream& is, std::vector<T, A>& v,
int nType,
int nVersion,
const boost::false_type&);
423 template<
typename Stream,
typename T,
typename A>
inline void Unserialize(Stream& is, std::vector<T, A>& v,
int nType,
int nVersion);
427 template<
typename Stream>
void Serialize(Stream& os,
const CScript& v,
int nType,
int nVersion);
428 template<
typename Stream>
void Unserialize(Stream& is,
CScript& v,
int nType,
int nVersion);
431 template<
typename K,
typename T>
unsigned int GetSerializeSize(
const std::pair<K, T>& item,
int nType,
int nVersion);
432 template<
typename Stream,
typename K,
typename T>
void Serialize(Stream& os,
const std::pair<K, T>& item,
int nType,
int nVersion);
433 template<
typename Stream,
typename K,
typename T>
void Unserialize(Stream& is, std::pair<K, T>& item,
int nType,
int nVersion);
436 template<
typename T0,
typename T1,
typename T2>
unsigned int GetSerializeSize(
const boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion);
437 template<
typename Stream,
typename T0,
typename T1,
typename T2>
void Serialize(Stream& os,
const boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion);
438 template<
typename Stream,
typename T0,
typename T1,
typename T2>
void Unserialize(Stream& is, boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion);
441 template<
typename T0,
typename T1,
typename T2,
typename T3>
unsigned int GetSerializeSize(
const boost::tuple<T0, T1, T2, T3>& item,
int nType,
int nVersion);
442 template<
typename Stream,
typename T0,
typename T1,
typename T2,
typename T3>
void Serialize(Stream& os,
const boost::tuple<T0, T1, T2, T3>& item,
int nType,
int nVersion);
443 template<
typename Stream,
typename T0,
typename T1,
typename T2,
typename T3>
void Unserialize(Stream& is, boost::tuple<T0, T1, T2, T3>& item,
int nType,
int nVersion);
446 template<
typename K,
typename T,
typename Pred,
typename A>
unsigned int GetSerializeSize(
const std::map<K, T, Pred, A>& m,
int nType,
int nVersion);
447 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);
448 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);
451 template<
typename K,
typename Pred,
typename A>
unsigned int GetSerializeSize(
const std::set<K, Pred, A>& m,
int nType,
int nVersion);
452 template<
typename Stream,
typename K,
typename Pred,
typename A>
void Serialize(Stream& os,
const std::set<K, Pred, A>& m,
int nType,
int nVersion);
453 template<
typename Stream,
typename K,
typename Pred,
typename A>
void Unserialize(Stream& is, std::set<K, Pred, A>& m,
int nType,
int nVersion);
468 return a.GetSerializeSize((
int)nType, nVersion);
471 template<
typename Stream,
typename T>
472 inline void Serialize(Stream& os,
const T& a,
long nType,
int nVersion)
474 a.Serialize(os, (
int)nType, nVersion);
477 template<
typename Stream,
typename T>
478 inline void Unserialize(Stream& is, T& a,
long nType,
int nVersion)
480 a.Unserialize(is, (
int)nType, nVersion);
496 template<
typename Stream,
typename C>
497 void Serialize(Stream& os,
const std::basic_string<C>& str,
int,
int)
501 os.write((
char*)&str[0], str.size() *
sizeof(str[0]));
504 template<
typename Stream,
typename C>
510 is.read((
char*)&str[0], nSize *
sizeof(str[0]));
518 template<
typename T,
typename A>
524 template<
typename T,
typename A>
528 for (
typename std::vector<T, A>::const_iterator vi = v.begin(); vi != v.end(); ++vi)
533 template<
typename T,
typename A>
540 template<
typename Stream,
typename T,
typename A>
541 void Serialize_impl(Stream& os,
const std::vector<T, A>& v,
int nType,
int nVersion,
const boost::true_type&)
545 os.write((
char*)&v[0], v.size() *
sizeof(T));
548 template<
typename Stream,
typename T,
typename A>
549 void Serialize_impl(Stream& os,
const std::vector<T, A>& v,
int nType,
int nVersion,
const boost::false_type&)
552 for (
typename std::vector<T, A>::const_iterator vi = v.begin(); vi != v.end(); ++vi)
556 template<
typename Stream,
typename T,
typename A>
557 inline void Serialize(Stream& os,
const std::vector<T, A>& v,
int nType,
int nVersion)
559 Serialize_impl(os, v, nType, nVersion, boost::is_fundamental<T>());
563 template<
typename Stream,
typename T,
typename A>
564 void Unserialize_impl(Stream& is, std::vector<T, A>& v,
int nType,
int nVersion,
const boost::true_type&)
572 unsigned int blk = std::min(nSize - i, (
unsigned int)(1 + 4999999 /
sizeof(T)));
574 is.read((
char*)&v[i], blk *
sizeof(T));
579 template<
typename Stream,
typename T,
typename A>
580 void Unserialize_impl(Stream& is, std::vector<T, A>& v,
int nType,
int nVersion,
const boost::false_type&)
585 unsigned int nMid = 0;
588 nMid += 5000000 /
sizeof(T);
592 for (; i < nMid; i++)
597 template<
typename Stream,
typename T,
typename A>
598 inline void Unserialize(Stream& is, std::vector<T, A>& v,
int nType,
int nVersion)
610 return GetSerializeSize((
const std::vector<unsigned char>&)v, nType, nVersion);
613 template<
typename Stream>
616 Serialize(os, (
const std::vector<unsigned char>&)v, nType, nVersion);
619 template<
typename Stream>
622 Unserialize(is, (std::vector<unsigned char>&)v, nType, nVersion);
630 template<
typename K,
typename T>
636 template<
typename Stream,
typename K,
typename T>
637 void Serialize(Stream& os,
const std::pair<K, T>& item,
int nType,
int nVersion)
639 Serialize(os, item.first, nType, nVersion);
640 Serialize(os, item.second, nType, nVersion);
643 template<
typename Stream,
typename K,
typename T>
644 void Unserialize(Stream& is, std::pair<K, T>& item,
int nType,
int nVersion)
655 template<
typename T0,
typename T1,
typename T2>
656 unsigned int GetSerializeSize(
const boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion)
658 unsigned int nSize = 0;
665 template<
typename Stream,
typename T0,
typename T1,
typename T2>
666 void Serialize(Stream& os,
const boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion)
668 Serialize(os, boost::get<0>(item), nType, nVersion);
669 Serialize(os, boost::get<1>(item), nType, nVersion);
670 Serialize(os, boost::get<2>(item), nType, nVersion);
673 template<
typename Stream,
typename T0,
typename T1,
typename T2>
674 void Unserialize(Stream& is, boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion)
676 Unserialize(is, boost::get<0>(item), nType, nVersion);
677 Unserialize(is, boost::get<1>(item), nType, nVersion);
678 Unserialize(is, boost::get<2>(item), nType, nVersion);
686 template<
typename T0,
typename T1,
typename T2,
typename T3>
687 unsigned int GetSerializeSize(
const boost::tuple<T0, T1, T2, T3>& item,
int nType,
int nVersion)
689 unsigned int nSize = 0;
697 template<
typename Stream,
typename T0,
typename T1,
typename T2,
typename T3>
698 void Serialize(Stream& os,
const boost::tuple<T0, T1, T2, T3>& item,
int nType,
int nVersion)
700 Serialize(os, boost::get<0>(item), nType, nVersion);
701 Serialize(os, boost::get<1>(item), nType, nVersion);
702 Serialize(os, boost::get<2>(item), nType, nVersion);
703 Serialize(os, boost::get<3>(item), nType, nVersion);
706 template<
typename Stream,
typename T0,
typename T1,
typename T2,
typename T3>
707 void Unserialize(Stream& is, boost::tuple<T0, T1, T2, T3>& item,
int nType,
int nVersion)
709 Unserialize(is, boost::get<0>(item), nType, nVersion);
710 Unserialize(is, boost::get<1>(item), nType, nVersion);
711 Unserialize(is, boost::get<2>(item), nType, nVersion);
712 Unserialize(is, boost::get<3>(item), nType, nVersion);
720 template<
typename K,
typename T,
typename Pred,
typename A>
724 for (
typename std::map<K, T, Pred, A>::const_iterator mi = m.begin(); mi != m.end(); ++mi)
729 template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
730 void Serialize(Stream& os,
const std::map<K, T, Pred, A>& m,
int nType,
int nVersion)
733 for (
typename std::map<K, T, Pred, A>::const_iterator mi = m.begin(); mi != m.end(); ++mi)
737 template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
738 void Unserialize(Stream& is, std::map<K, T, Pred, A>& m,
int nType,
int nVersion)
742 typename std::map<K, T, Pred, A>::iterator mi = m.begin();
743 for (
unsigned int i = 0; i < nSize; i++)
745 std::pair<K, T> item;
747 mi = m.insert(mi, item);
756 template<
typename K,
typename Pred,
typename A>
760 for (
typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
765 template<
typename Stream,
typename K,
typename Pred,
typename A>
766 void Serialize(Stream& os,
const std::set<K, Pred, A>& m,
int nType,
int nVersion)
769 for (
typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
773 template<
typename Stream,
typename K,
typename Pred,
typename A>
774 void Unserialize(Stream& is, std::set<K, Pred, A>& m,
int nType,
int nVersion)
778 typename std::set<K, Pred, A>::iterator it = m.begin();
779 for (
unsigned int i = 0; i < nSize; i++)
783 it = m.insert(it, key);
796 template<
typename Stream,
typename T>
802 template<
typename Stream,
typename T>
809 template<
typename Stream,
typename T>
863 Init(nTypeIn, nVersionIn);
866 CDataStream(const_iterator pbegin, const_iterator pend,
int nTypeIn,
int nVersionIn) : vch(pbegin, pend)
868 Init(nTypeIn, nVersionIn);
871 #if !defined(_MSC_VER) || _MSC_VER >= 1300
872 CDataStream(
const char* pbegin,
const char* pend,
int nTypeIn,
int nVersionIn) : vch(pbegin, pend)
874 Init(nTypeIn, nVersionIn);
880 Init(nTypeIn, nVersionIn);
883 CDataStream(
const std::vector<char>& vchIn,
int nTypeIn,
int nVersionIn) : vch(vchIn.
begin(), vchIn.
end())
885 Init(nTypeIn, nVersionIn);
888 CDataStream(
const std::vector<unsigned char>& vchIn,
int nTypeIn,
int nVersionIn) : vch((char*)&vchIn.
begin()[0], (char*)&vchIn.
end()[0])
890 Init(nTypeIn, nVersionIn);
893 void Init(
int nTypeIn,
int nVersionIn)
897 nVersion = nVersionIn;
899 exceptmask = std::ios::badbit | std::ios::failbit;
917 return (std::string(
begin(),
end()));
926 const_iterator
end()
const {
return vch.end(); }
927 iterator
end() {
return vch.end(); }
930 void resize(size_type n, value_type c=0) { vch.resize(n + nReadPos, c); }
931 void reserve(size_type n) { vch.reserve(n + nReadPos); }
934 void clear() { vch.clear(); nReadPos = 0; }
935 iterator
insert(iterator it,
const char& x=
char()) {
return vch.insert(it, x); }
936 void insert(iterator it, size_type n,
const char& x) { vch.insert(it, n, x); }
938 void insert(iterator it, std::vector<char>::const_iterator first, std::vector<char>::const_iterator last)
940 assert(last - first >= 0);
941 if (it == vch.begin() + nReadPos && (
unsigned int)(last - first) <=
nReadPos)
944 nReadPos -= (last - first);
945 memcpy(&vch[nReadPos], &first[0], last - first);
948 vch.insert(it, first, last);
951 #if !defined(_MSC_VER) || _MSC_VER >= 1300
952 void insert(iterator it,
const char* first,
const char* last)
954 assert(last - first >= 0);
955 if (it == vch.begin() + nReadPos && (
unsigned int)(last - first) <=
nReadPos)
958 nReadPos -= (last - first);
959 memcpy(&vch[nReadPos], &first[0], last - first);
962 vch.insert(it, first, last);
971 if (++nReadPos >= vch.size())
975 return vch.erase(vch.begin(), vch.end());
980 return vch.erase(it);
983 iterator
erase(iterator first, iterator last)
985 if (first == vch.begin() +
nReadPos)
988 if (last == vch.end())
991 return vch.erase(vch.begin(), vch.end());
995 nReadPos = (last - vch.begin());
1000 return vch.erase(first, last);
1005 vch.erase(vch.begin(), vch.begin() +
nReadPos);
1025 if (state & exceptmask)
1026 throw std::ios_base::failure(psz);
1030 bool fail()
const {
return state & (std::ios::badbit | std::ios::failbit); }
1031 bool good()
const {
return !
eof() && (state == 0); }
1049 unsigned int nReadPosNext = nReadPos + nSize;
1050 if (nReadPosNext >= vch.size())
1052 if (nReadPosNext > vch.size())
1054 setstate(std::ios::failbit,
"CDataStream::read() : end of data");
1055 memset(pch, 0, nSize);
1058 memcpy(pch, &vch[nReadPos], nSize);
1063 memcpy(pch, &vch[nReadPos], nSize);
1064 nReadPos = nReadPosNext;
1072 unsigned int nReadPosNext = nReadPos + nSize;
1073 if (nReadPosNext >= vch.size())
1075 if (nReadPosNext > vch.size())
1076 setstate(std::ios::failbit,
"CDataStream::ignore() : end of data");
1081 nReadPos = nReadPosNext;
1089 vch.insert(vch.end(), pch, pch + nSize);
1093 template<
typename Stream>
1098 s.write((
char*)&vch[0], vch.size() *
sizeof(vch[0]));
1101 template<
typename T>
1108 template<
typename T>
1116 template<
typename T>
1125 data.insert(data.end(),
begin(),
end());
1159 nVersion = nVersionIn;
1161 exceptmask = std::ios::badbit | std::ios::failbit;
1171 if (file != NULL && file != stdin && file != stdout && file != stderr)
1191 if (state & exceptmask)
1192 throw std::ios_base::failure(psz);
1195 bool fail()
const {
return state & (std::ios::badbit | std::ios::failbit); }
1196 bool good()
const {
return state == 0; }
1211 throw std::ios_base::failure(
"CAutoFile::read : file handle is NULL");
1212 if (fread(pch, 1, nSize, file) != nSize)
1213 setstate(std::ios::failbit, feof(file) ?
"CAutoFile::read : end of file" :
"CAutoFile::read : fread failed");
1220 throw std::ios_base::failure(
"CAutoFile::write : file handle is NULL");
1221 if (fwrite(pch, 1, nSize, file) != nSize)
1222 setstate(std::ios::failbit,
"CAutoFile::write : write failed");
1226 template<
typename T>
1233 template<
typename T>
1238 throw std::ios_base::failure(
"CAutoFile::operator<< : file handle is NULL");
1243 template<
typename T>
1248 throw std::ios_base::failure(
"CAutoFile::operator>> : file handle is NULL");
1273 if (state & exceptmask)
1274 throw std::ios_base::failure(psz);
1279 unsigned int pos = nSrcPos % vchBuf.size();
1280 unsigned int readNow = vchBuf.size() - pos;
1281 unsigned int nAvail = vchBuf.size() - (nSrcPos -
nReadPos) - nRewind;
1282 if (nAvail < readNow)
1286 size_t read = fread((
void*)&vchBuf[pos], 1, readNow, src);
1288 setstate(std::ios_base::failbit, feof(src) ?
"CBufferedFile::Fill : end of file" :
"CBufferedFile::Fill : fread failed");
1300 CBufferedFile(FILE *fileIn, uint64_t nBufSize, uint64_t nRewindIn,
int nTypeIn,
int nVersionIn) :
1301 src(fileIn), nSrcPos(0), nReadPos(0), nReadLimit((uint64_t)(-1)), nRewind(nRewindIn), vchBuf(nBufSize, 0),
1302 state(0), exceptmask(
std::ios_base::badbit |
std::ios_base::failbit), nType(nTypeIn), nVersion(nVersionIn) {
1312 return nReadPos == nSrcPos && feof(src);
1317 if (nSize + nReadPos > nReadLimit)
1318 throw std::ios_base::failure(
"Read attempted past buffer limit");
1319 if (nSize + nRewind > vchBuf.size())
1320 throw std::ios_base::failure(
"Read larger than buffer size");
1322 if (nReadPos == nSrcPos)
1324 unsigned int pos = nReadPos % vchBuf.size();
1325 size_t nNow = nSize;
1326 if (nNow + pos > vchBuf.size())
1327 nNow = vchBuf.size() - pos;
1328 if (nNow + nReadPos > nSrcPos)
1330 memcpy(pch, &vchBuf[pos], nNow);
1346 if (nReadPos + nRewind < nSrcPos) {
1349 }
else if (nReadPos > nSrcPos) {
1358 long nLongPos = nPos;
1359 if (nPos != (uint64_t)nLongPos)
1361 if (fseek(src, nLongPos, SEEK_SET))
1363 nLongPos = ftell(src);
1365 nReadPos = nLongPos;
1373 if (nPos < nReadPos)
1379 template<
typename T>
1389 if (nReadPos == nSrcPos)
1391 if (vchBuf[nReadPos % vchBuf.size()] == ch)
void setstate(short bits, const char *psz)
void Serialize(Stream &s, int nType, int nVersion) const
CAutoFile & read(char *pch, size_t nSize)
void setstate(short bits, const char *psz)
void Init(int nTypeIn, int nVersionIn)
CSerializeData vector_type
vector_type::iterator iterator
LimitedString(std::string &string)
unsigned int SerReadWrite(Stream &s, const T &obj, int nType, int nVersion, CSerActionGetSerializeSize ser_action)
vector_type::allocator_type allocator_type
const_iterator begin() const
void GetAndClear(CSerializeData &data)
CAutoFile & operator>>(T &obj)
uint64_t ReadCompactSize(Stream &is)
CDataStream(const_iterator pbegin, const_iterator pend, int nTypeIn, int nVersionIn)
CDataStream & ignore(int nSize)
CDataStream(const std::vector< unsigned char > &vchIn, int nTypeIn, int nVersionIn)
vector_type::size_type size_type
void resize(size_type n, value_type c=0)
void Serialize(Stream &s, char a, int, int=0)
CDataStream(const vector_type &vchIn, int nTypeIn, int nVersionIn)
unsigned int GetSizeOfCompactSize(uint64_t nSize)
CDataStream & read(char *pch, int nSize)
vector_type::reference reference
vector_type::value_type value_type
CBufferedFile & read(char *pch, size_t nSize)
short exceptions(short mask)
Double ended buffer combining vector and stream-like interfaces.
unsigned int GetSerializeSize(const T &obj)
vector_type::reverse_iterator reverse_iterator
iterator erase(iterator it)
CAutoFile(FILE *filenew, int nTypeIn, int nVersionIn)
friend CDataStream operator+(const CDataStream &a, const CDataStream &b)
#define WRITEDATA(s, obj)
void WriteVarInt(Stream &os, I n)
CDataStream(int nTypeIn, int nVersionIn)
void insert(iterator it, std::vector< char >::const_iterator first, std::vector< char >::const_iterator last)
vector_type::const_reference const_reference
bool SetLimit(uint64_t nPos=(uint64_t)(-1))
void setstate(short bits, const char *psz)
unsigned int GetSerializeSize(int, int) const
const char * begin() const
CDataStream(const std::vector< char > &vchIn, int nTypeIn, int nVersionIn)
vector_type::const_iterator const_iterator
CBufferedFile(FILE *fileIn, uint64_t nBufSize, uint64_t nRewindIn, int nTypeIn, int nVersionIn)
unsigned int GetSerializeSize(char a, int, int=0)
CDataStream(const char *pbegin, const char *pend, int nTypeIn, int nVersionIn)
void Unserialize(Stream &s, char &a, int, int=0)
CDataStream & operator+=(const CDataStream &b)
std::vector< char, zero_after_free_allocator< char > > CSerializeData
CDataStream & operator>>(T &obj)
void Serialize(Stream &s, int, int=0) const
void Unserialize(Stream &s, int, int=0)
void Serialize(Stream &s, int, int) const
reference operator[](size_type pos)
bool SetPos(uint64_t nPos)
unsigned int GetSizeOfVarInt(I n)
unsigned int GetSerializeSize(int, int=0) const
unsigned int GetSerializeSize(int, int=0) const
void Unserialize(Stream &s, int, int=0)
void Unserialize(Stream &s, int, int)
CFlatData(void *pbeginIn, void *pendIn)
CAutoFile & write(const char *pch, size_t nSize)
void Unserialize_impl(Stream &is, std::vector< T, A > &v, int nType, int nVersion, const boost::true_type &)
FILE * operator=(FILE *pnew)
iterator insert(iterator it, const char &x=char())
CDataStream & write(const char *pch, int nSize)
static const unsigned int MAX_SIZE
CDataStream & operator<<(const T &obj)
void reserve(size_type n)
Serialized script, used inside transaction inputs and outputs.
void * memcpy(void *a, const void *b, size_t c)
void insert(iterator it, size_type n, const char &x)
short exceptions(short mask)
vector_type::difference_type difference_type
const_reference operator[](size_type pos) const
unsigned int GetSerializeSize(const T &obj)
void insert(iterator it, const char *first, const char *last)
std::vector< char > vchBuf
iterator erase(iterator first, iterator last)
static const CCheckpointData data
void Serialize(Stream &s, int, int=0) const
void Serialize_impl(Stream &os, const std::vector< T, A > &v, int nType, int nVersion, const boost::true_type &)
Wrapper around a FILE* that implements a ring buffer to deserialize from.
void WriteCompactSize(Stream &os, uint64_t nSize)
CBufferedFile & operator>>(T &obj)
CAutoFile & operator<<(const T &obj)
CVarInt< I > WrapVarInt(I &n)
Wrapper for serializing arrays and POD.
unsigned int GetSerializeSize_impl(const std::vector< T, A > &v, int nType, int nVersion, const boost::true_type &)
const_iterator end() const