spatial_model.h

Go to the documentation of this file.

#ifndef FPMAS_ENVIRONMENT_API_H
#define FPMAS_ENVIRONMENT_API_H
 
#include "../model.h"
 
namespace fpmas { namespace api { namespace model {
 
    enum SpatialModelLayers : fpmas::api::graph::LayerId {
        CELL_SUCCESSOR = -1,
        LOCATION = -2,
        MOVE = -3,
        PERCEIVE = -4,
        PERCEPTION = -5,
        NEW_LOCATION = -6,
        NEW_MOVE = -7,
        NEW_PERCEIVE = -8
    };
 
    class CellBehavior {
        public:
            virtual void init() = 0;
            virtual void handleNewLocation() = 0;
            virtual void handleMove() = 0;
            virtual void handlePerceive() = 0;
 
            virtual void updatePerceptions(AgentGroup& group) = 0;
 
            virtual ~CellBehavior() {}
    };
 
    class Cell : public Agent, public CellBehavior {
        public:
            virtual std::vector<Cell*> successors() = 0;
 
            virtual ~Cell() {}
    };
 
    template<typename CellType>
        class Range {
            public:
                virtual bool contains(CellType* root, CellType* cell) const = 0;
 
                virtual std::size_t radius(CellType* origin) const = 0;
 
                virtual ~Range() {}
        };
 
    class SpatialAgentBehavior {
        public:
            virtual void handleNewMove() = 0;
 
            virtual void handleNewPerceive() = 0;
 
            virtual ~SpatialAgentBehavior() {}
    };
 
    template<typename CellType>
    class SpatialAgent : public Agent, public SpatialAgentBehavior {
        public:
            static_assert(std::is_base_of<api::model::Cell, CellType>::value,
                    "CellType must extend api::model::Cell");
            typedef CellType Cell;
 
            
            virtual DistributedId locationId() const = 0;
 
            virtual CellType* locationCell() const = 0;
 
            virtual void initLocation(Cell* cell) = 0;
 
            virtual const Range<CellType>& mobilityRange() const = 0;
 
            virtual const Range<CellType>& perceptionRange() const = 0;
 
        protected:
            virtual void moveTo(DistributedId id) = 0;
 
            virtual void moveTo(Cell* cell) = 0;
    };
 
    template<typename CellType>
        class EndCondition {
            public:
                virtual void init(
                        api::communication::MpiCommunicator& comm,
                        std::vector<api::model::SpatialAgent<CellType>*> agents,
                        std::vector<CellType*> cells) = 0;
 
                virtual void step() = 0;
                virtual bool end() = 0;
 
                virtual ~EndCondition() {};
        };
 
    template<typename CellType> class SpatialModel;
 
 
    template<typename CellType>
    class DistributedMoveAlgorithm {
        public:
            virtual api::scheduler::JobList jobs() const = 0;
 
            virtual ~DistributedMoveAlgorithm() {}
    };
 
    template<typename CellType>
        class MoveAgentGroup : public virtual AgentGroup {
            public:
                virtual DistributedMoveAlgorithm<CellType>& distributedMoveAlgorithm() = 0;
        };
 
    template<typename _CellType>
    class SpatialModel : public virtual Model {
        public:
            typedef _CellType CellType;
 
            virtual void add(CellType* cell) = 0;
 
            virtual std::vector<CellType*> cells() = 0;
 
            virtual AgentGroup& cellGroup() = 0;
 
            virtual const AgentGroup& cellGroup() const = 0;
 
            virtual MoveAgentGroup<CellType>& buildMoveGroup(GroupId id, const Behavior& behavior) = 0;
 
            virtual ~SpatialModel() {}
    };
 
    template<typename CellType>
    class CellNetworkBuilder {
        public:
            virtual std::vector<CellType*> build(
                    SpatialModel<CellType>& spatial_model
                    ) const = 0;
 
            virtual std::vector<CellType*> build(
                    SpatialModel<CellType>& spatial_model,
                    GroupList groups
                    ) const = 0;
 
            virtual ~CellNetworkBuilder() {}
    };
 
    template<typename CellType>
    class SpatialAgentFactory {
        public:
            virtual SpatialAgent<CellType>* build() = 0;
 
            virtual ~SpatialAgentFactory() {}
    };
 
    template<typename CellType>
    class SpatialAgentMapping {
        public:
            virtual std::size_t countAt(CellType* cell) = 0;
 
            virtual ~SpatialAgentMapping() {}
    };
 
    template<typename CellType, typename MappingCellType>
    class SpatialAgentBuilder {
        static_assert(
                std::is_base_of<MappingCellType, CellType>::value,
                "MappingCellType must be a base of CellType"
                );
        public:
            virtual void build(
                    SpatialModel<CellType>& model,
                    GroupList groups,
                    SpatialAgentFactory<CellType>& factory,
                    SpatialAgentMapping<MappingCellType>& agent_mapping
                    ) = 0;
 
            virtual void build(
                    SpatialModel<CellType>& model,
                    GroupList groups,
                    std::function<SpatialAgent<CellType>*()> factory,
                    SpatialAgentMapping<MappingCellType>& agent_mapping
                    ) = 0;
 
            virtual ~SpatialAgentBuilder() {}
    };
 
}}}
#endif