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)); }
267template <
typename Stream, BasicByte B, std::
size_t N>
void Serialize(Stream&
s, std::span<B, N> span) {
s.write(std::as_bytes(span)); }
270template <
typename Stream, CharNotInt8 V>
void Unserialize(Stream&, V) =
delete;
282template <
typename Stream, BasicByte B, std::
size_t N>
void Unserialize(Stream&
s, std::span<B, N> span) {
s.read(std::as_writable_bytes(span)); }
299 if (
nSize < 253)
return sizeof(
unsigned char);
300 else if (
nSize <= std::numeric_limits<uint16_t>::max())
return sizeof(
unsigned char) +
sizeof(uint16_t);
301 else if (
nSize <= std::numeric_limits<unsigned int>::max())
return sizeof(
unsigned char) +
sizeof(
unsigned int);
302 else return sizeof(
unsigned char) +
sizeof(uint64_t);
307template<
typename Stream>
314 else if (
nSize <= std::numeric_limits<uint16_t>::max())
319 else if (
nSize <= std::numeric_limits<unsigned int>::max())
338template<
typename Stream>
342 uint64_t nSizeRet = 0;
347 else if (chSize == 253)
351 throw std::ios_base::failure(
"non-canonical ReadCompactSize()");
353 else if (chSize == 254)
356 if (nSizeRet < 0x10000u)
357 throw std::ios_base::failure(
"non-canonical ReadCompactSize()");
362 if (nSizeRet < 0x100000000ULL)
363 throw std::ios_base::failure(
"non-canonical ReadCompactSize()");
365 if (range_check && nSizeRet >
MAX_SIZE) {
366 throw std::ios_base::failure(
"ReadCompactSize(): size too large");
407template <VarIntMode Mode,
typename I>
411 static_assert(Mode !=
VarIntMode::DEFAULT || std::is_unsigned<I>::value,
"Unsigned type required with mode DEFAULT.");
416template<VarIntMode Mode,
typename I>
433template<
typename Stream, VarIntMode Mode,
typename I>
437 unsigned char tmp[(
sizeof(n)*8+6)/7];
440 tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
451template<
typename Stream, VarIntMode Mode,
typename I>
458 if (n > (std::numeric_limits<I>::max() >> 7)) {
459 throw std::ios_base::failure(
"ReadVarInt(): size too large");
461 n = (n << 7) | (chData & 0x7F);
463 if (n == std::numeric_limits<I>::max()) {
464 throw std::ios_base::failure(
"ReadVarInt(): size too large");
474template<
typename Formatter,
typename T>
477 static_assert(std::is_lvalue_reference<T>::value,
"Wrapper needs an lvalue reference type T");
496template<
typename Formatter,
typename T>
499#define VARINT_MODE(obj, mode) Using<VarIntFormatter<mode>>(obj)
500#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
501#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
502#define LIMITED_STRING(obj,n) Using<LimitedStringFormatter<n>>(obj)
505template<VarIntMode Mode>
508 template<
typename Stream,
typename I>
void Ser(Stream &
s, I v)
510 WriteVarInt<Stream,Mode,typename std::remove_cv<I>::type>(
s, v);
513 template<
typename Stream,
typename I>
void Unser(Stream&
s, I& v)
515 v = ReadVarInt<Stream,Mode,typename std::remove_cv<I>::type>(
s);
528template<
int Bytes,
bool BigEndian = false>
531 static_assert(Bytes > 0 && Bytes <= 8,
"CustomUintFormatter Bytes out of range");
532 static constexpr uint64_t
MAX = 0xffffffffffffffff >> (8 * (8 - Bytes));
534 template <
typename Stream,
typename I>
void Ser(Stream&
s, I v)
536 if (v < 0 || v >
MAX)
throw std::ios_base::failure(
"CustomUintFormatter value out of range");
546 template <
typename Stream,
typename I>
void Unser(Stream&
s, I& v)
548 using U =
typename std::conditional<std::is_enum<I>::value, std::underlying_type<I>, std::common_type<I>>::type::type;
549 static_assert(std::numeric_limits<U>::max() >=
MAX && std::numeric_limits<U>::min() <= 0,
"Assigned type too small");
564template<
bool RangeCheck>
567 template<
typename Stream,
typename I>
570 uint64_t n = ReadCompactSize<Stream>(
s, RangeCheck);
571 if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
572 throw std::ios_base::failure(
"CompactSize exceeds limit of type");
577 template<
typename Stream,
typename I>
580 static_assert(std::is_unsigned<I>::value,
"CompactSize only supported for unsigned integers");
581 static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(),
"CompactSize only supports 64-bit integers and below");
583 WriteCompactSize<Stream>(
s, v);
587template <
typename U,
bool LOSSY = false>
589 template <
typename Stream,
typename Tp>
595 tp = Tp{
typename Tp::duration{
typename Tp::duration::rep{u}}};
597 template <
typename Stream,
typename Tp>
600 if constexpr (LOSSY) {
601 s << U(tp.time_since_epoch().count());
603 s << U{tp.time_since_epoch().count()};
617 template<
typename Stream>
619 WriteCompactSize<Stream>(
s,
n);
623template<
size_t Limit>
626 template<
typename Stream>
631 throw std::ios_base::failure(
"String length limit exceeded");
637 template<
typename Stream>
638 void Ser(Stream&
s,
const std::string& v)
657template<
class Formatter>
660 template<
typename Stream,
typename V>
661 void Ser(Stream&
s,
const V& v)
665 for (
const typename V::value_type& elem : v) {
666 formatter.Ser(
s, elem);
670 template<
typename Stream,
typename V>
676 size_t allocated = 0;
677 while (allocated < size) {
681 static_assert(
sizeof(
typename V::value_type) <=
MAX_VECTOR_ALLOCATE,
"Vector element size too large");
682 allocated = std::min(size, allocated +
MAX_VECTOR_ALLOCATE /
sizeof(
typename V::value_type));
683 v.reserve(allocated);
684 while (v.size() < allocated) {
686 formatter.Unser(
s, v.back());
699template<
typename Stream,
typename C>
void Serialize(Stream& os,
const std::basic_string<C>& str);
700template<
typename Stream,
typename C>
void Unserialize(Stream& is, std::basic_string<C>& str);
711template<
typename Stream,
typename T,
typename A>
inline void Serialize(Stream& os,
const std::vector<T, A>& v);
712template<
typename Stream,
typename T,
typename A>
inline void Unserialize(Stream& is, std::vector<T, A>& v);
717template<
typename Stream,
typename K,
typename T>
void Serialize(Stream& os,
const std::pair<K, T>& item);
718template<
typename Stream,
typename K,
typename T>
void Unserialize(Stream& is, std::pair<K, T>& item);
723template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
void Serialize(Stream& os,
const std::map<K, T, Pred, A>& m);
724template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
void Unserialize(Stream& is, std::map<K, T, Pred, A>& m);
729template<
typename Stream,
typename K,
typename Pred,
typename A>
void Serialize(Stream& os,
const std::set<K, Pred, A>& m);
730template<
typename Stream,
typename K,
typename Pred,
typename A>
void Unserialize(Stream& is, std::set<K, Pred, A>& m);
735template<
typename Stream,
typename T>
void Serialize(Stream& os,
const std::shared_ptr<const T>& p);
736template<
typename Stream,
typename T>
void Unserialize(Stream& os, std::shared_ptr<const T>& p);
741template<
typename Stream,
typename T>
void Serialize(Stream& os,
const std::unique_ptr<const T>& p);
742template<
typename Stream,
typename T>
void Unserialize(Stream& os, std::unique_ptr<const T>& p);
748template <
class T,
class Stream>
750template <
typename Stream,
typename T>
757template <
class T,
class Stream>
759template <
typename Stream,
typename T>
773 template<
typename Stream,
typename T>
776 template<
typename Stream,
typename T>
787template<
typename Stream,
typename C>
788void Serialize(Stream& os,
const std::basic_string<C>& str)
795template<
typename Stream,
typename C>
809template <
typename Stream,
unsigned int N,
typename T>
821template <
typename Stream,
unsigned int N,
typename T>
830 unsigned int blk = std::min(nSize - i, (
unsigned int)(1 + 4999999 /
sizeof(
T)));
844template <
typename Stream,
typename T,
typename A>
850 }
else if constexpr (std::is_same_v<T, bool>) {
855 for (
bool elem : v) {
864template <
typename Stream,
typename T,
typename A>
873 unsigned int blk = std::min(nSize - i, (
unsigned int)(1 + 4999999 /
sizeof(
T)));
887template<
typename Stream,
typename K,
typename T>
894template<
typename Stream,
typename K,
typename T>
906template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
907void Serialize(Stream& os,
const std::map<K, T, Pred, A>& m)
910 for (
const auto& entry :
m)
914template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
919 typename std::map<K, T, Pred, A>::iterator mi =
m.begin();
920 for (
unsigned int i = 0; i < nSize; i++)
922 std::pair<K, T> item;
924 mi =
m.insert(mi, item);
933template<
typename Stream,
typename K,
typename Pred,
typename A>
934void Serialize(Stream& os,
const std::set<K, Pred, A>& m)
937 for (
typename std::set<K, Pred, A>::const_iterator it =
m.begin(); it !=
m.end(); ++it)
941template<
typename Stream,
typename K,
typename Pred,
typename A>
946 typename std::set<K, Pred, A>::iterator it =
m.begin();
947 for (
unsigned int i = 0; i < nSize; i++)
951 it =
m.insert(it, key);
960template<
typename Stream,
typename T>
void
966template<
typename Stream,
typename T>
977template<
typename Stream,
typename T>
void
983template<
typename Stream,
typename T>
993template <
typename Stream,
typename... Args>
999template <
typename Stream,
typename... Args>
1011 template<
typename Stream,
typename... Args>
1017 template<
typename Stream,
typename Type,
typename Fn>
1022 template<
typename Stream,
typename Type,
typename Fn>
1025 fn(
s, std::forward<Type>(obj));
1031 template<
typename Stream,
typename... Args>
1037 template<
typename Stream,
typename Type,
typename Fn>
1040 fn(
s, std::forward<Type>(obj));
1043 template<
typename Stream,
typename Type,
typename Fn>
1076 this->
nSize += _nSize;
1079 template<
typename T>
1094 s.seek(GetSizeOfVarInt<I>(n));
1102template <
typename T>
1113template <
typename SubStream,
typename Params>
1129 template <
typename NestedSubstream,
typename Params1,
typename Params2,
typename... NestedParams>
1142 template <
typename P>
1145 if constexpr (std::is_convertible_v<Params, P>) {
1176template <
typename Substream,
typename Params>
1183template <
typename Substream,
typename Params1,
typename Params2,
typename...
Params>
1188template <
typename Params,
typename T>
1197 template <
typename Stream>
1203 template <
typename Stream>
1220#define SER_PARAMS_OPFUNC \
1226 template <typename T> \
1227 auto operator()(T&& t) const \
1229 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.