How objects become bytes

751
752/**
753 * unique_ptr
754 */
755template<typename Stream, typename T> void Serialize(Stream& os, const std::unique_ptr<const T>& p);
756template<typename Stream, typename T> void Unserialize(Stream& os, std::unique_ptr<const T>& p);
757
758
759/**
760 * If none of the specialized versions above matched, default to calling member function.
761 */
762template <class T, class Stream>
763concept Serializable = requires(T a, Stream s) { a.Serialize(s); };
764template <typename Stream, typename T>
765    requires Serializable<T, Stream>
766void Serialize(Stream& os, const T& a)
767{
768    a.Serialize(os);
769}
770
771template <class T, class Stream>
772concept Unserializable = requires(T a, Stream s) { a.Unserialize(s); };
773template <typename Stream, typename T>
774    requires Unserializable<T, Stream>
775void Unserialize(Stream& is, T&& a)
776{
777    a.Unserialize(is);
778}
779
780/** Default formatter. Serializes objects as themselves.
781 *
782 * The vector/prevector serialization code passes this to VectorFormatter
783 * to enable reusing that logic. It shouldn't be needed elsewhere.
784 */
785struct DefaultFormatter
786{
787    template<typename Stream, typename T>
788    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
789
790    template<typename Stream, typename T>
791    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
792};
793
794/**
795 * Limited vector formatter. Throws an error if a vector is oversized.
796 */
797
798template<size_t Limit, class Formatter = DefaultFormatter>
799struct LimitedVectorFormatter
800{
801    template<typename Stream, typename V>
802    void Unser(Stream& s, V& v)
803    {
804        Formatter formatter;
805        v.clear();
806        size_t size = ReadCompactSize(s);
807        if (size > Limit) {
808            throw std::ios_base::failure("Vector length limit exceeded");
809        }
810        v.reserve(size);
811        for (size_t i = 0; i < size; ++i) {
812            v.emplace_back();
813            formatter.Unser(s, v.back());
814        }
815    }
816
817    template<typename Stream, typename V>
818    void Ser(Stream& s, const V& v)
819    {
820        VectorFormatter<Formatter>{}.Ser(s, v);
821    }
822};
823
824
825
826
827/**
828 * string
829 */
830template<typename Stream, typename C>
831void Serialize(Stream& os, const std::basic_string<C>& str)
832{
833    WriteCompactSize(os, str.size());
834    if (!str.empty())
835        os.write(MakeByteSpan(str));
836}
837
838template<typename Stream, typename C>
839void Unserialize(Stream& is, std::basic_string<C>& str)
840{
841    unsigned int nSize = ReadCompactSize(is);
842    str.resize(nSize);
843    if (nSize != 0)
844        is.read(MakeWritableByteSpan(str));
845}
846
847/**
848 * string_view
849 */
850template<typename Stream, typename C>
851void Serialize(Stream& os, const std::basic_string_view<C>& str)
852{
853    WriteCompactSize(os, str.size());
854    if (!str.empty()) {
855        os.write(MakeByteSpan(str));
856    }
857}
858
859/**
860 * prevector
861 */
862template <typename Stream, unsigned int N, typename T>
863void Serialize(Stream& os, const prevector<N, T>& v)
864{
865    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866        WriteCompactSize(os, v.size());
867        if (!v.empty()) os.write(MakeByteSpan(v));
868    } else {
869        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870    }
871}
872
873
874template <typename Stream, unsigned int N, typename T>
875void Unserialize(Stream& is, prevector<N, T>& v)
876{
877    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
878        // Limit size per read so bogus size value won't cause out of memory
879        v.clear();
880        unsigned int nSize = ReadCompactSize(is);
881        unsigned int i = 0;
882        while (i < nSize) {
883            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
884            v.resize_uninitialized(i + blk);
885            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
886            i += blk;
887        }
888    } else {
889        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
890    }
891}
892
893
894/**
895 * vector
896 */
897template <typename Stream, typename T, typename A>
898void Serialize(Stream& os, const std::vector<T, A>& v)
899{
900    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901        WriteCompactSize(os, v.size());
902        if (!v.empty()) os.write(MakeByteSpan(v));
903    } else if constexpr (std::is_same_v<T, bool>) {
904        // A special case for std::vector<bool>, as dereferencing
905        // std::vector<bool>::const_iterator does not result in a const bool&
906        // due to std::vector's special casing for bool arguments.
907        WriteCompactSize(os, v.size());
908        for (bool elem : v) {
909            ::Serialize(os, elem);
910        }
911    } else {
912        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913    }
914}
915
916
917template <typename Stream, typename T, typename A>
918void Unserialize(Stream& is, std::vector<T, A>& v)
919{
920    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921        // Limit size per read so bogus size value won't cause out of memory
922        v.clear();
923        unsigned int nSize = ReadCompactSize(is);
924        unsigned int i = 0;
925        while (i < nSize) {
926            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927            v.resize(i + blk);
928            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929            i += blk;
930        }
931    } else {
932        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933    }
934}
935
936
937/**
938 * pair
939 */
940template<typename Stream, typename K, typename T>
941void Serialize(Stream& os, const std::pair<K, T>& item)
942{
943    Serialize(os, item.first);
944    Serialize(os, item.second);
945}
946
947template<typename Stream, typename K, typename T>
948void Unserialize(Stream& is, std::pair<K, T>& item)
949{
950    Unserialize(is, item.first);
951    Unserialize(is, item.second);
952}
953
954
955
956/**
957 * map
958 */
959template<typename Stream, typename K, typename T, typename Pred, typename A>
960void Serialize(Stream& os, const std::map<K, T, Pred, A>& m)
961{
962    WriteCompactSize(os, m.size());
963    for (const auto& entry : m)
964        Serialize(os, entry);
965}
966
967template<typename Stream, typename K, typename T, typename Pred, typename A>
968void Unserialize(Stream& is, std::map<K, T, Pred, A>& m)
969{
970    m.clear();
971    unsigned int nSize = ReadCompactSize(is);
972    typename std::map<K, T, Pred, A>::iterator mi = m.begin();
973    for (unsigned int i = 0; i < nSize; i++)
974    {
975        std::pair<K, T> item;
976        Unserialize(is, item);
977        mi = m.insert(mi, item);
978    }
979}
980
981
982
983/**
984 * set
985 */
986template<typename Stream, typename K, typename Pred, typename A>
987void Serialize(Stream& os, const std::set<K, Pred, A>& m)
988{
989    WriteCompactSize(os, m.size());
990    for (typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
991        Serialize(os, (*it));
992}
993
994template<typename Stream, typename K, typename Pred, typename A>
995void Unserialize(Stream& is, std::set<K, Pred, A>& m)
996{
997    m.clear();
998    unsigned int nSize = ReadCompactSize(is);
999    typename std::set<K, Pred, A>::iterator it = m.begin();
1000    for (unsigned int i = 0; i < nSize; i++)