pddl.h

 
#ifndef SYMBOLIC_PDDL_H_
#define SYMBOLIC_PDDL_H_
 
#include <iostream>       // std::cout, std::ostream
#include <memory>         // std::shared_ptr, std::weak_ptr
#include <set>            // std::set
#include <string>         // std::string
#include <unordered_map>  // std::unordered_map
#include <utility>        // std::pair
#include <vector>         // std::vector
 
#include "symbolic/action.h"
#include "symbolic/axiom.h"
#include "symbolic/derived_predicate.h"
#include "symbolic/formula.h"
#include "symbolic/object.h"
#include "symbolic/predicate.h"
#include "symbolic/proposition.h"
 
namespace VAL {
 
class analysis;
 
}  // namespace VAL
 
namespace symbolic {
 
class Pddl {
 public:
  using ObjectTypeMap = std::unordered_map<std::string, std::vector<Object>>;
  using AxiomContextMap =
      std::unordered_map<std::string, std::vector<std::weak_ptr<Axiom>>>;
 
  Pddl(const std::string& domain_pddl, const std::string& problem_pddl,
       bool apply_axioms = true);
 
  explicit Pddl(const std::string& domain_pddl);
 
  bool IsValid(bool verbose = false, std::ostream& os = std::cout) const;
 
  State NextState(const State& state, const std::string& action_call) const;
 
  State ApplyActions(const State& state, const std::vector<std::string>& action_calls) const;
 
  State DerivedState(const State& state) const;
 
  State ConsistentState(const State& state) const;
 
  PartialState ConsistentState(const PartialState& state) const;
 
  bool IsValidAction(const State& state, const std::string& action) const;
 
  bool IsValidState(const State& state) const;
 
  bool IsValidState(const PartialState& state) const;
 
  bool IsValidTuple(const State& state, const std::string& action_call,
                    const State& next_state) const;
  bool IsValidTuple(const std::set<std::string>& state,
                    const std::string& action_call,
                    const std::set<std::string>& next_state) const;
 
  bool IsGoalSatisfied(const State& state) const { return goal_(state); }
  bool IsGoalSatisfied(const std::set<std::string>& state) const;
 
  bool IsValidPlan(const std::vector<std::string>& action_skeleton) const;
 
  std::vector<std::vector<Object>> ListValidArguments(
      const State& state, const Action& action) const;
  std::vector<std::vector<std::string>> ListValidArguments(
      const std::set<std::string>& state, const std::string& action_name) const;
 
  std::vector<std::string> ListValidActions(const State& state) const;
  std::vector<std::string> ListValidActions(
      const std::set<std::string>& state) const;
 
  void AddObject(const std::string& name, const std::string& type);
  void RemoveObject(const std::string& name);
 
  const VAL::analysis* symbol() const { return analysis_.get(); }
 
  const std::string& name() const;
 
  const std::string& domain_pddl() const { return domain_pddl_; }
 
  const std::string& problem_pddl() const { return problem_pddl_; }
 
  const State& initial_state() const { return initial_state_; }
  void set_initial_state(State&& state) { initial_state_ = std::move(state); }
 
  const ObjectTypeMap& object_map() const { return object_map_; }
 
  const std::vector<Object>& constants() const { return constants_; }
  const std::vector<Object>& objects() const { return objects_; }
 
  const std::vector<Action>& actions() const { return actions_; }
 
  const std::vector<Predicate>& predicates() const { return predicates_; }
 
  const std::vector<std::shared_ptr<Axiom>>& axioms() const { return axioms_; }
 
  const AxiomContextMap& axiom_map() const { return axiom_map_; }
 
  const std::vector<DerivedPredicate>& derived_predicates() const {
    return derived_predicates_;
  }
 
  const StateIndex& state_index() const { return state_index_; }
 
  const Formula& goal() const { return goal_; }
 
 private:
  std::shared_ptr<VAL::analysis> analysis_;
  std::string domain_pddl_;
  std::string problem_pddl_;
 
  std::vector<Object> constants_;
  std::vector<Object> objects_;
  ObjectTypeMap object_map_;
 
  AxiomContextMap axiom_map_;
  std::vector<Action> actions_;
  std::vector<std::shared_ptr<Axiom>> axioms_;
 
  std::vector<Predicate> predicates_;
  std::vector<DerivedPredicate> derived_predicates_;
 
  StateIndex state_index_;
 
  State initial_state_;
  Formula goal_;
};
 
std::set<std::string> Stringify(const State& state);
std::pair<std::set<std::string>, std::set<std::string>> Stringify(
    const PartialState& state);
std::vector<std::string> Stringify(const std::vector<Action>& actions);
std::vector<std::vector<std::string>> Stringify(
    const std::vector<std::vector<Object>>& arguments);
std::vector<std::string> Stringify(const std::vector<Object>& objects);
 
std::ostream& operator<<(std::ostream& os, const Pddl& pddl);
 
}  // namespace symbolic
 
#endif  // SYMBOLIC_PDDL_H_