taskManager.hpp

#ifndef TASKMANAGER_HPP
#define TASKMANAGER_HPP

//using namespace tr1;

#include "GTPTools/worldState.hpp"
#include "GTPTools/solutionTools/gtpPlan.hpp"
#include "GTP/GTPTools/geometricTools/geometricComputations.hpp"
#include "GTP/GTPTools/geometricTools/geometricForms-pkg.hpp"
#include "GTP/GTPTools/solutionTools/taskSolution.hpp"
#include "GTP/GTPTools/solutionTools/taskSubSolution.hpp"
#include "Tasks/task.hpp"
#include "Tasks/task-pkg.hpp"
#include "GTPTools/taskConstraints.hpp"




class TaskManager
{
    MOVE3D_STATIC_LOGGER;
public:
    TaskManager();
    ~TaskManager();
    void init();

    PlanNode *computeTask(TasksId task,
                    std::multimap<std::string,std::string> agents_name,
                    std::multimap<std::string,std::string> objects_name,
                    std::multimap<std::string, p3d_point> point3d,
                    std::multimap<std::string, std::string> additionalData,
                    WorldState *WC, bool computeMP, TaskConstraints *taskConst);

    double computeTaskHeuristic(TasksId taskId,
                    std::multimap<std::string,std::string> agents_name,
                    std::multimap<std::string,std::string> objects_name,
                    std::multimap<std::string, p3d_point> point3d,
                    std::multimap<std::string, std::string> additionalData,
                    WorldState *WC, bool computeMP, TaskConstraints *taskConst);

    PlanNode *findTaskAlternative(int taskId, bool computeMP);

    Task* createTask(TasksId task);
    Task* createHumanTask(TasksId taskId);

    bool computeTrajInTasks(int taskId, int alternativeId);

    Task* getTask(int id);

    bool setArm(armLabel a);

    void clearTasks();

    int addWorldState(WorldState* WC);
    WorldState* getWorldStateById(int id);
    WorldState* popWorldStateWithId(int id);
    void clearWorldStates();

    TasksId getTaskIdFromString(std::string value);
    TasksId getTaskIdFromString(char* value);


    bool forceArmChoice;

    PlanTree* getPlanTree() {return _PT;}
    OnePlan* getOnePlan() {return _OP;}

    void printAllTasks(bool verbose);
    void printOnePlan(bool verbose);
    std::string printAllTextNeeded();

    std::vector<Task*> getTaskList() { return task_list;}
    void addTask(Task* t) {task_list.push_back(t);}

    void printTd(type_data td);

    void setCurrentId(int t){current_id = t;}

    void setRequestToSolutionData(Task *t,
                                  std::multimap<std::string,std::string> agents_name,
                                  std::multimap<std::string,std::string> objects_name,
                                  std::multimap<std::string, p3d_point> point3d,
                                  std::multimap<std::string, std::string> additionalData,
                                  TaskConstraints *);

private:
    armLabel arm_l;

    int current_id;
    std::vector<Task*> task_list;
    std::vector<WorldState*> worldState_list;

    int current_worldState_id;

    PlanTree* _PT;
    OnePlan* _OP;

};

#endif // TASKMANAGER_HPP