5 #ifndef BITCOIN_SERIALIZE_H
6 #define BITCOIN_SERIALIZE_H
17 #include <boost/type_traits/is_fundamental.hpp>
18 #include <boost/tuple/tuple.hpp>
19 #include <boost/tuple/tuple_comparison.hpp>
20 #include <boost/tuple/tuple_io.hpp>
31 static const unsigned int MAX_SIZE = 0x02000000;
36 inline T&
REF(
const T& val)
38 return const_cast<T&
>(val);
55 #define IMPLEMENT_SERIALIZE(statements) \
56 unsigned int GetSerializeSize(int nType, int nVersion) const \
58 CSerActionGetSerializeSize ser_action; \
59 const bool fGetSize = true; \
60 const bool fWrite = false; \
61 const bool fRead = false; \
62 unsigned int nSerSize = 0; \
63 ser_streamplaceholder s; \
64 assert(fGetSize||fWrite||fRead); \
66 s.nVersion = nVersion; \
70 template<typename Stream> \
71 void Serialize(Stream& s, int nType, int nVersion) const \
73 CSerActionSerialize ser_action; \
74 const bool fGetSize = false; \
75 const bool fWrite = true; \
76 const bool fRead = false; \
77 unsigned int nSerSize = 0; \
78 assert(fGetSize||fWrite||fRead); \
81 template<typename Stream> \
82 void Unserialize(Stream& s, int nType, int nVersion) \
84 CSerActionUnserialize ser_action; \
85 const bool fGetSize = false; \
86 const bool fWrite = false; \
87 const bool fRead = true; \
88 unsigned int nSerSize = 0; \
89 assert(fGetSize||fWrite||fRead); \
93 #define READWRITE(obj) (nSerSize += ::SerReadWrite(s, (obj), nType, nVersion, ser_action))
103 #define WRITEDATA(s, obj) s.write((char*)&(obj), sizeof(obj))
104 #define READDATA(s, obj) s.read((char*)&(obj), sizeof(obj))
121 template<
typename Stream>
inline void Serialize(Stream& s,
signed char a,
int,
int=0) {
WRITEDATA(s, a); }
122 template<
typename Stream>
inline void Serialize(Stream& s,
unsigned char a,
int,
int=0) {
WRITEDATA(s, a); }
123 template<
typename Stream>
inline void Serialize(Stream& s,
signed short a,
int,
int=0) {
WRITEDATA(s, a); }
124 template<
typename Stream>
inline void Serialize(Stream& s,
unsigned short a,
int,
int=0) {
WRITEDATA(s, a); }
125 template<
typename Stream>
inline void Serialize(Stream& s,
signed int a,
int,
int=0) {
WRITEDATA(s, a); }
126 template<
typename Stream>
inline void Serialize(Stream& s,
unsigned int a,
int,
int=0) {
WRITEDATA(s, a); }
127 template<
typename Stream>
inline void Serialize(Stream& s,
signed long a,
int,
int=0) {
WRITEDATA(s, a); }
128 template<
typename Stream>
inline void Serialize(Stream& s,
unsigned long a,
int,
int=0) {
WRITEDATA(s, a); }
132 template<
typename Stream>
inline void Serialize(Stream& s,
double a,
int,
int=0) {
WRITEDATA(s, a); }
135 template<
typename Stream>
inline void Unserialize(Stream& s,
signed char& a,
int,
int=0) {
READDATA(s, a); }
136 template<
typename Stream>
inline void Unserialize(Stream& s,
unsigned char& a,
int,
int=0) {
READDATA(s, a); }
137 template<
typename Stream>
inline void Unserialize(Stream& s,
signed short& a,
int,
int=0) {
READDATA(s, a); }
138 template<
typename Stream>
inline void Unserialize(Stream& s,
unsigned short& a,
int,
int=0) {
READDATA(s, a); }
139 template<
typename Stream>
inline void Unserialize(Stream& s,
signed int& a,
int,
int=0) {
READDATA(s, a); }
140 template<
typename Stream>
inline void Unserialize(Stream& s,
unsigned int& a,
int,
int=0) {
READDATA(s, a); }
141 template<
typename Stream>
inline void Unserialize(Stream& s,
signed long& a,
int,
int=0) {
READDATA(s, a); }
142 template<
typename Stream>
inline void Unserialize(Stream& s,
unsigned long& a,
int,
int=0) {
READDATA(s, a); }
149 template<
typename Stream>
inline void Serialize(Stream& s,
bool a,
int,
int=0) {
char f=a;
WRITEDATA(s, f); }
150 template<
typename Stream>
inline void Unserialize(Stream& s,
bool& a,
int,
int=0) {
char f;
READDATA(s, f); a=f; }
166 if (nSize < 253)
return sizeof(
unsigned char);
167 else if (nSize <= std::numeric_limits<unsigned short>::max())
return sizeof(
unsigned char) +
sizeof(
unsigned short);
168 else if (nSize <= std::numeric_limits<unsigned int>::max())
return sizeof(
unsigned char) +
sizeof(
unsigned int);
169 else return sizeof(
unsigned char) +
sizeof(
uint64);
172 template<
typename Stream>
177 unsigned char chSize = nSize;
180 else if (nSize <= std::numeric_limits<unsigned short>::max())
182 unsigned char chSize = 253;
183 unsigned short xSize = nSize;
187 else if (nSize <= std::numeric_limits<unsigned int>::max())
189 unsigned char chSize = 254;
190 unsigned int xSize = nSize;
196 unsigned char chSize = 255;
204 template<
typename Stream>
207 unsigned char chSize;
214 else if (chSize == 253)
216 unsigned short xSize;
220 else if (chSize == 254)
233 throw std::ios_base::failure(
"ReadCompactSize() : size too large");
272 template<
typename Stream,
typename I>
275 unsigned char tmp[(
sizeof(n)*8+6)/7];
278 tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
289 template<
typename Stream,
typename I>
294 unsigned char chData;
296 n = (n << 7) | (chData & 0x7F);
304 #define FLATDATA(obj) REF(CFlatData((char*)&(obj), (char*)&(obj) + sizeof(obj)))
305 #define VARINT(obj) REF(WrapVarInt(REF(obj)))
315 CFlatData(
void* pbeginIn,
void* pendIn) : pbegin((char*)pbeginIn), pend((char*)pendIn) { }
326 template<
typename Stream>
329 s.write(pbegin, pend - pbegin);
332 template<
typename Stream>
335 s.read(pbegin, pend - pbegin);
348 return GetSizeOfVarInt<I>(
n);
351 template<
typename Stream>
353 WriteVarInt<Stream,I>(s,
n);
356 template<
typename Stream>
358 n = ReadVarInt<Stream,I>(s);
370 template<
typename C>
unsigned int GetSerializeSize(
const std::basic_string<C>& str,
int,
int=0);
371 template<
typename Stream,
typename C>
void Serialize(Stream& os,
const std::basic_string<C>& str,
int,
int=0);
372 template<
typename Stream,
typename C>
void Unserialize(Stream& is, std::basic_string<C>& str,
int,
int=0);
375 template<
typename T,
typename A>
unsigned int GetSerializeSize_impl(
const std::vector<T, A>& v,
int nType,
int nVersion,
const boost::true_type&);
376 template<
typename T,
typename A>
unsigned int GetSerializeSize_impl(
const std::vector<T, A>& v,
int nType,
int nVersion,
const boost::false_type&);
377 template<
typename T,
typename A>
inline unsigned int GetSerializeSize(
const std::vector<T, A>& v,
int nType,
int nVersion);
378 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&);
379 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&);
380 template<
typename Stream,
typename T,
typename A>
inline void Serialize(Stream& os,
const std::vector<T, A>& v,
int nType,
int nVersion);
381 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&);
382 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&);
383 template<
typename Stream,
typename T,
typename A>
inline void Unserialize(Stream& is, std::vector<T, A>& v,
int nType,
int nVersion);
387 template<
typename Stream>
void Serialize(Stream& os,
const CScript& v,
int nType,
int nVersion);
388 template<
typename Stream>
void Unserialize(Stream& is,
CScript& v,
int nType,
int nVersion);
391 template<
typename K,
typename T>
unsigned int GetSerializeSize(
const std::pair<K, T>& item,
int nType,
int nVersion);
392 template<
typename Stream,
typename K,
typename T>
void Serialize(Stream& os,
const std::pair<K, T>& item,
int nType,
int nVersion);
393 template<
typename Stream,
typename K,
typename T>
void Unserialize(Stream& is, std::pair<K, T>& item,
int nType,
int nVersion);
396 template<
typename T0,
typename T1,
typename T2>
unsigned int GetSerializeSize(
const boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion);
397 template<
typename Stream,
typename T0,
typename T1,
typename T2>
void Serialize(Stream& os,
const boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion);
398 template<
typename Stream,
typename T0,
typename T1,
typename T2>
void Unserialize(Stream& is, boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion);
401 template<
typename T0,
typename T1,
typename T2,
typename T3>
unsigned int GetSerializeSize(
const boost::tuple<T0, T1, T2, T3>& item,
int nType,
int nVersion);
402 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);
403 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);
406 template<
typename K,
typename T,
typename Pred,
typename A>
unsigned int GetSerializeSize(
const std::map<K, T, Pred, A>& m,
int nType,
int nVersion);
407 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);
408 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);
411 template<
typename K,
typename Pred,
typename A>
unsigned int GetSerializeSize(
const std::set<K, Pred, A>& m,
int nType,
int nVersion);
412 template<
typename Stream,
typename K,
typename Pred,
typename A>
void Serialize(Stream& os,
const std::set<K, Pred, A>& m,
int nType,
int nVersion);
413 template<
typename Stream,
typename K,
typename Pred,
typename A>
void Unserialize(Stream& is, std::set<K, Pred, A>& m,
int nType,
int nVersion);
428 return a.GetSerializeSize((
int)nType, nVersion);
431 template<
typename Stream,
typename T>
432 inline void Serialize(Stream& os,
const T& a,
long nType,
int nVersion)
434 a.Serialize(os, (
int)nType, nVersion);
437 template<
typename Stream,
typename T>
438 inline void Unserialize(Stream& is, T& a,
long nType,
int nVersion)
440 a.Unserialize(is, (
int)nType, nVersion);
456 template<
typename Stream,
typename C>
457 void Serialize(Stream& os,
const std::basic_string<C>& str,
int,
int)
461 os.write((
char*)&str[0], str.size() *
sizeof(str[0]));
464 template<
typename Stream,
typename C>
470 is.read((
char*)&str[0], nSize *
sizeof(str[0]));
478 template<
typename T,
typename A>
484 template<
typename T,
typename A>
488 for (
typename std::vector<T, A>::const_iterator vi = v.begin(); vi != v.end(); ++vi)
493 template<
typename T,
typename A>
500 template<
typename Stream,
typename T,
typename A>
501 void Serialize_impl(Stream& os,
const std::vector<T, A>& v,
int nType,
int nVersion,
const boost::true_type&)
505 os.write((
char*)&v[0], v.size() *
sizeof(T));
508 template<
typename Stream,
typename T,
typename A>
509 void Serialize_impl(Stream& os,
const std::vector<T, A>& v,
int nType,
int nVersion,
const boost::false_type&)
512 for (
typename std::vector<T, A>::const_iterator vi = v.begin(); vi != v.end(); ++vi)
516 template<
typename Stream,
typename T,
typename A>
517 inline void Serialize(Stream& os,
const std::vector<T, A>& v,
int nType,
int nVersion)
519 Serialize_impl(os, v, nType, nVersion, boost::is_fundamental<T>());
523 template<
typename Stream,
typename T,
typename A>
524 void Unserialize_impl(Stream& is, std::vector<T, A>& v,
int nType,
int nVersion,
const boost::true_type&)
532 unsigned int blk = std::min(nSize - i, (
unsigned int)(1 + 4999999 /
sizeof(T)));
534 is.read((
char*)&v[i], blk *
sizeof(T));
539 template<
typename Stream,
typename T,
typename A>
540 void Unserialize_impl(Stream& is, std::vector<T, A>& v,
int nType,
int nVersion,
const boost::false_type&)
545 unsigned int nMid = 0;
548 nMid += 5000000 /
sizeof(T);
552 for (; i < nMid; i++)
557 template<
typename Stream,
typename T,
typename A>
558 inline void Unserialize(Stream& is, std::vector<T, A>& v,
int nType,
int nVersion)
570 return GetSerializeSize((
const std::vector<unsigned char>&)v, nType, nVersion);
573 template<
typename Stream>
576 Serialize(os, (
const std::vector<unsigned char>&)v, nType, nVersion);
579 template<
typename Stream>
582 Unserialize(is, (std::vector<unsigned char>&)v, nType, nVersion);
590 template<
typename K,
typename T>
596 template<
typename Stream,
typename K,
typename T>
597 void Serialize(Stream& os,
const std::pair<K, T>& item,
int nType,
int nVersion)
599 Serialize(os, item.first, nType, nVersion);
600 Serialize(os, item.second, nType, nVersion);
603 template<
typename Stream,
typename K,
typename T>
604 void Unserialize(Stream& is, std::pair<K, T>& item,
int nType,
int nVersion)
615 template<
typename T0,
typename T1,
typename T2>
616 unsigned int GetSerializeSize(
const boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion)
618 unsigned int nSize = 0;
625 template<
typename Stream,
typename T0,
typename T1,
typename T2>
626 void Serialize(Stream& os,
const boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion)
628 Serialize(os, boost::get<0>(item), nType, nVersion);
629 Serialize(os, boost::get<1>(item), nType, nVersion);
630 Serialize(os, boost::get<2>(item), nType, nVersion);
633 template<
typename Stream,
typename T0,
typename T1,
typename T2>
634 void Unserialize(Stream& is, boost::tuple<T0, T1, T2>& item,
int nType,
int nVersion)
636 Unserialize(is, boost::get<0>(item), nType, nVersion);
637 Unserialize(is, boost::get<1>(item), nType, nVersion);
638 Unserialize(is, boost::get<2>(item), nType, nVersion);
646 template<
typename T0,
typename T1,
typename T2,
typename T3>
647 unsigned int GetSerializeSize(
const boost::tuple<T0, T1, T2, T3>& item,
int nType,
int nVersion)
649 unsigned int nSize = 0;
657 template<
typename Stream,
typename T0,
typename T1,
typename T2,
typename T3>
658 void Serialize(Stream& os,
const boost::tuple<T0, T1, T2, T3>& item,
int nType,
int nVersion)
660 Serialize(os, boost::get<0>(item), nType, nVersion);
661 Serialize(os, boost::get<1>(item), nType, nVersion);
662 Serialize(os, boost::get<2>(item), nType, nVersion);
663 Serialize(os, boost::get<3>(item), nType, nVersion);
666 template<
typename Stream,
typename T0,
typename T1,
typename T2,
typename T3>
667 void Unserialize(Stream& is, boost::tuple<T0, T1, T2, T3>& item,
int nType,
int nVersion)
669 Unserialize(is, boost::get<0>(item), nType, nVersion);
670 Unserialize(is, boost::get<1>(item), nType, nVersion);
671 Unserialize(is, boost::get<2>(item), nType, nVersion);
672 Unserialize(is, boost::get<3>(item), nType, nVersion);
680 template<
typename K,
typename T,
typename Pred,
typename A>
684 for (
typename std::map<K, T, Pred, A>::const_iterator mi = m.begin(); mi != m.end(); ++mi)
689 template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
690 void Serialize(Stream& os,
const std::map<K, T, Pred, A>& m,
int nType,
int nVersion)
693 for (
typename std::map<K, T, Pred, A>::const_iterator mi = m.begin(); mi != m.end(); ++mi)
697 template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
698 void Unserialize(Stream& is, std::map<K, T, Pred, A>& m,
int nType,
int nVersion)
702 typename std::map<K, T, Pred, A>::iterator mi = m.begin();
703 for (
unsigned int i = 0; i < nSize; i++)
705 std::pair<K, T> item;
707 mi = m.insert(mi, item);
716 template<
typename K,
typename Pred,
typename A>
720 for (
typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
725 template<
typename Stream,
typename K,
typename Pred,
typename A>
726 void Serialize(Stream& os,
const std::set<K, Pred, A>& m,
int nType,
int nVersion)
729 for (
typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
733 template<
typename Stream,
typename K,
typename Pred,
typename A>
734 void Unserialize(Stream& is, std::set<K, Pred, A>& m,
int nType,
int nVersion)
738 typename std::set<K, Pred, A>::iterator it = m.begin();
739 for (
unsigned int i = 0; i < nSize; i++)
743 it = m.insert(it, key);
756 template<
typename Stream,
typename T>
762 template<
typename Stream,
typename T>
769 template<
typename Stream,
typename T>
823 Init(nTypeIn, nVersionIn);
826 CDataStream(const_iterator pbegin, const_iterator pend,
int nTypeIn,
int nVersionIn) : vch(pbegin, pend)
828 Init(nTypeIn, nVersionIn);
831 #if !defined(_MSC_VER) || _MSC_VER >= 1300
832 CDataStream(
const char* pbegin,
const char* pend,
int nTypeIn,
int nVersionIn) : vch(pbegin, pend)
834 Init(nTypeIn, nVersionIn);
840 Init(nTypeIn, nVersionIn);
843 CDataStream(
const std::vector<char>& vchIn,
int nTypeIn,
int nVersionIn) : vch(vchIn.
begin(), vchIn.
end())
845 Init(nTypeIn, nVersionIn);
848 CDataStream(
const std::vector<unsigned char>& vchIn,
int nTypeIn,
int nVersionIn) : vch((char*)&vchIn.
begin()[0], (char*)&vchIn.
end()[0])
850 Init(nTypeIn, nVersionIn);
853 void Init(
int nTypeIn,
int nVersionIn)
857 nVersion = nVersionIn;
859 exceptmask = std::ios::badbit | std::ios::failbit;
877 return (std::string(
begin(),
end()));
886 const_iterator
end()
const {
return vch.end(); }
887 iterator
end() {
return vch.end(); }
890 void resize(size_type n, value_type c=0) { vch.resize(n + nReadPos, c); }
891 void reserve(size_type n) { vch.reserve(n + nReadPos); }
894 void clear() { vch.clear(); nReadPos = 0; }
895 iterator
insert(iterator it,
const char& x=
char()) {
return vch.insert(it, x); }
896 void insert(iterator it, size_type n,
const char& x) { vch.insert(it, n, x); }
898 void insert(iterator it, std::vector<char>::const_iterator first, std::vector<char>::const_iterator last)
900 assert(last - first >= 0);
901 if (it == vch.begin() + nReadPos && (
unsigned int)(last - first) <=
nReadPos)
904 nReadPos -= (last - first);
905 memcpy(&vch[nReadPos], &first[0], last - first);
908 vch.insert(it, first, last);
911 #if !defined(_MSC_VER) || _MSC_VER >= 1300
912 void insert(iterator it,
const char* first,
const char* last)
914 assert(last - first >= 0);
915 if (it == vch.begin() + nReadPos && (
unsigned int)(last - first) <=
nReadPos)
918 nReadPos -= (last - first);
919 memcpy(&vch[nReadPos], &first[0], last - first);
922 vch.insert(it, first, last);
931 if (++nReadPos >= vch.size())
935 return vch.erase(vch.begin(), vch.end());
940 return vch.erase(it);
943 iterator
erase(iterator first, iterator last)
945 if (first == vch.begin() +
nReadPos)
948 if (last == vch.end())
951 return vch.erase(vch.begin(), vch.end());
955 nReadPos = (last - vch.begin());
960 return vch.erase(first, last);
965 vch.erase(vch.begin(), vch.begin() +
nReadPos);
985 if (state & exceptmask)
986 throw std::ios_base::failure(psz);
990 bool fail()
const {
return state & (std::ios::badbit | std::ios::failbit); }
991 bool good()
const {
return !
eof() && (state == 0); }
1009 unsigned int nReadPosNext = nReadPos + nSize;
1010 if (nReadPosNext >= vch.size())
1012 if (nReadPosNext > vch.size())
1014 setstate(std::ios::failbit,
"CDataStream::read() : end of data");
1015 memset(pch, 0, nSize);
1018 memcpy(pch, &vch[nReadPos], nSize);
1023 memcpy(pch, &vch[nReadPos], nSize);
1024 nReadPos = nReadPosNext;
1032 unsigned int nReadPosNext = nReadPos + nSize;
1033 if (nReadPosNext >= vch.size())
1035 if (nReadPosNext > vch.size())
1037 setstate(std::ios::failbit,
"CDataStream::ignore() : end of data");
1044 nReadPos = nReadPosNext;
1052 vch.insert(vch.end(), pch, pch + nSize);
1056 template<
typename Stream>
1061 s.write((
char*)&vch[0], vch.size() *
sizeof(vch[0]));
1064 template<
typename T>
1071 template<
typename T>
1079 template<
typename T>
1122 nVersion = nVersionIn;
1124 exceptmask = std::ios::badbit | std::ios::failbit;
1134 if (file != NULL && file != stdin && file != stdout && file != stderr)
1154 if (state & exceptmask)
1155 throw std::ios_base::failure(psz);
1158 bool fail()
const {
return state & (std::ios::badbit | std::ios::failbit); }
1159 bool good()
const {
return state == 0; }
1174 throw std::ios_base::failure(
"CAutoFile::read : file handle is NULL");
1175 if (fread(pch, 1, nSize, file) != nSize)
1176 setstate(std::ios::failbit, feof(file) ?
"CAutoFile::read : end of file" :
"CAutoFile::read : fread failed");
1183 throw std::ios_base::failure(
"CAutoFile::write : file handle is NULL");
1184 if (fwrite(pch, 1, nSize, file) != nSize)
1185 setstate(std::ios::failbit,
"CAutoFile::write : write failed");
1189 template<
typename T>
1196 template<
typename T>
1201 throw std::ios_base::failure(
"CAutoFile::operator<< : file handle is NULL");
1206 template<
typename T>
1211 throw std::ios_base::failure(
"CAutoFile::operator>> : file handle is NULL");
1236 if (state & exceptmask)
1237 throw std::ios_base::failure(psz);
1242 unsigned int pos = nSrcPos % vchBuf.size();
1243 unsigned int readNow = vchBuf.size() - pos;
1244 unsigned int nAvail = vchBuf.size() - (nSrcPos -
nReadPos) - nRewind;
1245 if (nAvail < readNow)
1249 size_t read = fread((
void*)&vchBuf[pos], 1, readNow, src);
1251 setstate(std::ios_base::failbit, feof(src) ?
"CBufferedFile::Fill : end of file" :
"CBufferedFile::Fill : fread failed");
1264 src(fileIn), nSrcPos(0), nReadPos(0), nReadLimit((
uint64)(-1)), nRewind(nRewindIn), vchBuf(nBufSize, 0),
1265 state(0), exceptmask(
std::ios_base::badbit |
std::ios_base::failbit), nType(nTypeIn), nVersion(nVersionIn) {
1275 return nReadPos == nSrcPos && feof(src);
1280 if (nSize + nReadPos > nReadLimit)
1281 throw std::ios_base::failure(
"Read attempted past buffer limit");
1282 if (nSize + nRewind > vchBuf.size())
1283 throw std::ios_base::failure(
"Read larger than buffer size");
1285 if (nReadPos == nSrcPos)
1287 unsigned int pos = nReadPos % vchBuf.size();
1288 size_t nNow = nSize;
1289 if (nNow + pos > vchBuf.size())
1290 nNow = vchBuf.size() - pos;
1291 if (nNow + nReadPos > nSrcPos)
1293 memcpy(pch, &vchBuf[pos], nNow);
1309 if (nReadPos + nRewind < nSrcPos) {
1312 }
else if (nReadPos > nSrcPos) {
1321 long nLongPos = nPos;
1322 if (nPos != (
uint64)nLongPos)
1324 if (fseek(src, nLongPos, SEEK_SET))
1326 nLongPos = ftell(src);
1328 nReadPos = nLongPos;
1336 if (nPos < nReadPos)
1342 template<
typename T>
1352 if (nReadPos == nSrcPos)
1354 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
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)
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)
CDataStream & read(char *pch, int nSize)
vector_type::reference reference
bool SetLimit(uint64 nPos=(uint64)(-1))
vector_type::value_type value_type
CBufferedFile & read(char *pch, size_t nSize)
short exceptions(short mask)
CBufferedFile(FILE *fileIn, uint64 nBufSize, uint64 nRewindIn, int nTypeIn, int nVersionIn)
Double ended buffer combining vector and stream-like interfaces.
unsigned long long uint64
unsigned int GetSerializeSize(const T &obj)
vector_type::reverse_iterator reverse_iterator
iterator erase(iterator it)
CAutoFile(FILE *filenew, int nTypeIn, int nVersionIn)
unsigned int GetSizeOfCompactSize(uint64 nSize)
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
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
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 Unserialize(Stream &s, int, int=0)
void Serialize(Stream &s, int, int) const
reference operator[](size_type pos)
unsigned int GetSizeOfVarInt(I n)
unsigned int GetSerializeSize(int, int=0) const
void WriteCompactSize(Stream &os, uint64 nSize)
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)
CDataStream & operator<<(const T &obj)
void reserve(size_type n)
Serialized script, used inside transaction inputs and outputs.
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)
uint64 ReadCompactSize(Stream &is)
std::vector< char > vchBuf
iterator erase(iterator first, iterator last)
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.
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