How objects become bytes

1001    {
1002        K key;
1003        Unserialize(is, key);
1004        it = m.insert(it, key);
1005    }
1006}
1007
1008
1009
1010/**
1011 * unique_ptr
1012 */
1013template<typename Stream, typename T> void
1014Serialize(Stream& os, const std::unique_ptr<const T>& p)
1015{
1016    Serialize(os, *p);
1017}
1018
1019template<typename Stream, typename T>
1020void Unserialize(Stream& is, std::unique_ptr<const T>& p)
1021{
1022    p.reset(new T(deserialize, is));
1023}
1024
1025
1026
1027/**
1028 * shared_ptr
1029 */
1030template<typename Stream, typename T> void
1031Serialize(Stream& os, const std::shared_ptr<const T>& p)
1032{
1033    Serialize(os, *p);
1034}
1035
1036template<typename Stream, typename T>
1037void Unserialize(Stream& is, std::shared_ptr<const T>& p)
1038{
1039    p = std::make_shared<const T>(deserialize, is);
1040}
1041
1042/**
1043 * Support for (un)serializing many things at once
1044 */
1045
1046template <typename Stream, typename... Args>
1047void SerializeMany(Stream& s, const Args&... args)
1048{
1049    (::Serialize(s, args), ...);
1050}
1051
1052template <typename Stream, typename... Args>
1053inline void UnserializeMany(Stream& s, Args&&... args)
1054{
1055    (::Unserialize(s, args), ...);
1056}
1057
1058/**
1059 * Support for all macros providing or using the ser_action parameter of the SerializationOps method.
1060 */
1061struct ActionSerialize {
1062    static constexpr bool ForRead() { return false; }
1063
1064    template<typename Stream, typename... Args>
1065    static void SerReadWriteMany(Stream& s, const Args&... args)
1066    {
1067        ::SerializeMany(s, args...);
1068    }
1069
1070    template<typename Stream, typename Type, typename Fn>
1071    static void SerRead(Stream& s, Type&&, Fn&&)
1072    {
1073    }
1074
1075    template<typename Stream, typename Type, typename Fn>
1076    static void SerWrite(Stream& s, Type&& obj, Fn&& fn)
1077    {
1078        fn(s, std::forward<Type>(obj));
1079    }
1080};
1081struct ActionUnserialize {
1082    static constexpr bool ForRead() { return true; }
1083
1084    template<typename Stream, typename... Args>
1085    static void SerReadWriteMany(Stream& s, Args&&... args)
1086    {
1087        ::UnserializeMany(s, args...);
1088    }
1089
1090    template<typename Stream, typename Type, typename Fn>
1091    static void SerRead(Stream& s, Type&& obj, Fn&& fn)
1092    {
1093        fn(s, std::forward<Type>(obj));
1094    }
1095
1096    template<typename Stream, typename Type, typename Fn>
1097    static void SerWrite(Stream& s, Type&&, Fn&&)
1098    {
1099    }
1100};
1101
1102/* ::GetSerializeSize implementations
1103 *
1104 * Computing the serialized size of objects is done through a special stream
1105 * object of type SizeComputer, which only records the number of bytes written
1106 * to it.
1107 *
1108 * If your Serialize or SerializationOp method has non-trivial overhead for
1109 * serialization, it may be worthwhile to implement a specialized version for
1110 * SizeComputer, which uses the s.seek() method to record bytes that would
1111 * be written instead.
1112 */
1113class SizeComputer
1114{
1115protected:
1116    uint64_t m_size{0};
1117
1118public:
1119    SizeComputer() = default;
1120
1121    void write(std::span<const std::byte> src)
1122    {
1123        m_size += src.size();
1124    }
1125
1126    /** Pretend this many bytes are written, without specifying them. */
1127    void seek(uint64_t num)
1128    {
1129        m_size += num;
1130    }
1131
1132    template <typename T>
1133    SizeComputer& operator<<(const T& obj)
1134    {
1135        ::Serialize(*this, obj);
1136        return *this;
1137    }
1138
1139    uint64_t size() const
1140    {
1141        return m_size;
1142    }
1143};
1144
1145template<typename I>
1146inline void WriteVarInt(SizeComputer &s, I n)
1147{
1148    s.seek(GetSizeOfVarInt<I>(n));
1149}
1150
1151inline void WriteCompactSize(SizeComputer &s, uint64_t nSize)
1152{
1153    s.seek(GetSizeOfCompactSize(nSize));
1154}
1155
1156template <typename T>
1157uint64_t GetSerializeSize(const T& t)
1158{
1159    return (SizeComputer() << t).size();
1160}
1161
1162//! Check if type contains a stream by seeing if has a GetStream() method.
1163template<typename T>
1164concept ContainsStream = requires(T t) { t.GetStream(); };
1165
1166/** Wrapper that overrides the GetParams() function of a stream. */
1167template <typename SubStream, typename Params>
1168class ParamsStream
1169{
1170    const Params& m_params;
1171    // If ParamsStream constructor is passed an lvalue argument, Substream will
1172    // be a reference type, and m_substream will reference that argument.
1173    // Otherwise m_substream will be a substream instance and move from the
1174    // argument. Letting ParamsStream contain a substream instance instead of
1175    // just a reference is useful to make the ParamsStream object self contained
1176    // and let it do cleanup when destroyed, for example by closing files if
1177    // SubStream is a file stream.
1178    SubStream m_substream;
1179
1180public:
1181    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
1182
1183    template <typename NestedSubstream, typename Params1, typename Params2, typename... NestedParams>
1184    ParamsStream(NestedSubstream&& s, const Params1& params1 LIFETIMEBOUND, const Params2& params2 LIFETIMEBOUND, const NestedParams&... params LIFETIMEBOUND)
1185        : ParamsStream{::ParamsStream{std::forward<NestedSubstream>(s), params2, params...}, params1} {}
1186
1187    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
1188    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
1189    void write(std::span<const std::byte> src) { GetStream().write(src); }
1190    void read(std::span<std::byte> dst) { GetStream().read(dst); }
1191    void ignore(size_t num) { GetStream().ignore(num); }
1192    bool empty() const { return GetStream().empty(); }
1193    size_t size() const { return GetStream().size(); }
1194
1195    //! Get reference to stream parameters.
1196    template <typename P>
1197    const auto& GetParams() const
1198    {
1199        if constexpr (std::is_convertible_v<Params, P>) {
1200            return m_params;
1201        } else {
1202            return m_substream.template GetParams<P>();
1203        }
1204    }
1205
1206    //! Get reference to underlying stream.
1207    auto& GetStream()
1208    {
1209        if constexpr (ContainsStream<SubStream>) {
1210            return m_substream.GetStream();
1211        } else {
1212            return m_substream;
1213        }
1214    }
1215    const auto& GetStream() const
1216    {
1217        if constexpr (ContainsStream<SubStream>) {
1218            return m_substream.GetStream();
1219        } else {
1220            return m_substream;
1221        }
1222    }
1223};
1224
1225/**
1226 * Explicit template deduction guide is required for single-parameter
1227 * constructor so Substream&& is treated as a forwarding reference, and
1228 * SubStream is deduced as reference type for lvalue arguments.
1229 */
1230template <typename Substream, typename Params>
1231ParamsStream(Substream&&, const Params&) -> ParamsStream<Substream, Params>;
1232
1233/**
1234 * Template deduction guide for multiple params arguments that creates a nested
1235 * ParamsStream.
1236 */
1237template <typename Substream, typename Params1, typename Params2, typename... Params>
1238ParamsStream(Substream&& s, const Params1& params1, const Params2& params2, const Params&... params) ->
1239    ParamsStream<decltype(ParamsStream{std::forward<Substream>(s), params2, params...}), Params1>;
1240
1241/** Wrapper that serializes objects with the specified parameters. */
1242template <typename Params, typename T>
1243class ParamsWrapper
1244{
1245    const Params& m_params;
1246    T& m_object;
1247
1248public:
1249    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
1250