data_update_pack.h

Go to the documentation of this file.

#ifndef FPMAS_DATA_UPDATE_PACK_H
#define FPMAS_DATA_UPDATE_PACK_H
 
#include "fpmas/api/graph/distributed_id.h"
#include "fpmas/io/datapack.h"
 
namespace fpmas { namespace synchro {
    template<typename T>
        struct DataUpdatePack {
            DistributedId id;
            T updated_data;
 
            DataUpdatePack(DistributedId id, const T& data)
                : id(id), updated_data(data) {}
        };
 
    template<typename T>
        struct NodeUpdatePack : public DataUpdatePack<T> {
            float updated_weight;
 
            NodeUpdatePack(DistributedId id, const T& data, float weight)
                : DataUpdatePack<T>(id, data), updated_weight(weight) {}
        };
}}
 
namespace nlohmann {
    using fpmas::synchro::DataUpdatePack;
    using fpmas::synchro::NodeUpdatePack;
 
    template <typename T>
    struct adl_serializer<DataUpdatePack<T>> {
        static DataUpdatePack<T> from_json(const json& j) {
            return {j[0].get<DistributedId>(), j[1].get<T>()};
        }
 
        static void to_json(json& j, const DataUpdatePack<T>& data) {
            j = json::array({data.id, data.updated_data});
        }
    };
 
    template <typename T>
    struct adl_serializer<NodeUpdatePack<T>> {
        static NodeUpdatePack<T> from_json(const json& j) {
            return {j[0].get<DistributedId>(), j[1].get<T>(), j[2].get<float>()};
        }
        static void to_json(json& j, const NodeUpdatePack<T>& data) {
            j = json::array({data.id, data.updated_data, data.updated_weight});
        }
    };
}
 
namespace fpmas { namespace io { namespace datapack {
    using fpmas::synchro::DataUpdatePack;
    using fpmas::synchro::NodeUpdatePack;
 
    template<typename T>
        struct Serializer<DataUpdatePack<T>> {
            static std::size_t size(const ObjectPack& pack, const DataUpdatePack<T>& data) {
                return pack.size(data.id) + pack.size(data.updated_data);
            }
 
            static void to_datapack(ObjectPack& pack, const DataUpdatePack<T>& data) {
                pack.put(data.id);
                pack.put(data.updated_data);
            }
 
            static DataUpdatePack<T> from_datapack(const ObjectPack& pack) {
                DistributedId id = pack.get<DistributedId>();
                T data = pack.get<T>();
                return {std::move(id), std::move(data)};
            }
        };
 
    template<typename T>
        struct Serializer<NodeUpdatePack<T>> {
            static std::size_t size(const ObjectPack& pack, const NodeUpdatePack<T>& data) {
                return pack.size<DistributedId>() + pack.size(data.updated_data)
                    + pack.size<float>();
            }
 
            static void to_datapack(ObjectPack& pack, const NodeUpdatePack<T>& data) {
                pack.put(data.id);
                pack.put(data.updated_data);
                pack.put(data.updated_weight);
            }
 
            static NodeUpdatePack<T> from_datapack(const ObjectPack& pack) {
                return {
                    pack.get<DistributedId>(),
                    pack.get<T>(),
                    pack.get<float>()
                };
            }
        };
}}}
#endif