distributed_node.h

Go to the documentation of this file.

#ifndef FPMAS_DISTRIBUTED_NODE_H
#define FPMAS_DISTRIBUTED_NODE_H
 
#include "fpmas/api/graph/distributed_node.h"
#include "fpmas/api/utils/ptr_wrapper.h"
#include "fpmas/graph/node.h"
#include "fpmas/io/json.h"
#include "fpmas/io/datapack.h"
 
namespace fpmas { namespace graph {
 
    using api::graph::LocationState;
    using api::graph::DistributedId;
 
    template<typename T>
    class DistributedNode :
        public Node<DistributedId, api::graph::DistributedEdge<T>>,
        public api::graph::DistributedNode<T> {
            typedef graph::Node<DistributedId, api::graph::DistributedEdge<T>> NodeBase;
            typedef api::synchro::Mutex<T> Mutex;
 
        private:
            LocationState _state = LocationState::LOCAL;
            int _location;
            T _data;
            Mutex* _mutex = nullptr;
 
        public:
            DistributedNode(const DistributedId& id, const T& data)
                : NodeBase(id), _data(data) {
            }
 
            DistributedNode(const DistributedId& id, T&& data)
                : NodeBase(id), _data(std::move(data)) {
            }
 
            int location() const override {return _location;}
            void setLocation(int location) override {this->_location = location;}
 
            api::graph::LocationState state() const override {return _state;}
            void setState(api::graph::LocationState state) override {this->_state=state;}
 
 
            T& data() override {return _data;}
            const T& data() const override {return _data;}
            void setMutex(Mutex* mutex) override {_mutex=mutex;}
            Mutex* mutex() override {return _mutex;}
            const Mutex* mutex() const override {return _mutex;}
 
            ~DistributedNode() {
                if(_mutex!=nullptr)
                    delete _mutex;
            }
    };
 
    template<typename T>
    using NodePtrWrapper = api::utils::PtrWrapper<api::graph::DistributedNode<T>>;
}}
 
namespace nlohmann {
    using fpmas::graph::NodePtrWrapper;
 
    template<typename T>
        struct adl_serializer<NodePtrWrapper<T>> {
            static void to_json(json& j, const NodePtrWrapper<T>& node) {
                j["id"] = node->getId();
                j["data"] = node->data();
                j["weight"] = node->getWeight();
            }
 
            static NodePtrWrapper<T> from_json(const json& j) {
                auto node = new fpmas::graph::DistributedNode<T> {
                    j.at("id").get<DistributedId>(),
                    std::move(j.at("data").get<T>())
                };
                node->setWeight(j.at("weight").get<float>());
                return node;
            }
        };
}
 
namespace fpmas { namespace io {
    namespace json {
        using fpmas::graph::NodePtrWrapper;
 
        template<typename T>
            struct light_serializer<NodePtrWrapper<T>> {
                static void to_json(light_json& j, const NodePtrWrapper<T>& node) {
                    j["id"] = node->getId();
                    j["data"] = node->data();
                }
                static void from_json(const light_json& j, NodePtrWrapper<T>& node_ptr) {
                    node_ptr = {new fpmas::graph::DistributedNode<T>(
                            j["id"].get<fpmas::graph::DistributedId>(),
                            j["data"].get<T>()
                            )};
                }
            };
    }
 
    namespace datapack {
        using fpmas::graph::NodePtrWrapper;
 
        template<typename T>
            struct Serializer<NodePtrWrapper<T>> {
                static std::size_t size(
                        const ObjectPack& p, const NodePtrWrapper<T>& node) {
                    return p.size<DistributedId>() + p.size(node->data())
                        + p.size<float>();
                }
                static void to_datapack(ObjectPack& pack, const NodePtrWrapper<T>& node) {
                    pack.put(node->getId());
                    pack.put(node->data());
                    pack.put(node->getWeight());
                }
 
                static NodePtrWrapper<T> from_datapack(const ObjectPack& pack) {
                    DistributedId id = pack.get<DistributedId>();
                    T data = pack.get<T>();
                    auto node = new fpmas::graph::DistributedNode<T>(
                            std::move(id), std::move(data)
                            );
                    node->setWeight(pack.get<float>());
                    return node;
                }
            };
 
        template<typename T>
            struct LightSerializer<NodePtrWrapper<T>> {
                static std::size_t size(
                        const LightObjectPack& p, const NodePtrWrapper<T>& node) {
                    return p.size<DistributedId>() + p.size(node->data());
                }
 
                static void to_datapack(LightObjectPack& pack, const NodePtrWrapper<T>& node) {
                    pack.put(node->getId());
                    pack.put(node->data());
                }
 
                static NodePtrWrapper<T> from_datapack(const LightObjectPack& pack) {
                    // Call order guaranteed, DO NOT CALL gets FROM THE CONSTRUCTOR
                    DistributedId id = pack.get<DistributedId>();
                    T data = pack.get<T>();
                    auto node = new fpmas::graph::DistributedNode<T>(
                            std::move(id), std::move(data)
                            );
                    return node;
                }
            };
    }
}}
#endif