graph.h

Go to the documentation of this file.

#ifndef FPMAS_MODEL_SPATIAL_GRAPH_H
#define FPMAS_MODEL_SPATIAL_GRAPH_H
 
#include "spatial_model.h"
 
namespace fpmas { namespace model {
 
    class ReachableCell {
        friend nlohmann::adl_serializer<ReachableCell>;
        friend io::datapack::Serializer<ReachableCell>;
 
        protected:
            std::set<DistributedId> reachable_cells;
 
        public:
 
            const std::set<DistributedId>& reachableCells() const {
                return reachable_cells;
            }
 
            void addReachableCell(DistributedId id) {
                reachable_cells.insert(id);
            }
 
            void removeReachableCell(DistributedId id) {
                reachable_cells.erase(id);
            }
 
            void clearReachableCells() {
                reachable_cells.clear();
            }
    };
 
    template<typename GraphCellType, typename Derived = GraphCellType>
        class GraphCellBase :
            public CellBase<api::model::Cell, GraphCellType, GraphCellBase<GraphCellType, Derived>>,
            public ReachableCell {
                public:
                typedef GraphCellBase<GraphCellType, Derived> JsonBase;
            };
 
    struct GraphCell final : public GraphCellBase<GraphCell> {
        using GraphCellBase<GraphCell>::GraphCellBase;
    };
 
    /*
     * TODO: How to avoid synchronize()?
     * Event listeners might be added to GraphCells to automatically update the
     * `reachable_cells` list when a GraphCell is linked / unlinked on the
     * CELL_SUCCESSOR layer. However, such event handling is not yet supported
     * by FPMAS 1.1.
     */
    template<typename GraphCellType = GraphCell>
        class GraphRange : public api::model::Range<GraphCellType> {
            static_assert(
                    std::is_base_of<api::model::Cell, GraphCellType>::value,
                    "The specified GraphCellType must implement api::model::Cell."
                    );
            static_assert(
                    std::is_base_of<ReachableCell, GraphCellType>::value,
                    "The specified GraphCellType must extend ReachableCell"
                    );
            private:
                bool include_location;
            public:
                GraphRange(bool include_location = INCLUDE_LOCATION) : include_location(include_location) {
                }
 
                std::size_t radius(GraphCellType*) const override {
                    return 1;
                }
 
                bool contains(GraphCellType* root, GraphCellType* cell) const override {
                    if(include_location && root->node()->getId() == cell->node()->getId())
                        return true;
                    return root->reachableCells().count(cell->node()->getId()) > 0;
                }
 
                static void synchronize(api::model::SpatialModel<GraphCellType>& model) {
                    for(auto cell : model.cellGroup().localAgents()) {
                        auto graph_cell = dynamic_cast<ReachableCell*>(cell);
                        graph_cell->clearReachableCells();
                        for(auto neighbor : cell->node()->outNeighbors(api::model::CELL_SUCCESSOR))
                            graph_cell->addReachableCell(neighbor->getId());
                    }
                    model.graph().synchronize();
                }
 
        };
}}
 
FPMAS_DEFAULT_JSON(fpmas::model::GraphCell)
FPMAS_DEFAULT_DATAPACK(fpmas::model::GraphCell)
 
namespace nlohmann {
    template<>
        struct adl_serializer<fpmas::model::ReachableCell> {
            static void to_json(nlohmann::json& j, const fpmas::model::ReachableCell& cell);
            static void from_json(const nlohmann::json& j, fpmas::model::ReachableCell& cell);
        };
 
    template<typename AgentType, typename Derived>
        struct adl_serializer<fpmas::api::utils::PtrWrapper<fpmas::model::GraphCellBase<AgentType, Derived>>> {
            typedef fpmas::api::utils::PtrWrapper<fpmas::model::GraphCellBase<AgentType, Derived>> Ptr;
            static void to_json(nlohmann::json& j, const Ptr& ptr) {
                // Derived serialization
                j[0] = fpmas::api::utils::PtrWrapper<Derived>(
                        const_cast<Derived*>(dynamic_cast<const Derived*>(ptr.get())));
                j[1] = static_cast<const fpmas::model::ReachableCell&>(*ptr);
            }
 
            static Ptr from_json(const nlohmann::json& j) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                fpmas::api::utils::PtrWrapper<Derived> derived_ptr
                    = j[0].get<fpmas::api::utils::PtrWrapper<Derived>>();
                static_cast<fpmas::model::ReachableCell&>(*derived_ptr)
                    = j[1].get<fpmas::model::ReachableCell>();
                //derived_ptr->reachable_nodes = j[1].get<std::set<fpmas::api::graph::DistributedId>>();
                return derived_ptr.get();
            }
        };
}
 
namespace fpmas { namespace io { namespace json {
    template<typename AgentType, typename Derived>
        struct light_serializer<PtrWrapper<fpmas::model::GraphCellBase<AgentType, Derived>>> {
            typedef PtrWrapper<fpmas::model::GraphCellBase<AgentType, Derived>> Ptr;
            
            static void to_json(light_json& j, const Ptr& agent) {
                // Derived serialization
                light_serializer<PtrWrapper<Derived>>::to_json(
                        j,
                        const_cast<Derived*>(dynamic_cast<const Derived*>(agent.get()))
                        );
            }
 
            static Ptr from_json(const light_json& j) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                PtrWrapper<Derived> derived_ptr
                    = light_serializer<PtrWrapper<Derived>>::from_json(j);
                return derived_ptr.get();
            }
        };
 
}}}
 
namespace fpmas { namespace io { namespace datapack {
    template<>
        struct Serializer<model::ReachableCell> {
            static std::size_t size(
                    const ObjectPack& p, const model::ReachableCell& cell);
 
            static void to_datapack(
                    ObjectPack& pack, const model::ReachableCell& cell);
 
            static model::ReachableCell from_datapack(
                    const ObjectPack& pack);
        };
 
    template<typename GraphCellType, typename Derived>
        struct Serializer<PtrWrapper<fpmas::model::GraphCellBase<GraphCellType, Derived>>> {
            typedef PtrWrapper<fpmas::model::GraphCellBase<GraphCellType, Derived>> Ptr;
 
            static std::size_t size(const ObjectPack& p, const Ptr& ptr) {
                return p.size(PtrWrapper<Derived>(
                        const_cast<Derived*>(dynamic_cast<const Derived*>(ptr.get()))))
                    + p.size(static_cast<const fpmas::model::ReachableCell&>(*ptr));
            }
 
            static void to_datapack(ObjectPack& pack, const Ptr& ptr) {
                // Derived serialization
                PtrWrapper<Derived> derived = PtrWrapper<Derived>(
                        const_cast<Derived*>(dynamic_cast<const Derived*>(ptr.get())));
                const fpmas::model::ReachableCell& reachable_cell
                    = static_cast<const fpmas::model::ReachableCell&>(*ptr);
                pack.put(derived);
                pack.put(reachable_cell);
            }
 
            static Ptr from_datapack(const ObjectPack& pack) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                PtrWrapper<Derived> derived_ptr = pack
                    .get<PtrWrapper<Derived>>();
 
                // ReachableCell unserialization into derived_ptr
                static_cast<fpmas::model::ReachableCell&>(*derived_ptr)
                    = pack.get<fpmas::model::ReachableCell>();
 
                return derived_ptr.get();
            }
        };
 
 
    template<typename GraphCellType, typename Derived>
        struct LightSerializer<PtrWrapper<fpmas::model::GraphCellBase<GraphCellType, Derived>>> {
            typedef PtrWrapper<fpmas::model::GraphCellBase<GraphCellType, Derived>> Ptr;
 
            static std::size_t size(const LightObjectPack& pack, const Ptr& ptr) {
                return pack.size(PtrWrapper<Derived>(
                            const_cast<Derived*>(dynamic_cast<const Derived*>(ptr.get()))
                            ));
            }
 
            static void to_datapack(LightObjectPack& pack, const Ptr& ptr) {
                // Derived serialization
                LightSerializer<PtrWrapper<Derived>>::to_datapack(
                        pack,
                        const_cast<Derived*>(dynamic_cast<const Derived*>(ptr.get()))
                        );
            }
 
            static Ptr from_datapack(const LightObjectPack& pack) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                PtrWrapper<Derived> derived_ptr
                    = LightSerializer<PtrWrapper<Derived>>::from_datapack(pack);
                return derived_ptr.get();
            }
        };
}}}
#endif