Planning.hpp

Go to the documentation of this file.

#ifndef PDDL_PLANNER_H
#define PDDL_PLANNER_H

#include <string>
#include <stdexcept>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <pddl_planner/representation/Problem.hpp>
#include <pddl_planner/PDDLPlannerTypes.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread.hpp>

#define TIMEOUT 7.

namespace pddl_planner
{
    class PDDLPlannerInterface;
    typedef std::string PlannerName;
    typedef std::map<std::string, std::string> ActionDescriptions;
    typedef std::map<std::string, std::string> DomainDescriptions;
    typedef std::map<std::string, PDDLPlannerInterface*> PlannerMap;
    typedef std::vector<PDDLPlannerInterface*> PlannerList;
    typedef std::pair<PlannerName, PlanCandidates> PlanResult;
    typedef std::vector< PlanResult > PlanResultList;

    class Planning
    {

    public:
        Planning();

        ~Planning();

        
        PlannerMap getPlanners() const { return mPlanners; }
        
        std::set<std::string> getAvailablePlanners() const;
        
        void registerPlanner(PDDLPlannerInterface* planner);

        PlannerList getRegisteredPlanners() const;

        bool isRegistered(const std::string& name) const { return mPlanners.count(name); }

        PDDLPlannerInterface* getPlanner(const std::string& name) const;

        void setActionDescription(const std::string& action, const std::string& description);

        void setDomainDescription(const std::string& domain, const std::string& description);

        std::string getDomainDescriptions() const;

        std::string getActionDescriptions() const;

        PlanResultList plan(const std::string& problem, const std::set<std::string>& planners, bool sequential = false, double timeout = TIMEOUT);

        PlanCandidates plan(const std::string& problem, const std::string& plannerName = "LAMA", double timeout = TIMEOUT);

        PlanResultList plan(const representation::Problem& problem, const std::set<std::string>& planners, bool sequential = false, double timeout = TIMEOUT);

        PlanResultList plan(const representation::Domain& domain, const representation::Problem& problem, const std::set<std::string>& planners, bool sequential = false, double timeout = TIMEOUT);

        PlanCandidates plan(const representation::Problem& problem, const std::string& plannerName = "LAMA", double timeout = TIMEOUT);

        PlanCandidates plan(const representation::Domain& domain, const representation::Problem& problem, const std::string& plannerName = "LAMA", double timeout = TIMEOUT);

    private:
        PlannerMap mPlanners;
        ActionDescriptions mActionDescriptions;
        DomainDescriptions mDomainDescriptions;
        std::vector<boost::thread *> mPlanRunners;
    public:
        PlanResultList     mPlanResultList;
        boost::mutex  mResultMutex;
        boost::mutex mPlannerMutex;
    };


}
#endif // PDDL_PLANNER_H