json_serializer.h

Go to the documentation of this file.

#ifndef FPMAS_MODEL_JSON_SERIALIZER_H
#define FPMAS_MODEL_JSON_SERIALIZER_H
 
#include "serializer_set_up.h"
#include "fpmas/api/model/model.h"
#include "fpmas/io/json.h"
#include "fpmas/model/model.h"
 
#define FPMAS_BASE_JSON_SET_UP(...)\
    namespace nlohmann {\
        void adl_serializer<fpmas::api::model::AgentPtr>\
            ::to_json(json& j, const fpmas::api::model::AgentPtr& data) {\
            fpmas::io::json::AgentPtrSerializer<json, __VA_ARGS__ , void>::to_json(j, data);\
        }\
        fpmas::api::model::AgentPtr adl_serializer<fpmas::api::model::AgentPtr>\
            ::from_json(const json& j) {\
            return {fpmas::io::json::AgentPtrSerializer<json, __VA_ARGS__ , void>::from_json(j)};\
        }\
\
        void adl_serializer<fpmas::api::model::WeakAgentPtr>\
            ::to_json(json& j, const fpmas::api::model::WeakAgentPtr& data) {\
            fpmas::io::json::AgentPtrSerializer<json, __VA_ARGS__ , void>::to_json(j, data);\
        }\
        fpmas::api::model::WeakAgentPtr adl_serializer<fpmas::api::model::WeakAgentPtr>\
            ::from_json(const json& j) {\
            return fpmas::io::json::AgentPtrSerializer<json, __VA_ARGS__ , void>::from_json(j);\
        }\
    }\
    namespace fpmas { namespace io { namespace json {\
        void light_serializer<fpmas::api::model::AgentPtr>::to_json(light_json& j, const fpmas::api::model::AgentPtr& data) {\
            AgentPtrSerializer<light_json, __VA_ARGS__ , void>::to_json(j, data);\
        }\
        fpmas::api::model::AgentPtr light_serializer<fpmas::api::model::AgentPtr>::from_json(const light_json& j) {\
            return {AgentPtrSerializer<light_json, __VA_ARGS__ , void>::from_json(j)};\
        }\
        \
        void light_serializer<fpmas::api::model::WeakAgentPtr>\
            ::to_json(light_json& j, const fpmas::api::model::WeakAgentPtr& data) {\
            AgentPtrSerializer<light_json, __VA_ARGS__ , void>::to_json(j, data);\
        }\
        fpmas::api::model::WeakAgentPtr light_serializer<fpmas::api::model::WeakAgentPtr>\
            ::from_json(const light_json& j) {\
            return AgentPtrSerializer<light_json, __VA_ARGS__ , void>::from_json(j);\
        }\
    }}}\
 
#define FPMAS_BASE_DEFAULT_JSON_SET_UP()\
    namespace nlohmann {\
        void adl_serializer<fpmas::api::model::AgentPtr>\
            ::to_json(json& j, const fpmas::api::model::AgentPtr& data) {\
            fpmas::io::json::AgentPtrSerializer<json, void>::to_json(j, data);\
        }\
        fpmas::api::model::AgentPtr adl_serializer<fpmas::api::model::AgentPtr>\
            ::from_json(const json& j) {\
            return {fpmas::io::json::AgentPtrSerializer<json, void>::from_json(j)};\
        }\
\
        void adl_serializer<fpmas::api::model::WeakAgentPtr>\
            ::to_json(json& j, const fpmas::api::model::WeakAgentPtr& data) {\
            fpmas::io::json::AgentPtrSerializer<json, void>::to_json(j, data);\
        }\
        fpmas::api::model::WeakAgentPtr adl_serializer<fpmas::api::model::WeakAgentPtr>\
            ::from_json(const json& j) {\
            return fpmas::io::json::AgentPtrSerializer<json, void>::from_json(j);\
        }\
    }\
    namespace fpmas { namespace io { namespace json {\
        void light_serializer<fpmas::api::model::AgentPtr>::to_json(light_json& j, const fpmas::api::model::AgentPtr& data) {\
            AgentPtrSerializer<light_json, void>::to_json(j, data);\
        }\
        fpmas::api::model::AgentPtr light_serializer<fpmas::api::model::AgentPtr>::from_json(const light_json& j) {\
            return {AgentPtrSerializer<light_json, void>::from_json(j)};\
        }\
        \
        void light_serializer<fpmas::api::model::WeakAgentPtr>\
            ::to_json(light_json& j, const fpmas::api::model::WeakAgentPtr& data) {\
            AgentPtrSerializer<light_json, void>::to_json(j, data);\
        }\
        fpmas::api::model::WeakAgentPtr light_serializer<fpmas::api::model::WeakAgentPtr>\
            ::from_json(const light_json& j) {\
            return AgentPtrSerializer<light_json, void>::from_json(j);\
        }\
    }}}\
 
#define FPMAS_DEFAULT_JSON(AGENT) \
    namespace nlohmann {\
        template<>\
\
            struct adl_serializer<fpmas::api::utils::PtrWrapper<AGENT>> {\
\
                template<typename JsonType>\
                static void to_json(JsonType& j, const fpmas::api::utils::PtrWrapper<AGENT>&) {\
                    j = json::object();\
                }\
\
\
                template<typename JsonType>\
                static void from_json(const JsonType&, fpmas::api::utils::PtrWrapper<AGENT>& ptr) {\
                    ptr = fpmas::api::utils::PtrWrapper<AGENT>(new AGENT);\
                }\
            };\
    }
 
namespace nlohmann {
    
    template<>
        struct adl_serializer<std::type_index> {
            private:
            static FPMAS_TYPE_INDEX id;
            static std::unordered_map<FPMAS_TYPE_INDEX, std::type_index> id_to_type;
            static std::unordered_map<std::type_index, FPMAS_TYPE_INDEX> type_to_id;
 
            public:
            static FPMAS_TYPE_INDEX register_type(const std::type_index& type) {
                FPMAS_TYPE_INDEX new_id = id++;
                type_to_id.insert({type, new_id});
                id_to_type.insert({new_id, type});
                return new_id;
            }
 
            template<typename JsonType>
            static std::type_index from_json(const JsonType& j) {
                FPMAS_TYPE_INDEX id = j.template get<FPMAS_TYPE_INDEX>();
                auto _type = id_to_type.find(id);
                if(_type != id_to_type.end())
                    return _type->second;
                throw fpmas::exceptions::BadIdException(id);
 
            }
 
            template<typename JsonType>
            static void to_json(JsonType& j, const std::type_index& type) {
                auto _id = type_to_id.find(type);
                if(_id != type_to_id.end())
                    j = _id->second;
                else
                    throw fpmas::exceptions::BadTypeException(type);
            }
        };
 
    template<typename AgentType>
        struct adl_serializer<fpmas::api::utils::PtrWrapper<AgentType>> {
            template<typename JsonType>
            static fpmas::api::utils::PtrWrapper<AgentType> from_json(const JsonType& j) {
                return AgentType::from_json(j);
            }
 
            template<typename JsonType>
            static void to_json(JsonType& j, const fpmas::api::utils::PtrWrapper<AgentType>& agent_ptr) {
                AgentType::to_json(j, agent_ptr.get());
            }
        };
}
 
namespace fpmas { namespace io { namespace json {
 
    template<typename AgentType>
        struct light_serializer<
        fpmas::api::utils::PtrWrapper<AgentType>,
        typename std::enable_if<
            std::is_base_of<fpmas::api::model::Agent, AgentType>::value
            && !std::is_default_constructible<AgentType>::value
            && std::is_same<AgentType, typename AgentType::FinalAgentType>::value>::type
            >{
                public:
                    static void to_json(light_json& j, const fpmas::api::utils::PtrWrapper<AgentType>& agent) {
                        static bool warn_print = false;
                        if(!warn_print) {
                            warn_print = true;
                            FPMAS_LOGW(0, "light_serializer",
                                    "Type %s does not define a default constructor or "
                                    "a light_serializer specialization."
                                    "This might be uneficient.", FPMAS_TYPE_STR(AgentType)
                                    );
                        }
 
                        nlohmann::json _j = agent;
                        j = light_json::parse(_j.dump());
                    }
 
                    static fpmas::api::utils::PtrWrapper<AgentType> from_json(const light_json& j) {
                        nlohmann::json _j = nlohmann::json::parse(j.dump());
                        return _j.get<fpmas::api::utils::PtrWrapper<AgentType>>();
                    }
            };
 
    
    template<typename AgentType>
        struct light_serializer<
            fpmas::api::utils::PtrWrapper<AgentType>,
            typename std::enable_if<
                std::is_base_of<fpmas::api::model::Agent, AgentType>::value
                && std::is_default_constructible<AgentType>::value
                && std::is_same<AgentType, typename AgentType::FinalAgentType>::value>::type
         > {
 
            static void to_json(light_json&, const fpmas::api::utils::PtrWrapper<AgentType>&) {
            }
 
            static fpmas::api::utils::PtrWrapper<AgentType> from_json(const light_json&) {
                return new AgentType;
            }
        };
 
}}}
 
namespace fpmas { namespace io { namespace json {
    using api::utils::PtrWrapper;
    using api::model::AgentPtr;
    using api::model::WeakAgentPtr;
 
    template<typename JsonType, typename Type, typename... AgentTypes> 
        struct AgentPtrSerializer;
 
    template<typename JsonType> 
        struct AgentPtrSerializer<JsonType, void> {
            static void to_json(JsonType&, const WeakAgentPtr& ptr); 
 
            static WeakAgentPtr from_json(const JsonType& j);
        };
 
    template<typename JsonType>
        void AgentPtrSerializer<JsonType, void>::to_json(
                JsonType &, const WeakAgentPtr& ptr) {
            FPMAS_LOGE(-1, "AGENT_SERIALIZER",
                    "Invalid agent type : %s. Make sure to properly register "
                    "the Agent type with FPMAS_JSON_SET_UP and FPMAS_REGISTER_AGENT_TYPES.",
                    ptr->typeId().name());
            throw exceptions::BadTypeException(ptr->typeId());
        }
 
    template<typename JsonType>
        WeakAgentPtr AgentPtrSerializer<JsonType, void>::from_json(const JsonType &j) {
            std::size_t id = j.at("type").template get<std::size_t>();
            FPMAS_LOGE(-1, "AGENT_SERIALIZER",
                    "Invalid agent type id : %lu. Make sure to properly register "
                    "the Agent type with FPMAS_JSON_SET_UP and FPMAS_REGISTER_AGENT_TYPES.",
                    id);
            throw exceptions::BadIdException(id);
        }
 
    template<typename JsonType, typename Type, typename... AgentTypes> 
        struct AgentPtrSerializer {
            static void to_json(
                    JsonType& j, const WeakAgentPtr& ptr) {
                if(ptr->typeId() == Type::TYPE_ID) {
                    j["type"] = Type::TYPE_ID;
                    j["gids"] = ptr->groupIds();
                    j["agent"] = TypedAgentPtr<Type>(
                            const_cast<Type*>(static_cast<const Type*>(ptr.get()))
                            );
                } else {
                    AgentPtrSerializer<JsonType, AgentTypes...>::to_json(j, ptr);
                }
            }
 
            static WeakAgentPtr from_json(const JsonType& j) {
                fpmas::api::model::TypeId id = j.at("type")
                    .template get<fpmas::api::model::TypeId>();
                if(id == Type::TYPE_ID) {
                    auto agent = j.at("agent").template get<TypedAgentPtr<Type>>();
                    for(auto gid : j.at("gids")
                            .template get<std::vector<fpmas::api::model::GroupId>>())
                        agent->addGroupId(gid);
                    return {agent};
                } else {
                    return AgentPtrSerializer<JsonType, AgentTypes...>::from_json(j);
                }
            }
 
        };
}}}
#endif