model.h

Go to the documentation of this file.

#ifndef FPMAS_MODEL_API_H
#define FPMAS_MODEL_API_H
 
#include <typeindex>
#include <list>
#include <random>
 
#include "fpmas/api/graph/distributed_graph.h"
#include "fpmas/api/runtime/runtime.h"
#include "fpmas/api/utils/ptr_wrapper.h"
#include "fpmas/api/random/generator.h"
 
#ifndef FPMAS_AGENT_RNG
    #define FPMAS_AGENT_RNG minstd_rand
#endif
 
namespace fpmas { namespace api {namespace model {
    using api::graph::DistributedId;
 
    class Agent;
    class AgentTask;
    class AgentPtr;
 
    typedef api::graph::DistributedNode<AgentPtr> AgentNode;
    typedef api::graph::DistributedEdge<AgentPtr> AgentEdge;
 
    typedef api::graph::DistributedGraph<AgentPtr> AgentGraph;
 
    typedef api::graph::SetLocalNodeEvent<AgentPtr> SetAgentLocalEvent;
    typedef api::graph::DistributedGraph<AgentPtr>::SetLocalNodeCallback
        SetAgentLocalCallback;
    typedef api::graph::SetDistantNodeEvent<AgentPtr> SetAgentDistantEvent;
    typedef api::graph::DistributedGraph<AgentPtr>::SetDistantNodeCallback
        SetAgentDistantCallback;
 
    typedef int GroupId;
    typedef std::type_index TypeId;
 
    class AgentPtr : public api::utils::PtrWrapper<api::model::Agent> {
        public:
            AgentPtr() : PtrWrapper() {}
            AgentPtr(api::model::Agent* agent)
                : PtrWrapper(agent) {}
 
            AgentPtr(AgentPtr&& other);
 
            AgentPtr(const AgentPtr& other);
 
            AgentPtr& operator=(AgentPtr&& other);
 
            AgentPtr& operator=(const AgentPtr&);
 
            ~AgentPtr();
    };
 
    typedef api::utils::PtrWrapper<api::model::Agent> WeakAgentPtr;
 
    class Model;
    class AgentGroup;
 
    class Agent {
        public:
            HEDLEY_DEPRECATED_FOR(1.1, groupIds())
            virtual GroupId groupId() const = 0;
 
            virtual std::vector<GroupId> groupIds() const = 0;
 
            HEDLEY_DEPRECATED_FOR(1.1, addGroupId())
            virtual void setGroupId(GroupId id) = 0;
 
            virtual void addGroupId(GroupId id) = 0;
 
            virtual void removeGroupId(GroupId id) = 0;
 
 
            HEDLEY_DEPRECATED_FOR(1.1, groups())
            virtual AgentGroup* group() = 0;
            HEDLEY_DEPRECATED_FOR(1.1, groups())
            virtual const AgentGroup* group() const = 0;
 
            virtual std::vector<AgentGroup*> groups() = 0;
 
            virtual std::vector<const AgentGroup*> groups() const = 0;
 
            HEDLEY_DEPRECATED_FOR(1.1, addGroup())
            virtual void setGroup(AgentGroup* group) = 0;
 
            virtual void addGroup(AgentGroup* group) = 0;
 
            virtual void removeGroup(AgentGroup* group) = 0;
 
            virtual void setGroupPos(
                    api::model::GroupId gid,
                    std::list<Agent*>::iterator pos
                    ) = 0;
 
            virtual std::list<Agent*>::iterator getGroupPos(api::model::GroupId gid) const = 0;
 
            virtual TypeId typeId() const = 0;
            virtual Agent* copy() const = 0;
 
            virtual void copyAssign(Agent* agent) = 0;
 
            virtual void moveAssign(Agent* agent) = 0;
 
            virtual AgentNode* node() = 0;
            virtual const AgentNode* node() const = 0;
            virtual void setNode(AgentNode* node) = 0;
 
            virtual Model* model() = 0;
            virtual const Model* model() const = 0;
            virtual void setModel(Model* model) = 0;
 
            HEDLEY_DEPRECATED_FOR(1.1, task(GroupId))
            virtual AgentTask* task() = 0; 
            HEDLEY_DEPRECATED_FOR(1.1, task(GroupId))
            virtual const AgentTask* task() const = 0; 
            HEDLEY_DEPRECATED_FOR(1.1, setTask(GroupId, AgentTask*))
            virtual void setTask(AgentTask* task) = 0;
 
            virtual AgentTask* task(GroupId id) = 0;
            virtual const AgentTask* task(GroupId id) const = 0; 
 
            virtual void setTask(GroupId id, AgentTask* task) = 0;
 
            virtual const std::unordered_map<GroupId, AgentTask*>& tasks() = 0;
 
            virtual void act() = 0;
 
            virtual ~Agent(){}
    };
 
    class RandomAgent {
        public:
            virtual api::random::Generator<std::FPMAS_AGENT_RNG::result_type>& rd() = 0;
 
            virtual void seed(std::FPMAS_AGENT_RNG::result_type seed) = 0;
 
            virtual ~RandomAgent() {
            }
    };
 
    class AgentTask : public api::scheduler::NodeTask<AgentPtr> {
        public:
            virtual const AgentPtr& agent() const = 0;
            
            virtual ~AgentTask(){}
    };
 
    class Behavior {
        public:
            virtual void execute(Agent* agent) const = 0;
 
            virtual ~Behavior(){}
    };
 
    class AgentGroup {
        public:
            enum Event {
                INSERT,
                ERASE,
                ADD,
                REMOVE
            };
            virtual GroupId groupId() const = 0;
 
            virtual const Behavior& behavior() = 0;
 
            virtual void add(Agent* agent) = 0;
 
            virtual void remove(Agent* agent) = 0;
 
            virtual void clear() = 0;
 
            virtual void insert(AgentPtr* agent) = 0;
            virtual void erase(AgentPtr* agent) = 0;
 
            virtual std::vector<Agent*> agents() const = 0;
 
 
            virtual std::vector<Agent*> localAgents() const = 0;
 
            virtual std::vector<Agent*> distantAgents() const = 0;
 
            HEDLEY_DEPRECATED_FOR(1.1, jobs())
            virtual api::scheduler::Job& job() = 0;
 
            HEDLEY_DEPRECATED_FOR(1.1, jobs())
            virtual const api::scheduler::Job& job() const = 0;
 
            virtual api::scheduler::Job& agentExecutionJob() = 0;
 
            virtual const api::scheduler::Job& agentExecutionJob() const = 0;
 
            virtual api::scheduler::JobList jobs() const = 0;
 
            virtual void addEventHandler(
                    Event event, api::utils::Callback<Agent*>* callback
                    ) = 0;
            virtual void removeEventHandler(
                    Event event, api::utils::Callback<Agent*>* callback
                    ) = 0;
 
            virtual ~AgentGroup(){}
    };
 
    typedef std::vector<std::reference_wrapper<AgentGroup>> GroupList;
 
    class Model {
        protected:
            virtual void insert(GroupId id, AgentGroup* group) = 0;
 
        public:
            virtual AgentGraph& graph() = 0;
 
            virtual const AgentGraph& graph() const = 0;
 
            virtual api::scheduler::Scheduler& scheduler() = 0;
 
            virtual const api::scheduler::Scheduler& scheduler() const = 0;
 
            virtual api::runtime::Runtime& runtime() = 0;
 
            virtual const api::runtime::Runtime& runtime() const = 0;
 
            virtual const api::scheduler::Job& loadBalancingJob() const = 0;
 
            virtual AgentGroup& buildGroup(GroupId id) = 0;
 
            virtual AgentGroup& buildGroup(GroupId id, const Behavior& behavior) = 0;
 
            virtual void removeGroup(AgentGroup& group) = 0;
 
            virtual AgentGroup& getGroup(GroupId id) const = 0;
 
            virtual const std::unordered_map<GroupId, AgentGroup*>& groups() const = 0;
 
            virtual AgentEdge* link(Agent* src_agent, Agent* tgt_agent, api::graph::LayerId layer) = 0;
            virtual void unlink(AgentEdge* edge) = 0;
 
            virtual api::communication::MpiCommunicator& getMpiCommunicator() = 0;
 
            virtual const api::communication::MpiCommunicator& getMpiCommunicator() const = 0;
 
            virtual void clear() = 0;
        public:
            virtual ~Model(){}
    };
 
    using LoadBalancing = fpmas::api::graph::LoadBalancing<AgentPtr>;
}}}
#endif