util/serialization/format.hpp

Go to the documentation of this file.

// Copyright (c) 2021 MIT Digital Currency Initiative,
//                    Federal Reserve Bank of Boston
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef OPENCBDC_TX_SRC_SERIALIZATION_FORMAT_H_
#define OPENCBDC_TX_SRC_SERIALIZATION_FORMAT_H_
 
#include "serializer.hpp"
#include "util/common/buffer.hpp"
#include "util/common/config.hpp"
#include "util/common/variant_overloaded.hpp"
 
#include <algorithm>
#include <array>
#include <cassert>
#include <cstdint>
#include <limits>
#include <optional>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <variant>
#include <vector>
 
namespace cbdc {
 
    auto operator<<(serializer& packet, std::byte b) -> serializer&;
 
    auto operator>>(serializer& packet, std::byte& b) -> serializer&;
 
    auto operator<<(serializer& ser, const buffer& b) -> serializer&;
 
    auto operator>>(serializer& deser, buffer& b) -> serializer&;
 
    template<typename T>
    auto operator<<(serializer& s, T /* t */) ->
        typename std::enable_if_t<std::is_empty_v<T>, serializer&> {
        return s;
    }
 
    template<typename T>
    auto operator>>(serializer& s, T& /* t */) ->
        typename std::enable_if_t<std::is_empty_v<T>, serializer&> {
        return s;
    }
 
    template<typename T>
    auto operator<<(serializer& s, T t) ->
        typename std::enable_if_t<std::is_integral_v<T> && !std::is_enum_v<T>,
                                  serializer&> {
        s.write(&t, sizeof(t));
        return s;
    }
 
    template<typename T>
    auto operator>>(serializer& s, T& t) ->
        typename std::enable_if_t<std::is_integral_v<T> && !std::is_enum_v<T>,
                                  serializer&> {
        s.read(&t, sizeof(t));
        return s;
    }
 
    template<typename T, size_t len>
    auto operator<<(serializer& packet, const std::array<T, len>& arr) ->
        typename std::enable_if_t<std::is_integral_v<T>, serializer&> {
        packet.write(arr.data(), sizeof(T) * len);
        return packet;
    }
 
    template<typename T, size_t len>
    auto operator>>(serializer& packet, std::array<T, len>& arr) ->
        typename std::enable_if_t<std::is_integral_v<T>, serializer&> {
        packet.read(arr.data(), sizeof(T) * len);
        return packet;
    }
 
    template<typename T>
    auto operator>>(serializer& deser, std::optional<T>& val) -> serializer& {
        bool has_value{};
        if(!(deser >> has_value)) {
            return deser;
        }
 
        if(has_value) {
            auto opt_val = T();
            if(!(deser >> opt_val)) {
                return deser;
            }
            val = std::move(opt_val);
        } else {
            val = std::nullopt;
        }
 
        return deser;
    }
 
    template<typename T>
    auto operator<<(serializer& ser, const std::optional<T>& val)
        -> serializer& {
        auto has_value = val.has_value();
        ser << has_value;
        if(has_value) {
            ser << *val;
        }
        return ser;
    }
 
    template<typename A, typename B>
    auto operator<<(serializer& ser, const std::pair<A, B>& p) -> serializer& {
        ser << p.first << p.second;
        return ser;
    }
 
    template<typename A, typename B>
    auto operator>>(serializer& deser, std::pair<A, B>& p) -> serializer& {
        auto a = A();
        if(!(deser >> a)) {
            return deser;
        }
 
        auto b = B();
        if(!(deser >> b)) {
            return deser;
        }
 
        p = {std::move(a), std::move(b)};
        return deser;
    }
 
    template<typename T>
    auto operator<<(serializer& packet, const std::vector<T>& vec)
        -> serializer& {
        const auto len = static_cast<uint64_t>(vec.size());
        packet << len;
        for(uint64_t i = 0; i < len; i++) {
            packet << static_cast<T>(vec[i]);
        }
        return packet;
    }
 
    template<typename T>
    auto operator>>(serializer& packet, std::vector<T>& vec) -> serializer& {
        static_assert(sizeof(T) <= config::maximum_reservation,
                      "Vector element size too large");
 
        uint64_t len{};
        if(!(packet >> len)) {
            return packet;
        }
 
        uint64_t allocated = 0;
        while(allocated < len) {
            allocated = std::min(
                len,
                allocated + config::maximum_reservation / sizeof(T));
            vec.reserve(allocated);
            while(vec.size() < allocated) {
                if constexpr(std::is_default_constructible_v<T>) {
                    T val{};
                    if(!(packet >> val)) {
                        return packet;
                    }
                    vec.push_back(std::move(val));
                } else {
                    auto val = T(packet);
                    if(!packet) {
                        return packet;
                    }
                    vec.push_back(std::move(val));
                }
            }
        }
 
        vec.shrink_to_fit();
        return packet;
    }
 
    template<typename K, typename V, typename... Ts>
    auto operator<<(serializer& ser,
                    const std::unordered_map<K, V, Ts...>& map)
        -> serializer& {
        auto len = static_cast<uint64_t>(map.size());
        ser << len;
        for(const auto& it : map) {
            ser << static_cast<K>(it.first);
            ser << static_cast<V>(it.second);
        }
        return ser;
    }
 
    template<typename K, typename V, typename... Ts>
    auto operator>>(serializer& deser, std::unordered_map<K, V, Ts...>& map)
        -> serializer& {
        static_assert(sizeof(K) + sizeof(V) <= config::maximum_reservation,
                      "Unordered Map element size too large");
        auto len = uint64_t();
        if(!(deser >> len)) {
            return deser;
        }
 
        uint64_t allocated = 0;
        while(allocated < len) {
            allocated = std::min(len,
                                 allocated
                                     + config::maximum_reservation
                                           / (sizeof(K) + sizeof(V)));
            map.reserve(allocated);
            while(map.size() < allocated) {
                auto key = K();
                if(!(deser >> key)) {
                    return deser;
                }
 
                auto val = V();
                if(!(deser >> val)) {
                    return deser;
                }
 
                map.emplace(std::move(key), std::move(val));
            }
        }
        return deser;
    }
 
    template<typename K, typename... Ts>
    auto operator<<(serializer& ser, const std::set<K, Ts...>& set)
        -> serializer& {
        auto len = static_cast<uint64_t>(set.size());
        ser << len;
        for(const auto& key : set) {
            ser << static_cast<K>(key);
        }
        return ser;
    }
 
    template<typename K, typename... Ts>
    auto operator>>(serializer& deser, std::set<K, Ts...>& set)
        -> serializer& {
        auto len = uint64_t();
        if(!(deser >> len)) {
            return deser;
        }
 
        for(uint64_t i = 0; i < len; i++) {
            auto key = K();
            if(!(deser >> key)) {
                return deser;
            }
            set.emplace(std::move(key));
        }
        return deser;
    }
 
    template<typename K, typename... Ts>
    auto operator<<(serializer& ser, const std::unordered_set<K, Ts...>& set)
        -> serializer& {
        auto len = static_cast<uint64_t>(set.size());
        ser << len;
        for(const auto& key : set) {
            ser << static_cast<K>(key);
        }
        return ser;
    }
 
    template<typename K, typename... Ts>
    auto operator>>(serializer& deser, std::unordered_set<K, Ts...>& set)
        -> serializer& {
        static_assert(sizeof(K) <= config::maximum_reservation,
                      "Unordered Set element size too large");
        auto len = uint64_t();
        if(!(deser >> len)) {
            return deser;
        }
 
        uint64_t allocated = 0;
        while(allocated < len) {
            allocated = std::min(
                len,
                allocated + config::maximum_reservation / sizeof(K));
            while(set.size() < allocated) {
                auto key = K();
                if(!(deser >> key)) {
                    return deser;
                }
                set.emplace(std::move(key));
            }
        }
        return deser;
    }
 
    template<typename... Ts>
    auto operator<<(serializer& ser, const std::variant<Ts...>& var)
        -> serializer& {
        using S = uint8_t;
        static_assert(
            std::variant_size_v<std::remove_reference_t<decltype(var)>> < std::
                numeric_limits<S>::max());
        auto idx = static_cast<S>(var.index());
        ser << idx;
        std::visit(
            [&](auto&& arg) {
                ser << arg;
            },
            var);
        return ser;
    }
 
    template<typename... Ts>
    auto operator>>(serializer& deser, std::variant<Ts...>& var)
        -> std::enable_if_t<(std::is_default_constructible_v<Ts> && ...),
                            serializer&> {
        using S = uint8_t;
        static_assert(
            std::variant_size_v<std::remove_reference_t<decltype(var)>> < std::
                numeric_limits<S>::max());
        S idx{};
        deser >> idx;
        auto var_idx = static_cast<size_t>(idx);
        var = expand_type<Ts...>(var_idx);
        std::visit(
            [&](auto&& arg) {
                deser >> arg;
            },
            var);
        return deser;
    }
 
    template<typename... Ts>
    [[nodiscard]] auto get_variant(serializer& deser) -> std::variant<Ts...> {
        using T = typename std::variant<Ts...>;
        using S = uint8_t;
        static_assert(std::variant_size_v<T> < std::numeric_limits<S>::max());
        // Since if the variant holds only default constructiable types
        // we will be only able to unpack it using >>
        // thus we can't extract the index value from the deser
        if constexpr((std::is_default_constructible_v<Ts> && ...)) {
            T variants;
            deser >> variants;
            return variants;
        } else {
            S idx{};
            deser >> idx;
            auto i = static_cast<size_t>(idx);
            assert(i < std::variant_size_v<T>);
            static constexpr auto t = std::array{+[](serializer& d) {
                return T{std::in_place_type<Ts>, d};
            }...};
            // TODO: deserialization error handling for variant indexes.
            return t.at(i)(deser);
        }
    }
 
    // TODO: use std::is_scoped_enum_v and std::to_underlying once C++23 is
    // available.
    template<typename T>
    auto operator<<(serializer& ser, T e) ->
        typename std::enable_if_t<std::is_enum_v<T>, serializer&> {
        return ser << static_cast<std::underlying_type_t<T>>(e);
    }
 
    template<typename T>
    auto operator>>(serializer& deser, T& e) ->
        typename std::enable_if_t<std::is_enum_v<T>, serializer&> {
        std::underlying_type_t<T> val{};
        if(deser >> val) {
            e = static_cast<T>(val);
        }
        return deser;
    }
}
 
#endif // OPENCBDC_TX_SRC_SERIALIZATION_FORMAT_H_