json_datapack.h

Go to the documentation of this file.

#ifndef FPMAS_IO_JSON_DATAPACK_H
#define FPMAS_IO_JSON_DATAPACK_H
 
#include "datapack.h"
#include "json.h"
 
namespace fpmas { namespace io { namespace datapack {
        template<typename T, typename JsonType>
            struct BasicJsonSerializer {
 
                template<typename PackType>
                    static std::size_t size(const PackType&, const T&) {
                        return 0;
                    }
 
                template<typename PackType>
                    static void to_datapack(PackType& pack, const T& item) {
                        std::string json_str = JsonType(item).dump();
                        pack.expand(pack.template size(json_str));
                        pack.template put(json_str);
                    }
 
                template<typename PackType>
                    static T from_datapack(const PackType& pack) {
                        return JsonType::parse(
                                pack.template get<std::string>()
                                ).template get<T>();
                    }
            };
 
        template<typename JsonType>
            struct BasicJsonSerializer<std::string, JsonType> {
                template<typename PackType>
                    static std::size_t size(const PackType& pack, const std::string& item) {
                        return Serializer<std::string>::size(pack, item);
                    }
                template<typename PackType>
                    static void to_datapack(PackType& pack, const std::string& item) {
                        Serializer<std::string>::to_datapack(pack, item);
                    }
 
                template<typename PackType>
                    static std::string from_datapack(const PackType& pack) {
                        return Serializer<std::string>::from_datapack(pack);
                    }
            };
 
        template<typename T, typename Enable = void>
            using JsonSerializer = BasicJsonSerializer<T, nlohmann::json>;
        typedef BasicObjectPack<JsonSerializer> JsonPack;
 
        template<typename T, typename Enable = void>
            using LightJsonSerializer = BasicJsonSerializer<T, fpmas::io::json::light_json>;
        typedef BasicObjectPack<LightJsonSerializer> LightJsonPack;
}}}
 
namespace fpmas { namespace io { namespace json {
    template<typename T, typename PackType>
        struct basic_datapack_serializer {
            template<typename JsonType>
                static void to_json(JsonType& json, const T& data) {
                    PackType p = data;
                    std::vector<std::uint8_t> binary_buffer(p.data().size);
                    for(std::size_t i = 0; i < p.data().size; i++)
                        binary_buffer[i] = p.data().buffer[i];
 
                    json = JsonType::binary(std::move(binary_buffer));
                }
 
            template<typename JsonType>
                static T from_json(const JsonType& json) {
                    const std::vector<std::uint8_t>& binary_buffer = json.get_binary();
 
                    datapack::DataPack p(binary_buffer.size(), 1);
                    for(std::size_t i = 0; i < binary_buffer.size(); i++)
                        p.buffer[i] = binary_buffer[i];
                    return PackType::parse(p).template get<T>();
                }
        };
 
    template<typename T, typename Enable=void>
        using datapack_serializer
        = basic_datapack_serializer<T, fpmas::io::datapack::ObjectPack>;
 
    typedef nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, double, std::allocator, datapack_serializer> datapack_json;
 
    template<typename T, typename Enable=void>
        using light_datapack_serializer
        = basic_datapack_serializer<T, fpmas::io::datapack::LightObjectPack>;
 
    typedef nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, double, std::allocator, light_datapack_serializer> light_datapack_json;
 
}}}
 
#endif