6 #ifndef BITCOIN_SERIALIZE_H
7 #define BITCOIN_SERIALIZE_H
32 static constexpr uint64_t
MAX_SIZE = 0x02000000;
143 template <
class Out,
class In>
146 static_assert(std::is_base_of_v<Out, In>);
149 template <
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)
253 concept
CharNotInt8 = std::same_as<T, char> && !std::same_as<T, int8_t>;
255 template <
typename Stream, CharNotInt8 V>
void Serialize(Stream&, V) =
delete;
266 template <
typename Stream, BasicByte B, std::
size_t N>
void Serialize(Stream& s,
const std::array<B, N>& a) { s.write(
MakeByteSpan(a)); }
269 template <
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);
305 template<
typename Stream>
312 else if (
nSize <= std::numeric_limits<uint16_t>::max())
317 else if (
nSize <= std::numeric_limits<unsigned int>::max())
336 template<
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");
405 template <VarIntMode Mode,
typename I>
409 static_assert(Mode !=
VarIntMode::DEFAULT || std::is_unsigned<I>::value,
"Unsigned type required with mode DEFAULT.");
414 template<VarIntMode Mode,
typename I>
431 template<
typename Stream, VarIntMode Mode,
typename I>
435 unsigned char tmp[(
sizeof(n)*8+6)/7];
438 tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
449 template<
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");
472 template<
typename Formatter,
typename T>
475 static_assert(std::is_lvalue_reference<T>::value,
"Wrapper needs an lvalue reference type T");
494 template<
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)
503 template<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);
526 template<
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");
562 template<
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);
585 template <
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>
596 void Ser(Stream& s, Tp tp)
598 if constexpr (LOSSY) {
599 s << U(tp.time_since_epoch().count());
601 s << U{tp.time_since_epoch().count()};
605 template <
typename U>
615 template<
typename Stream>
617 WriteCompactSize<Stream>(s,
n);
621 template<
size_t Limit>
624 template<
typename Stream>
625 void Unser(Stream& s, std::string& v)
629 throw std::ios_base::failure(
"String length limit exceeded");
635 template<
typename Stream>
636 void Ser(Stream& s,
const std::string& v)
655 template<
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());
697 template<
typename Stream,
typename C>
void Serialize(Stream& os,
const std::basic_string<C>& str);
698 template<
typename Stream,
typename C>
void Unserialize(Stream& is, std::basic_string<C>& str);
709 template<
typename Stream,
typename T,
typename A>
inline void Serialize(Stream& os,
const std::vector<T, A>& v);
710 template<
typename Stream,
typename T,
typename A>
inline void Unserialize(Stream& is, std::vector<T, A>& v);
715 template<
typename Stream,
typename K,
typename T>
void Serialize(Stream& os,
const std::pair<K, T>& item);
716 template<
typename Stream,
typename K,
typename T>
void Unserialize(Stream& is, std::pair<K, T>& item);
721 template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
void Serialize(Stream& os,
const std::map<K, T, Pred, A>& m);
722 template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
void Unserialize(Stream& is, std::map<K, T, Pred, A>& m);
727 template<
typename Stream,
typename K,
typename Pred,
typename A>
void Serialize(Stream& os,
const std::set<K, Pred, A>& m);
728 template<
typename Stream,
typename K,
typename Pred,
typename A>
void Unserialize(Stream& is, std::set<K, Pred, A>& m);
733 template<
typename Stream,
typename T>
void Serialize(Stream& os,
const std::shared_ptr<const T>& p);
734 template<
typename Stream,
typename T>
void Unserialize(Stream& os, std::shared_ptr<const T>& p);
739 template<
typename Stream,
typename T>
void Serialize(Stream& os,
const std::unique_ptr<const T>& p);
740 template<
typename Stream,
typename T>
void Unserialize(Stream& os, std::unique_ptr<const T>& p);
746 template <
class T,
class Stream>
748 template <
typename Stream,
typename T>
749 requires Serializable<T, Stream>
755 template <
class T,
class Stream>
757 template <
typename Stream,
typename T>
758 requires Unserializable<T, Stream>
771 template<
typename Stream,
typename T>
774 template<
typename Stream,
typename T>
785 template<
typename Stream,
typename C>
786 void Serialize(Stream& os,
const std::basic_string<C>& str)
793 template<
typename Stream,
typename C>
807 template <
typename Stream,
unsigned int N,
typename T>
810 if constexpr (BasicByte<T>) {
819 template <
typename Stream,
unsigned int N,
typename T>
822 if constexpr (BasicByte<T>) {
828 unsigned int blk = std::min(nSize - i, (
unsigned int)(1 + 4999999 /
sizeof(
T)));
842 template <
typename Stream,
typename T,
typename A>
845 if constexpr (BasicByte<T>) {
848 }
else if constexpr (std::is_same_v<T, bool>) {
853 for (
bool elem : v) {
862 template <
typename Stream,
typename T,
typename A>
865 if constexpr (BasicByte<T>) {
871 unsigned int blk = std::min(nSize - i, (
unsigned int)(1 + 4999999 /
sizeof(
T)));
885 template<
typename Stream,
typename K,
typename T>
892 template<
typename Stream,
typename K,
typename T>
904 template<
typename Stream,
typename K,
typename T,
typename Pred,
typename A>
905 void Serialize(Stream& os,
const std::map<K, T, Pred, A>& m)
908 for (
const auto& entry :
m)
912 template<
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);
931 template<
typename Stream,
typename K,
typename Pred,
typename A>
932 void 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)
939 template<
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);
958 template<
typename Stream,
typename T>
void
959 Serialize(Stream& os,
const std::unique_ptr<const T>& p)
964 template<
typename Stream,
typename T>
975 template<
typename Stream,
typename T>
void
976 Serialize(Stream& os,
const std::shared_ptr<const T>& p)
981 template<
typename Stream,
typename T>
991 template <
typename Stream,
typename... Args>
997 template <
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>
1036 static void SerRead(Stream& s, Type&& obj, Fn&& fn)
1038 fn(s, std::forward<Type>(obj));
1041 template<
typename Stream,
typename Type,
typename Fn>
1074 this->
nSize += _nSize;
1077 template<
typename T>
1089 template<
typename I>
1092 s.
seek(GetSizeOfVarInt<I>(n));
1100 template <
typename T>
1107 template<
typename T>
1111 template <
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>) {
1153 if constexpr (ContainsStream<SubStream>) {
1161 if constexpr (ContainsStream<SubStream>) {
1174 template <
typename Substream,
typename Params>
1181 template <
typename Substream,
typename Params1,
typename Params2,
typename...
Params>
1186 template <
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>>(U &&obj)
ParamsStream(NestedSubstream &&s, const Params1 ¶ms1 LIFETIMEBOUND, const Params2 ¶ms2 LIFETIMEBOUND, const NestedParams &... params LIFETIMEBOUND)
const auto & GetStream() const
void read(Span< std::byte > dst)
ParamsStream & operator<<(const U &obj)
void write(Span< const std::byte > src)
const auto & GetParams() const
Get reference to stream parameters.
auto & GetStream()
Get reference to underlying stream.
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)
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)
Out & AsBase(In &x)
Convert any argument to a reference to X, maintaining constness.
concept ContainsStream
Check if type contains a stream by seeing if has a GetStream() method.
void Unserialize(Stream &, V)=delete
void UnserializeMany(Stream &s, Args &&... args)
static Wrapper< Formatter, T & > Using(T &&t)
Cause serialization/deserialization of an object to be done using a specified formatter class.
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...
unsigned int GetSizeOfVarInt(I n)
concept Serializable
If none of the specialized versions above matched, default to calling member function.
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.