MPProblem.h

Go to the documentation of this file.

#ifndef MP_PROBLEM_H_
#define MP_PROBLEM_H_
 
#include <iostream>
#include <list>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "ConfigurationSpace/Cfg.h"
//class Cfg;
class Decomposition;
class DynamicObstacle;
class InteractionInformation;
class Environment;
class MPTask;
class GroupTask;
class MultiBody;
class Robot;
class RobotGroup;
class XMLNode;
 
 
#ifdef _PARALLEL
class MPProblem : public stapl::p_object
#else
class MPProblem 
#endif
{
 
  public:
 
 
    MPProblem();
 
    explicit MPProblem(const std::string& _filename);
 
    explicit MPProblem(XMLNode _mpNode, XMLNode _input);
 
    MPProblem(const MPProblem& _other); 
    MPProblem(MPProblem&& _other) = delete;
 
    virtual ~MPProblem();
 
 
    MPProblem& operator=(const MPProblem& _other); 
    MPProblem& operator=(MPProblem&& _other) = delete;
 
 
    const std::string& GetXMLFilename() const;
 
    void ReadXMLFile(const std::string& _filename);
 
    void ProcessXML(XMLNode mpNode, XMLNode input);
 
 
    Environment* GetEnvironment();
 
    void SetEnvironment(std::unique_ptr<Environment>&& _e);
 
 
    size_t NumRobots() const noexcept;
 
    Robot* GetRobot(const size_t _index) const noexcept;
 
    Robot* GetRobot(const std::string& _label) const noexcept;
 
    const std::vector<std::unique_ptr<Robot>>& GetRobots() const noexcept;
 
    const std::vector<Robot*> GetRobotsOfType(std::string _type) const noexcept;
 
    size_t NumRobotGroups() const noexcept;
 
    RobotGroup* GetRobotGroup(const size_t _index) const noexcept;
 
    RobotGroup* GetRobotGroup(const std::string& _label) const noexcept;
 
    const std::vector<std::unique_ptr<RobotGroup>>& GetRobotGroups() const noexcept;
 
        Cfg GetInitialCfg(Robot* _r);
 
        void SetInitialCfg(Robot* _r, Cfg _cfg);
 
 
    MPTask* GetTask(std::string _label);
 
    std::vector<std::shared_ptr<MPTask>> GetTasks(Robot* const _robot) const
        noexcept;
 
    std::vector<std::shared_ptr<GroupTask>> GetTasks(RobotGroup* const _group)
        const noexcept;
 
    void AddTask(std::unique_ptr<MPTask>&& _task);
 
    void ReassignTask(MPTask* const _task, Robot* const _newOwner);
 
        void AddDecomposition(Robot* _coordinator, std::unique_ptr<Decomposition>&& _decomp);
 
        const std::vector<std::unique_ptr<Decomposition>>& GetDecompositions(Robot* _coordinator);
 
        const std::unordered_map<Robot*,std::vector<std::unique_ptr<Decomposition>>>& 
                                                        GetDecompositions();
 
 
    const std::vector<DynamicObstacle>& GetDynamicObstacles() const noexcept;
 
    void AddDynamicObstacle(DynamicObstacle&& _obstacle);
 
    void ClearDynamicObstacles();
 
 
    virtual void Print(std::ostream& _os) const;
 
 
    const std::string& GetBaseFilename() const;
 
    void SetBaseFilename(const std::string& _s);
 
    std::string GetPath(const std::string& _filename = "");
 
    void SetPath(const std::string& _filename);
 
 
 
    std::vector<std::unique_ptr<InteractionInformation>>&
        GetInteractionInformations();
 
 
  protected:
 
 
    void ParseChild(XMLNode& _node);
 
    void MakePointRobot();
 
 
    std::unique_ptr<Environment> m_environment;    
 
    std::vector<std::unique_ptr<Robot>> m_robots;  
    std::vector<std::unique_ptr<RobotGroup>> m_robotGroups; 
    std::unique_ptr<Robot> m_pointRobot;           
  
    std::unordered_map<std::string,std::vector<Robot*>> m_robotCapabilityMap;
 
        std::unordered_map<Robot*,Cfg> m_initialCfgs;  
 
    std::vector<DynamicObstacle> m_dynamicObstacles;
 
    std::vector<std::unique_ptr<InteractionInformation>> m_interactionInformations;
 
    std::unordered_map<Robot*, std::list<std::shared_ptr<MPTask>>> m_taskMap;
    std::unordered_map<RobotGroup*, std::list<std::shared_ptr<GroupTask>>>
        m_groupTaskMap;
 
    std::unordered_map<std::string, MPTask*> m_taskLabelMap;
        std::unordered_map<Robot*,std::vector<std::unique_ptr<Decomposition>>> m_taskDecompositions;
 
 
    std::string m_xmlFilename;   
    std::string m_baseFilename;  
    std::string m_filePath;      
 
 
};
 
#endif