cell.h

Go to the documentation of this file.

#pragma once
 
#include "config.h"
#include "interactions.h"
 
using namespace fpmas::model;
 
class MetaCell {
    public:
        static float cell_edge_weight;
 
    private:
        float utility;
        std::vector<char> data;
 
    public:
        // For edge migration optimization purpose only
 
        MetaCell() = default;
 
        // For JSON serialization
 
        MetaCell(float utility, std::size_t cell_size)
            : MetaCell(utility, std::vector<char>(cell_size)) {
            }
        
        MetaCell(float utility, const std::vector<char>& data)
            : utility(utility), data(data) {
            }
 
        float getUtility() const {
            return utility;
        }
        const std::vector<char>& getData() const {
            return data;
        }
 
        void update_edge_weights();
 
        virtual void read_all_cell() = 0;
        virtual void read_one_cell() = 0;
        virtual void write_all_cell() = 0;
        virtual void write_one_cell() = 0;
        virtual void read_all_write_one_cell() = 0;
        virtual void read_all_write_all_cell() = 0;
 
        virtual const fpmas::api::model::AgentNode* cellNode() const = 0;
};
 
template<typename CellType>
struct CellSerialization {
    static void to_json(nlohmann::json &j, const CellType *cell) {
        j = {cell->getUtility(), cell->getData()};
    }
 
    static CellType* from_json(const nlohmann::json& j) {
        return new CellType(j[0].get<float>(), j[1].get<std::vector<char>>());
    }
 
    static std::size_t size(
            const fpmas::io::datapack::ObjectPack &o, const CellType *cell) {
        return o.size<float>() + o.size(cell->getData());
    }
 
    static void to_datapack(
            fpmas::io::datapack::ObjectPack &o, const CellType *cell) {
        o.put(cell->getUtility());
        o.put(cell->getData());
    }
 
    static CellType* from_datapack(const fpmas::io::datapack::ObjectPack& o) {
        float utility = o.get<float>();
        std::vector<char> data = o.get<std::vector<char>>();
        return new CellType(utility, data);
    }
};
 
#define IMPLEM_CELL_INTERACTION(INTERACTION, CELL_TYPE)\
    void INTERACTION##_cell() override {\
        auto neighbors = this->outNeighbors<fpmas::api::model::Agent>(fpmas::api::model::CELL_SUCCESSOR);\
        ReaderWriter::INTERACTION(neighbors);\
    }
 
#define IMPLEM_CELL_INTERACTIONS(CELL_TYPE)\
    IMPLEM_CELL_INTERACTION(read_all, CELL_TYPE)\
    IMPLEM_CELL_INTERACTION(read_one, CELL_TYPE)\
    IMPLEM_CELL_INTERACTION(write_all, CELL_TYPE)\
    IMPLEM_CELL_INTERACTION(write_one, CELL_TYPE)\
    IMPLEM_CELL_INTERACTION(read_all_write_one, CELL_TYPE)\
    IMPLEM_CELL_INTERACTION(read_all_write_all, CELL_TYPE)
 
class MetaGridCell :
    public MetaCell,
    public GridCellBase<MetaGridCell>,
    public CellSerialization<MetaGridCell> {
    public:
        // For edge migration optimization purpose only
        using MetaCell::MetaCell;
 
        // For cell factory
 
        MetaGridCell(DiscretePoint location, float utility, const std::vector<char>& data)
            : GridCellBase<MetaGridCell>(location), MetaCell(utility, data) {
            }
        MetaGridCell(DiscretePoint location, float utility, std::size_t cell_size)
            : MetaGridCell(location, utility, std::vector<char>(cell_size)) {
            }
 
        const fpmas::api::model::AgentNode* cellNode() const override {
            return this->GridCellBase<MetaGridCell>::node();
        }
 
        IMPLEM_CELL_INTERACTIONS(MetaGridCell);
};
 
class MetaGraphCell :
    public MetaCell,
    public GraphCellBase<MetaGraphCell>,
    public CellSerialization<MetaGraphCell> {
        public:
            // For edge migration optimization purpose only
            using MetaCell::MetaCell;
 
            // For cell factory
 
            MetaGraphCell(float utility, const std::vector<char>& data)
                : GraphCellBase<MetaGraphCell>(), MetaCell(utility, data) {
                }
 
            MetaGraphCell(float utility, std::size_t cell_size)
                : MetaGraphCell(utility, std::vector<char>(cell_size)) {
                }
 
            const fpmas::api::model::AgentNode* cellNode() const override {
                return this->GraphCellBase<MetaGraphCell>::node();
            }
 
            IMPLEM_CELL_INTERACTIONS(MetaGraphCell);
    };
 
struct UtilityFunction {
    virtual float utility(GridAttractor attractor, DiscretePoint point) const = 0;
 
    virtual ~UtilityFunction() {
    }
};
 
struct UniformUtility : public UtilityFunction {
    float utility(GridAttractor attractor, DiscretePoint point) const override;
};
 
struct LinearUtility : public UtilityFunction {
    float utility(GridAttractor attractor, DiscretePoint point) const override;
};
 
class InverseUtility : public UtilityFunction {
    private:
        float offset;
 
    public:
        InverseUtility() : InverseUtility(0.f) {
        }
 
        InverseUtility(float offset) : offset(offset) {
        }
 
        float utility(GridAttractor attractor, DiscretePoint point) const override;
};
 
struct StepUtility : public UtilityFunction {
    float utility(GridAttractor attractor, DiscretePoint point) const override;
};
 
class MetaGridCellFactory : public fpmas::api::model::GridCellFactory<MetaGridCell> {
    private:
        const UtilityFunction& utility_function;
        std::vector<GridAttractor> attractors;
        std::size_t cell_size;
 
    public:
        MetaGridCellFactory(
                const UtilityFunction& utility_function,
                std::vector<GridAttractor> attractors,
                std::size_t cell_size) :
            utility_function(utility_function), attractors(attractors),
            cell_size(cell_size) {
        }
 
        MetaGridCell* build(DiscretePoint location) override;
};
 
class MetaGraphCellFactory {
    private:
        std::size_t cell_size;
    public:
        MetaGraphCellFactory(std::size_t cell_size)
            : cell_size(cell_size) {
            }
 
        MetaGraphCell* operator()();
};