SemanticTask.h

Go to the documentation of this file.

#ifndef PPL_SEMANTIC_TASK_H_
#define PPL_SEMANTIC_TASK_H_
 
#include "MPProblem/GroupTask.h"
#include "MPProblem/MPTask.h"
 
#include <unordered_map>
#include <unordered_set>
 
class Decomposition;
class MPProblem;
 
class SemanticTask {
 
    public:
    
 
        enum SubtaskRelation {
            XOR, 
            AND 
        };
 
        enum DependencyType {
            Completion, 
            Initiation, 
            Synchronous, 
            Asynchronous, 
            None
        };
 
        typedef std::unordered_map<DependencyType, std::unordered_set<SemanticTask*>,
                                                             std::hash<int>> DependencyMap;
 
 
        SemanticTask();
 
        SemanticTask(MPProblem* _problem, XMLNode& _node, Decomposition* _decomp);
 
        SemanticTask(std::string _label, SemanticTask* _parent, Decomposition* _decomp,
                                 SubtaskRelation _relation, bool _decomposable, bool _fixedAssign, 
                                 std::shared_ptr<MPTask> _motionTask = nullptr);
 
        SemanticTask(std::string _label, SemanticTask* _parent, Decomposition* _decomp,
                                 SubtaskRelation _relation, bool _decomposable, bool _fixedAssign,
                                 std::shared_ptr<GroupTask> _groupMotionTask);
 
        SemanticTask(SemanticTask* _parent, Decomposition* _decomp, 
                 std::shared_ptr<MPTask> _motionTask, bool _decomposable=true);
 
        SemanticTask(SemanticTask* _parent, Decomposition* _decomp,
                 std::shared_ptr<GroupTask> _groupMotionTask, bool _decomposable=true);
 
        SemanticTask(std::string _label, SemanticTask* _parent, Decomposition* _decomp,
                                 std::shared_ptr<MPTask> _motionTask = nullptr, bool _decomposable=true);
 
        SemanticTask(std::string _label, SemanticTask* _parent, Decomposition* _decomp,
                                 std::shared_ptr<GroupTask> _groupMotionTask, bool _decomposable=true);
 
        ~SemanticTask();
 
 
        std::string GetLabel() const;
 
        std::vector<SemanticTask*> SetDependencies();
 
        bool IsDecomposable();
 
        void SetMotionTask(std::shared_ptr<MPTask> _motion);
 
        std::shared_ptr<MPTask> GetMotionTask();
 
        void SetGroupMotionTask(std::shared_ptr<GroupTask> _motion);
 
        std::shared_ptr<GroupTask> GetGroupMotionTask();
 
        SemanticTask* GetParent();
 
        void SetParent(SemanticTask* _parent);
 
        std::unordered_set<SemanticTask*> AddDependency(SemanticTask* _task, DependencyType _type);
 
        DependencyMap& GetDependencies();
 
        bool IsFixedAssignment();
 
        void AddSubtask(SemanticTask* _task);
 
        std::vector<SemanticTask*> GetSubtasks();
 
        SubtaskRelation GetSubtaskRelation();
 
 
    private:
 
        void ParseDependency(MPProblem* _problem, XMLNode& _node, Decomposition* _decomp);
 
 
        std::string m_label;
 
        SemanticTask* m_parent{nullptr};
 
        std::shared_ptr<MPTask> m_motionTask;
 
        std::shared_ptr<GroupTask>  m_groupMotionTask;
 
        bool m_fixedAssignment{false};
 
        bool m_decomposable{true};
 
        std::vector<SemanticTask*> m_subtasks;
 
        SubtaskRelation m_subtasksRelation;
 
        DependencyMap   m_dependencyMap;
        
};
 
#endif