6#ifndef BITCOIN_SERIALIZE_H
7#define BITCOIN_SERIALIZE_H
32static constexpr uint64_t
MAX_SIZE = 0x02000000;
143template <
class Out,
class In>
146 static_assert(std::is_base_of_v<Out, In>);
149template <
class Out,
class In>
152 static_assert(std::is_base_of_v<Out, In>);
156#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
157#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, typename std::remove_const<Type>::type& obj) { code; })
158#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
176#define FORMATTER_METHODS(cls, obj) \
177 template<typename Stream> \
178 static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
179 template<typename Stream> \
180 static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
181 template<typename Stream, typename Type, typename Operation> \
182 static void SerializationOps(Type& obj, Stream& s, Operation ser_action)
217#define SER_PARAMS(type) (s.template GetParams<type>())
219#define BASE_SERIALIZE_METHODS(cls) \
220 template <typename Stream> \
221 void Serialize(Stream& s) const \
223 static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
226 template <typename Stream> \
227 void Unserialize(Stream& s) \
229 static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch"); \
240#define SERIALIZE_METHODS(cls, obj) \
241 BASE_SERIALIZE_METHODS(cls) \
242 FORMATTER_METHODS(cls, obj)
253concept CharNotInt8 = std::same_as<T, char> && !std::same_as<T, int8_t>;
255template <
typename Stream, CharNotInt8 V>
void Serialize(Stream&, V) =
delete;
266template <
typename Stream, BasicByte B, std::
size_t N>
void Serialize(Stream&
s,
const std::array<B, N>& a) {
s.write(
MakeByteSpan(a)); }
269template <
typename Stream, CharNotInt8 V>
void Unserialize(Stream&, V) =
delete;
297 if (
nSize < 253)
return sizeof(
unsigned char);
298 else if (
nSize <= std::numeric_limits<uint16_t>::max())
return sizeof(
unsigned char) +
sizeof(uint16_t);
299 else if (
nSize <= std::numeric_limits<unsigned int>::max())
return sizeof(
unsigned char) +
sizeof(
unsigned int);
300 else return sizeof(
unsigned char) +
sizeof(uint64_t);
305template<
typename Stream>
312 else if (
nSize <= std::numeric_limits<uint16_t>::max())
317 else if (
nSize <= std::numeric_limits<unsigned int>::max())
336template<
typename Stream>
340 uint64_t nSizeRet = 0;
345 else if (chSize == 253)
349 throw std::ios_base::failure(
"non-canonical ReadCompactSize()");
351 else if (chSize == 254)
354 if (nSizeRet < 0x10000u)
355 throw std::ios_base::failure(
"non-canonical ReadCompactSize()");
360 if (nSizeRet < 0x100000000ULL)
361 throw std::ios_base::failure(
"non-canonical ReadCompactSize()");
363 if (range_check && nSizeRet >
MAX_SIZE) {
364 throw std::ios_base::failure(
"ReadCompactSize(): size too large");
405template <VarIntMode Mode,
typename I>
409 static_assert(Mode !=
VarIntMode::DEFAULT || std::is_unsigned<I>::value,
"Unsigned type required with mode DEFAULT.");
414template<VarIntMode Mode,
typename I>
431template<
typename Stream, VarIntMode Mode,
typename I>
435 unsigned char tmp[(
sizeof(n)*8+6)/7];
438 tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
449template<
typename Stream, VarIntMode Mode,
typename I>
456 if (n > (std::numeric_limits<I>::max() >> 7)) {
457 throw std::ios_base::failure(
"ReadVarInt(): size too large");
459 n = (n << 7) | (chData & 0x7F);
461 if (n == std::numeric_limits<I>::max()) {
462 throw std::ios_base::failure(
"ReadVarInt(): size too large");
472template<
typename Formatter,
typename T>
475 static_assert(std::is_lvalue_reference<T>::value,
"Wrapper needs an lvalue reference type T");
494template<
typename Formatter,
typename T>
497#define VARINT_MODE(obj, mode) Using<VarIntFormatter<mode>>(obj)
498#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
499#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
500#define LIMITED_STRING(obj,n) Using<LimitedStringFormatter<n>>(obj)
503template<VarIntMode Mode>
506 template<
typename Stream,
typename I>
void Ser(Stream &
s, I v)
508 WriteVarInt<Stream,Mode,typename std::remove_cv<I>::type>(
s, v);
511 template<
typename Stream,
typename I>
void Unser(Stream&
s, I& v)
513 v = ReadVarInt<Stream,Mode,typename std::remove_cv<I>::type>(
s);
526template<
int Bytes,
bool BigEndian = false>
529 static_assert(Bytes > 0 && Bytes <= 8,
"CustomUintFormatter Bytes out of range");
530 static constexpr uint64_t
MAX = 0xffffffffffffffff >> (8 * (8 - Bytes));
532 template <
typename Stream,
typename I>
void Ser(Stream&
s, I v)
534 if (v < 0 || v >
MAX)
throw std::ios_base::failure(
"CustomUintFormatter value out of range");
544 template <
typename Stream,
typename I>
void Unser(Stream&
s, I& v)
546 using U =
typename std::conditional<std::is_enum<I>::value, std::underlying_type<I>, std::common_type<I>>::type::type;
547 static_assert(std::numeric_limits<U>::max() >=
MAX && std::numeric_limits<U>::min() <= 0,
"Assigned type too small");
562template<
bool RangeCheck>
565 template<
typename Stream,
typename I>
568 uint64_t n = ReadCompactSize<Stream>(
s, RangeCheck);
569 if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
570 throw std::ios_base::failure(
"CompactSize exceeds limit of type");
575 template<
typename Stream,
typename I>
578 static_assert(std::is_unsigned<I>::value,
"CompactSize only supported for unsigned integers");
579 static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(),
"CompactSize only supports 64-bit integers and below");
581 WriteCompactSize<Stream>(
s, v);
585template <
typename U,
bool LOSSY = false>
587 template <
typename Stream,
typename Tp>
593 tp = Tp{
typename Tp::duration{
typename Tp::duration::rep{u}}};
595 template <
typename Stream,
typename Tp>
598 if constexpr (LOSSY) {
599 s << U(tp.time_since_epoch().count());
601 s << U{tp.time_since_epoch().count()};
615 template<
typename Stream>
617 WriteCompactSize<Stream>(
s,
n);
621template<
size_t Limit>
624 template<
typename Stream>
629 throw std::ios_base::failure(
"String length limit exceeded");
635 template<
typename Stream>
636 void Ser(Stream&
s,
const std::string& v)
655template<
class Formatter>
658 template<
typename Stream,
typename V>
659 void Ser(Stream&
s,
const V& v)
663 for (
const typename V::value_type& elem : v) {
664 formatter.Ser(
s, elem);
668 template<
typename Stream,
typename V>
674 size_t allocated = 0;
675 while (allocated < size) {
679 static_assert(
sizeof(
typename V::value_type) <=
MAX_VECTOR_ALLOCATE,
"Vector element size too large");
680 allocated = std::min(size, allocated +
MAX_VECTOR_ALLOCATE /
sizeof(
typename V::value_type));
681 v.reserve(allocated);
682 while (v.size() < allocated) {
684 formatter.Unser(
s, v.back());
697template<
typename Stream,
typename C>
void Serialize(Stream& os,
const std::basic_string<C>& str);
698template<
typename Stream,
typename C>
void Unserialize(Stream& is, std::basic_string<C>& str);
709template<
typename Stream,
typename T,
typename A>
inline void Serialize(Stream& os,
const std::vector<T, A>& v);
710template<
typename Stream,
typename T,
typename A>
inline void Unserialize(Stream& is, std::vector<T, A>& v);
715template<
typename Stream,
typename K,
typename T>
void Serialize(Stream& os,
const std::pair<K, T>& item);
716template<
typename Stream,
typename K,
typename T>
void Unserialize(Stream& is, std::pair<K, T>& item);
721template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
void Serialize(Stream& os,
const std::map<K, T, Pred, A>& m);
722template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
void Unserialize(Stream& is, std::map<K, T, Pred, A>& m);
727template<
typename Stream,
typename K,
typename Pred,
typename A>
void Serialize(Stream& os,
const std::set<K, Pred, A>& m);
728template<
typename Stream,
typename K,
typename Pred,
typename A>
void Unserialize(Stream& is, std::set<K, Pred, A>& m);
733template<
typename Stream,
typename T>
void Serialize(Stream& os,
const std::shared_ptr<const T>& p);
734template<
typename Stream,
typename T>
void Unserialize(Stream& os, std::shared_ptr<const T>& p);
739template<
typename Stream,
typename T>
void Serialize(Stream& os,
const std::unique_ptr<const T>& p);
740template<
typename Stream,
typename T>
void Unserialize(Stream& os, std::unique_ptr<const T>& p);
746template <
class T,
class Stream>
748template <
typename Stream,
typename T>
755template <
class T,
class Stream>
757template <
typename Stream,
typename T>
771 template<
typename Stream,
typename T>
774 template<
typename Stream,
typename T>
785template<
typename Stream,
typename C>
786void Serialize(Stream& os,
const std::basic_string<C>& str)
793template<
typename Stream,
typename C>
807template <
typename Stream,
unsigned int N,
typename T>
819template <
typename Stream,
unsigned int N,
typename T>
828 unsigned int blk = std::min(nSize - i, (
unsigned int)(1 + 4999999 /
sizeof(
T)));
842template <
typename Stream,
typename T,
typename A>
848 }
else if constexpr (std::is_same_v<T, bool>) {
853 for (
bool elem : v) {
862template <
typename Stream,
typename T,
typename A>
871 unsigned int blk = std::min(nSize - i, (
unsigned int)(1 + 4999999 /
sizeof(
T)));
885template<
typename Stream,
typename K,
typename T>
892template<
typename Stream,
typename K,
typename T>
904template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
905void Serialize(Stream& os,
const std::map<K, T, Pred, A>& m)
908 for (
const auto& entry :
m)
912template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
917 typename std::map<K, T, Pred, A>::iterator mi =
m.begin();
918 for (
unsigned int i = 0; i < nSize; i++)
920 std::pair<K, T> item;
922 mi =
m.insert(mi, item);
931template<
typename Stream,
typename K,
typename Pred,
typename A>
932void Serialize(Stream& os,
const std::set<K, Pred, A>& m)
935 for (
typename std::set<K, Pred, A>::const_iterator it =
m.begin(); it !=
m.end(); ++it)
939template<
typename Stream,
typename K,
typename Pred,
typename A>
944 typename std::set<K, Pred, A>::iterator it =
m.begin();
945 for (
unsigned int i = 0; i < nSize; i++)
949 it =
m.insert(it, key);
958template<
typename Stream,
typename T>
void
964template<
typename Stream,
typename T>
975template<
typename Stream,
typename T>
void
981template<
typename Stream,
typename T>
991template <
typename Stream,
typename... Args>
997template <
typename Stream,
typename... Args>
1009 template<
typename Stream,
typename... Args>
1015 template<
typename Stream,
typename Type,
typename Fn>
1020 template<
typename Stream,
typename Type,
typename Fn>
1023 fn(
s, std::forward<Type>(obj));
1029 template<
typename Stream,
typename... Args>
1035 template<
typename Stream,
typename Type,
typename Fn>
1038 fn(
s, std::forward<Type>(obj));
1041 template<
typename Stream,
typename Type,
typename Fn>
1074 this->
nSize += _nSize;
1077 template<
typename T>
1092 s.seek(GetSizeOfVarInt<I>(n));
1100template <
typename T>
1111template <
typename SubStream,
typename Params>
1127 template <
typename NestedSubstream,
typename Params1,
typename Params2,
typename... NestedParams>
1140 template <
typename P>
1143 if constexpr (std::is_convertible_v<Params, P>) {
1174template <
typename Substream,
typename Params>
1181template <
typename Substream,
typename Params1,
typename Params2,
typename...
Params>
1186template <
typename Params,
typename T>
1195 template <
typename Stream>
1201 template <
typename Stream>
1218#define SER_PARAMS_OPFUNC \
1224 template <typename T> \
1225 auto operator()(T&& t) const \
1227 return ParamsWrapper{*this, t}; \
const CChainParams & Params()
Return the currently selected parameters.
void Serialize(Stream &s) const
CompactSizeWriter(uint64_t n_in)
Wrapper that overrides the GetParams() function of a stream.
ParamsStream & operator<<(const U &obj)
ParamsStream & operator>>(U &&obj)
ParamsStream(NestedSubstream &&s, const Params1 ¶ms1 LIFETIMEBOUND, const Params2 ¶ms2 LIFETIMEBOUND, const NestedParams &... params LIFETIMEBOUND)
auto & GetStream()
Get reference to underlying stream.
void read(Span< std::byte > dst)
void write(Span< const std::byte > src)
const auto & GetParams() const
Get reference to stream parameters.
const auto & GetStream() const
ParamsStream(SubStream &&substream, const Params ¶ms LIFETIMEBOUND)
Wrapper that serializes objects with the specified parameters.
void Unserialize(Stream &s)
void Serialize(Stream &s) const
ParamsWrapper(const Params ¶ms, T &obj)
void write(Span< const std::byte > src)
void seek(size_t _nSize)
Pretend _nSize bytes are written, without specifying them.
SizeComputer & operator<<(const T &obj)
A Span is an object that can refer to a contiguous sequence of objects.
constexpr std::size_t size() const noexcept
Simple wrapper class to serialize objects using a formatter; used by Using().
void Serialize(Stream &s) const
void Unserialize(Stream &s)
Implements a drop-in replacement for std::vector<T> which stores up to N elements directly (without h...
void resize_uninitialized(size_type new_size)
Check if type contains a stream by seeing if has a GetStream() method.
If none of the specialized versions above matched, default to calling member function.
BSWAP_CONSTEXPR uint32_t be32toh_internal(uint32_t big_endian_32bits)
BSWAP_CONSTEXPR uint16_t be16toh_internal(uint16_t big_endian_16bits)
BSWAP_CONSTEXPR uint64_t htobe64_internal(uint64_t host_64bits)
BSWAP_CONSTEXPR uint16_t htobe16_internal(uint16_t host_16bits)
BSWAP_CONSTEXPR uint32_t htole32_internal(uint32_t host_32bits)
BSWAP_CONSTEXPR uint16_t htole16_internal(uint16_t host_16bits)
BSWAP_CONSTEXPR uint64_t be64toh_internal(uint64_t big_endian_64bits)
BSWAP_CONSTEXPR uint16_t le16toh_internal(uint16_t little_endian_16bits)
BSWAP_CONSTEXPR uint64_t htole64_internal(uint64_t host_64bits)
BSWAP_CONSTEXPR uint64_t le64toh_internal(uint64_t little_endian_64bits)
BSWAP_CONSTEXPR uint32_t le32toh_internal(uint32_t little_endian_32bits)
BSWAP_CONSTEXPR uint32_t htobe32_internal(uint32_t host_32bits)
#define T(expected, seed, data)
size_t GetSerializeSize(const T &t)
void Serialize(Stream &, V)=delete
constexpr unsigned int GetSizeOfCompactSize(uint64_t nSize)
Compact Size size < 253 – 1 byte size <= USHRT_MAX – 3 bytes (253 + 2 bytes) size <= UINT_MAX – 5 byt...
void SerializeMany(Stream &s, const Args &... args)
Support for (un)serializing many things at once.
static const unsigned int MAX_VECTOR_ALLOCATE
Maximum amount of memory (in bytes) to allocate at once when deserializing vectors.
uint8_t ser_readdata8(Stream &s)
void ser_writedata32be(Stream &s, uint32_t obj)
VarIntMode
Variable-length integers: bytes are a MSB base-128 encoding of the number.
void ser_writedata32(Stream &s, uint32_t obj)
static constexpr uint64_t MAX_SIZE
The maximum size of a serialized object in bytes or number of elements (for eg vectors) when the size...
constexpr deserialize_type deserialize
void ser_writedata16(Stream &s, uint16_t obj)
void Unserialize(Stream &, V)=delete
void UnserializeMany(Stream &s, Args &&... args)
Out & AsBase(In &x)
Convert any argument to a reference to X, maintaining constness.
void WriteVarInt(SizeComputer &os, I n)
void WriteCompactSize(SizeComputer &os, uint64_t nSize)
void ser_writedata16be(Stream &s, uint16_t obj)
uint16_t ser_readdata16(Stream &s)
uint64_t ser_readdata64(Stream &s)
void ser_writedata8(Stream &s, uint8_t obj)
uint64_t ReadCompactSize(Stream &is, bool range_check=true)
Decode a CompactSize-encoded variable-length integer.
ParamsStream(Substream &&, const Params &) -> ParamsStream< Substream, Params >
Explicit template deduction guide is required for single-parameter constructor so Substream&& is trea...
static Wrapper< Formatter, T & > Using(T &&t)
Cause serialization/deserialization of an object to be done using a specified formatter class.
unsigned int GetSizeOfVarInt(I n)
uint32_t ser_readdata32(Stream &s)
uint16_t ser_readdata16be(Stream &s)
void ser_writedata64(Stream &s, uint64_t obj)
uint32_t ser_readdata32be(Stream &s)
Span< std::byte > AsWritableBytes(Span< T > s) noexcept
Span< const std::byte > MakeByteSpan(V &&v) noexcept
Span< const std::byte > AsBytes(Span< T > s) noexcept
Span< std::byte > MakeWritableByteSpan(V &&v) noexcept
Support for all macros providing or using the ser_action parameter of the SerializationOps method.
static void SerReadWriteMany(Stream &s, const Args &... args)
static constexpr bool ForRead()
static void SerWrite(Stream &s, Type &&obj, Fn &&fn)
static void SerRead(Stream &s, Type &&, Fn &&)
static constexpr bool ForRead()
static void SerReadWriteMany(Stream &s, Args &&... args)
static void SerRead(Stream &s, Type &&obj, Fn &&fn)
static void SerWrite(Stream &s, Type &&, Fn &&)
constexpr CheckVarIntMode()
Dummy data type to identify deserializing constructors.