datapack_serializer.h

Go to the documentation of this file.

#ifndef FPMAS_MODEL_DATAPACK_SERIALIZER_H
#define FPMAS_MODEL_DATAPACK_SERIALIZER_H
 
#include "serializer_set_up.h"
#include "fpmas/api/model/model.h"
#include "fpmas/io/datapack.h"
#include "fpmas/model/model.h"
 
#define FPMAS_BASE_DATAPACK_SET_UP(...)\
    namespace fpmas { namespace io { namespace datapack {\
        std::size_t Serializer<api::model::AgentPtr>\
            ::size(const ObjectPack& p, const api::model::AgentPtr& data) {\
            return AgentPtrSerializer<ObjectPack, __VA_ARGS__ , void>::size(p, data);\
        }\
        void Serializer<api::model::AgentPtr>\
            ::to_datapack(ObjectPack& p, const api::model::AgentPtr& data) {\
            AgentPtrSerializer<ObjectPack, __VA_ARGS__ , void>::to_datapack(p, data);\
        }\
        api::model::AgentPtr Serializer<api::model::AgentPtr>\
            ::from_datapack(const ObjectPack& p) {\
            return {AgentPtrSerializer<ObjectPack, __VA_ARGS__ , void>::from_datapack(p)};\
        }\
        \
        std::size_t Serializer<api::model::WeakAgentPtr>\
            ::size(const ObjectPack& p, const api::model::WeakAgentPtr& data) {\
            return AgentPtrSerializer<ObjectPack, __VA_ARGS__ , void>::size(p, data);\
        }\
        void Serializer<api::model::WeakAgentPtr>\
            ::to_datapack(ObjectPack& p, const api::model::WeakAgentPtr& data) {\
            AgentPtrSerializer<ObjectPack, __VA_ARGS__ , void>::to_datapack(p, data);\
        }\
        api::model::WeakAgentPtr Serializer<api::model::WeakAgentPtr>\
            ::from_datapack(const ObjectPack& p) {\
            return AgentPtrSerializer<ObjectPack, __VA_ARGS__ , void>::from_datapack(p);\
        }\
        \
        std::size_t LightSerializer<api::model::AgentPtr>\
            ::size(const LightObjectPack& p, const api::model::AgentPtr& data) {\
            return AgentPtrSerializer<LightObjectPack, __VA_ARGS__ , void>::size(p, data);\
        }\
        void LightSerializer<api::model::AgentPtr>\
            ::to_datapack(LightObjectPack& p, const api::model::AgentPtr& data) {\
            AgentPtrSerializer<LightObjectPack, __VA_ARGS__ , void>::to_datapack(p, data);\
        }\
        api::model::AgentPtr LightSerializer<api::model::AgentPtr>::from_datapack(const LightObjectPack& p) {\
            return {AgentPtrSerializer<LightObjectPack, __VA_ARGS__ , void>::from_datapack(p)};\
        }\
        \
        std::size_t LightSerializer<api::model::WeakAgentPtr>\
            ::size(const LightObjectPack& p, const api::model::WeakAgentPtr& data) {\
            return AgentPtrSerializer<LightObjectPack, __VA_ARGS__ , void>::size(p, data);\
        }\
        void LightSerializer<api::model::WeakAgentPtr>\
            ::to_datapack(LightObjectPack& p, const api::model::WeakAgentPtr& data) {\
            AgentPtrSerializer<LightObjectPack, __VA_ARGS__ , void>::to_datapack(p, data);\
        }\
        api::model::WeakAgentPtr LightSerializer<api::model::WeakAgentPtr>\
            ::from_datapack(const LightObjectPack& p) {\
            return AgentPtrSerializer<LightObjectPack, __VA_ARGS__ , void>::from_datapack(p);\
        }\
    }}}
 
#define FPMAS_BASE_DEFAULT_DATAPACK_SET_UP() \
    namespace fpmas { namespace io { namespace datapack {\
        std::size_t Serializer<fpmas::api::model::AgentPtr>::size(const ObjectPack& o, const fpmas::api::model::AgentPtr& data) {\
            return AgentPtrSerializer<ObjectPack, void>::size(o, data);\
        }\
        void Serializer<fpmas::api::model::AgentPtr>::to_datapack(ObjectPack& o, const fpmas::api::model::AgentPtr& data) {\
            AgentPtrSerializer<ObjectPack, void>::to_datapack(o, data);\
        }\
        fpmas::api::model::AgentPtr Serializer<fpmas::api::model::AgentPtr>::from_datapack(const ObjectPack& o) {\
            return {AgentPtrSerializer<ObjectPack, void>::from_datapack(o)};\
        }\
        \
        std::size_t Serializer<fpmas::api::model::WeakAgentPtr>::size(const ObjectPack& o, const fpmas::api::model::WeakAgentPtr& data) {\
            return AgentPtrSerializer<ObjectPack, void>::size(o, data);\
        }\
        void Serializer<fpmas::api::model::WeakAgentPtr>\
            ::to_datapack(ObjectPack& o, const fpmas::api::model::WeakAgentPtr& data) {\
            AgentPtrSerializer<ObjectPack, void>::to_datapack(o, data);\
        }\
        fpmas::api::model::WeakAgentPtr Serializer<fpmas::api::model::WeakAgentPtr>\
            ::from_datapack(const ObjectPack& o) {\
            return AgentPtrSerializer<ObjectPack, void>::from_datapack(o);\
        }\
        \
        std::size_t LightSerializer<fpmas::api::model::AgentPtr>::size(const LightObjectPack& o, const fpmas::api::model::AgentPtr& data) {\
            return AgentPtrSerializer<LightObjectPack, void>::size(o, data);\
        }\
        void LightSerializer<fpmas::api::model::AgentPtr>::to_datapack(LightObjectPack& o, const fpmas::api::model::AgentPtr& data) {\
            AgentPtrSerializer<LightObjectPack, void>::to_datapack(o, data);\
        }\
        fpmas::api::model::AgentPtr LightSerializer<fpmas::api::model::AgentPtr>::from_datapack(const LightObjectPack& o) {\
            return {AgentPtrSerializer<LightObjectPack, void>::from_datapack(o)};\
        }\
        \
        std::size_t LightSerializer<fpmas::api::model::WeakAgentPtr>::size(const LightObjectPack& o, const fpmas::api::model::WeakAgentPtr& data) {\
            return AgentPtrSerializer<LightObjectPack, void>::size(o, data);\
        }\
        void LightSerializer<fpmas::api::model::WeakAgentPtr>\
            ::to_datapack(LightObjectPack& o, const fpmas::api::model::WeakAgentPtr& data) {\
            AgentPtrSerializer<LightObjectPack, void>::to_datapack(o, data);\
        }\
        fpmas::api::model::WeakAgentPtr LightSerializer<fpmas::api::model::WeakAgentPtr>\
            ::from_datapack(const LightObjectPack& o) {\
            return AgentPtrSerializer<LightObjectPack, void>::from_datapack(o);\
        }\
    }}}\
 
#define FPMAS_DEFAULT_DATAPACK(AGENT) \
    namespace fpmas { namespace io { namespace datapack {\
        template<>\
\
            struct Serializer<fpmas::api::utils::PtrWrapper<AGENT>> {\
                template<typename PackType>\
                static std::size_t size(const PackType&, const fpmas::api::utils::PtrWrapper<AGENT>&) {\
                    return 0;\
                }\
                \
\
                template<typename PackType>\
                static void to_datapack(PackType&, const fpmas::api::utils::PtrWrapper<AGENT>&) {\
                }\
                \
\
                template<typename PackType>\
                static fpmas::api::utils::PtrWrapper<AGENT> from_datapack(const PackType&) {\
                    return {new AGENT};\
                }\
            };\
    }}}
 
namespace fpmas { namespace io { namespace datapack {
 
    using api::model::AgentPtr;
    using api::model::WeakAgentPtr;
 
    template<>
        struct 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 PackType>
                    static FPMAS_TYPE_INDEX size(const PackType& pack) {
                        return pack.template size<FPMAS_TYPE_INDEX>();
                    }
 
                template<typename PackType>
                    static FPMAS_TYPE_INDEX size(const PackType& o, const std::type_index&) {
                        return o.template size<FPMAS_TYPE_INDEX>();
                    }
 
                template<typename PackType>
                    static void to_datapack(PackType& pack, const std::type_index& index) {
                        auto _id = type_to_id.find(index);
                        if(_id != type_to_id.end())
                            pack.put(_id->second);
                        else
                            throw fpmas::exceptions::BadTypeException(index);
                    }
 
                template<typename PackType>
                    static std::type_index from_datapack(const PackType& pack) {
                        FPMAS_TYPE_INDEX type_id = pack.template get<FPMAS_TYPE_INDEX>();
                        auto _type = id_to_type.find(type_id);
                        if(_type != id_to_type.end())
                            return _type->second;
                        throw fpmas::exceptions::BadIdException(type_id);
                    }
        };
 
     template<typename AgentType>
     struct Serializer<api::utils::PtrWrapper<AgentType>> {
         template<typename PackType>
             static std::size_t size(const PackType& p, const api::utils::PtrWrapper<AgentType>& agent_ptr) {
                 return AgentType::size(p, agent_ptr.get());
             }
 
         template<typename PackType>
             static void to_datapack(PackType& pack, const api::utils::PtrWrapper<AgentType>& agent_ptr) {
                 AgentType::to_datapack(pack, agent_ptr.get());
             }
 
         template<typename PackType>
             static api::utils::PtrWrapper<AgentType> from_datapack(const PackType& pack) {
                 return AgentType::from_datapack(pack);
             }
     };
 
    template<typename AgentType>
        struct LightSerializer<
        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 std::size_t size(const LightObjectPack& p, const fpmas::api::utils::PtrWrapper<AgentType>& agent) {
                        // Size required to serialize a classic ObjectPack into
                        // a LightObjectPack (the ObjectPack size is required
                        // in addition to the ObjectPack buffer size)
                        // This should be equivalent to the more correct
                        // `p.size(ObjectPack(agent))`, but avoids useless
                        // ObjectPack serialization in this method.
                        return p.size<std::size_t>() + ObjectPack().size(agent);
                    }
 
                    static void to_datapack(LightObjectPack& pack, const fpmas::api::utils::PtrWrapper<AgentType>& agent) {
                        static bool warn_print = false;
                        if(!warn_print) {
                            warn_print = true;
                            FPMAS_LOGW(0, "LightSerializer",
                                    "Type %s does not define a default constructor or "
                                    "a LightSerializer specialization."
                                    "This might be uneficient.", FPMAS_TYPE_STR(AgentType)
                                    );
                        }
 
                        pack.put(ObjectPack(agent));
                    }
 
                    static fpmas::api::utils::PtrWrapper<AgentType> from_datapack(const LightObjectPack& pack) {
                        return pack.get<ObjectPack>()
                            .get<fpmas::api::utils::PtrWrapper<AgentType>>();
                    }
            };
 
    template<typename AgentType>
        struct LightSerializer<
        fpmas::api::utils::PtrWrapper<AgentType>,
        typename std::enable_if<
            std::is_base_of<api::model::Agent, AgentType>::value
            && std::is_default_constructible<AgentType>::value
            && std::is_same<AgentType, typename AgentType::FinalAgentType>::value>::type
            > {
 
 
                static std::size_t size(
                        const LightObjectPack&, const api::utils::PtrWrapper<AgentType>&) {
                    return 0;
                }
 
                static void to_datapack(
                        LightObjectPack&, const api::utils::PtrWrapper<AgentType>&) {
                }
 
                static api::utils::PtrWrapper<AgentType> from_datapack(
                        const LightObjectPack&) {
                    return new AgentType;
                }
            };
 
    template<typename PackType, typename Type, typename... AgentTypes> 
        struct AgentPtrSerializer;
 
    template<typename PackType> 
        struct AgentPtrSerializer<PackType, void> {
            static std::size_t size(const PackType&, const WeakAgentPtr&);
            static void to_datapack(PackType&, const WeakAgentPtr& ptr); 
 
            static WeakAgentPtr from_datapack(const PackType& p);
        };
 
    template<typename PackType>
        std::size_t AgentPtrSerializer<PackType, void>::size(
                const PackType &, const WeakAgentPtr& ptr) {
            FPMAS_LOGE(-1, "AGENT_SERIALIZER",
                    "Invalid agent type : %s. Make sure to properly register "
                    "the Agent type with FPMAS_DATAPACK_SET_UP and FPMAS_REGISTER_AGENT_TYPES.",
                    ptr->typeId().name());
            throw exceptions::BadTypeException(ptr->typeId());
        }
 
    template<typename PackType>
        void AgentPtrSerializer<PackType, void>::to_datapack(
                PackType &, const WeakAgentPtr& ptr) {
            FPMAS_LOGE(-1, "AGENT_SERIALIZER",
                    "Invalid agent type : %s. Make sure to properly register "
                    "the Agent type with FPMAS_DATAPACK_SET_UP and FPMAS_REGISTER_AGENT_TYPES.",
                    ptr->typeId().name());
            throw exceptions::BadTypeException(ptr->typeId());
        }
 
    template<typename PackType>
        WeakAgentPtr AgentPtrSerializer<PackType, void>::from_datapack(const PackType &p) {
            std::size_t id = p.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_DATAPACK_SET_UP and FPMAS_REGISTER_AGENT_TYPES.",
                    id);
            throw exceptions::BadIdException(id);
        }
 
    template<typename PackType, typename Type, typename... AgentTypes> 
        struct AgentPtrSerializer {
            static std::size_t size(const PackType& p, const WeakAgentPtr& ptr) {
                if(ptr->typeId() == Type::TYPE_ID) {
                    return p.template size<api::model::TypeId>()
                        + p.template size(TypedAgentPtr<Type>(
                            const_cast<Type*>(static_cast<const Type*>(ptr.get()))
                            ))
                        + p.template size(ptr->groupIds());
                }
                return AgentPtrSerializer<PackType, AgentTypes...>::size(p, ptr);
            }
 
            static void to_datapack(
                    PackType& p, const WeakAgentPtr& ptr) {
                if(ptr->typeId() == Type::TYPE_ID) {
                    p.put(Type::TYPE_ID);
                    p.put(TypedAgentPtr<Type>(
                            const_cast<Type*>(static_cast<const Type*>(ptr.get()))
                            ));
                    p.put(ptr->groupIds());
                } else {
                    AgentPtrSerializer<PackType, AgentTypes...>::to_datapack(p, ptr);
                }
            }
 
            static WeakAgentPtr from_datapack(const PackType& p) {
                std::size_t pos = p.readOffset();
                fpmas::api::model::TypeId id = p
                    .template get<fpmas::api::model::TypeId>();
                if(id == Type::TYPE_ID) {
                    auto agent = p
                        .template get<TypedAgentPtr<Type>>();
                    for(auto gid : 
                            p.template get<std::vector<api::model::GroupId>>())
                        agent->addGroupId(gid);
                    return {agent};
                } else {
                    p.seekRead(pos);
                    return AgentPtrSerializer<PackType, AgentTypes...>::from_datapack(p);
                }
            }
        };
 
}}}
 
#endif