templated policies, tentatively working. next step is matched_step

Author: connoralittle

src/deadend.cc

@@ -3,7 +3,7 @@
 #include "regression.h"
 
 
-FSAP::FSAP(PR2State *s, PR2OperatorProxy o) : PolicyItem(s), op(&o) {}
+FSAP::FSAP(PR2State *s, PR2OperatorProxy *o) : PolicyItem(s), op(o) {}
 
 
 void FSAP::dump() const {
@@ -78,7 +78,7 @@ bool generalize_deadend(PR2State &state) {
 
 void update_deadends(vector< DeadendTuple* > &failed_states) {
 
-    list<PolicyItem *> fsaps;
+    list<FSAP *> fsaps;
     list<PolicyItem *> deadends;
 
     PR2State *dummy_state = new PR2State();
@@ -109,9 +109,9 @@ void update_deadends(vector< DeadendTuple* > &failed_states) {
         for (auto item : reg_items) {
 
             RegressableOperator *ro = (RegressableOperator*)item;
-
+            PR2OperatorProxy *ro_op_ptr = new PR2OperatorProxy(ro->op);
             fsaps.push_back(new FSAP(failed_state->regress(ro->op, dummy_state),
-                                     ro->op));
+                                     ro_op_ptr));
 
         }
 
@@ -138,9 +138,10 @@ void update_deadends(vector< DeadendTuple* > &failed_states) {
         // If we have a specified previous state and action, use that to
         //  build a forbidden state-action pair
         if (NULL != failed_state_prev) {
+            PR2OperatorProxy *prev_op_ptr = new PR2OperatorProxy(*prev_op);
             fsaps.push_back(new FSAP(
-                    failed_state->regress(*prev_op, failed_state_prev),
-                    *prev_op));
+                failed_state->regress(*prev_op, failed_state_prev),
+                prev_op_ptr));
         }
     }
 
@@ -154,9 +155,11 @@ void update_deadends(vector< DeadendTuple* > &failed_states) {
 
     // Add a pointer from the operator to the newly created fsaps
     for (auto fsap : fsaps)
-        PR2.deadend.nondetop2fsaps[((FSAP*)fsap)->get_index()]->push_back((FSAP*)fsap);
+        PR2.deadend.nondetop2fsaps[fsap->get_index()]->push_back(fsap);
 
     PR2.deadend.policy->update_policy(fsaps);
+    for (auto fsap : PR2.deadend.policy->all_items)
+        std::cout << fsap->get_index() << endl;
     PR2.deadend.states->update_policy(deadends);
 }
 

src/deadend.h

@@ -28,22 +28,6 @@ struct DeadendTuple {
     ~DeadendTuple() {};
 };
 
-struct FSAP : PolicyItem {
-
-    PR2OperatorProxy *op; // The nondet action id we are forbidding
-
-    FSAP(PR2State *s, PR2OperatorProxy o);
-    FSAP(PR2State *s) : PolicyItem(s), op(NULL) {}
-
-    ~FSAP() {}
-
-    bool operator< (const FSAP& other) const;
-
-    string get_name();
-    int get_index();
-    void dump() const;
-};
-
 struct Deadend : FSAP {
     Deadend(PR2State *s) : FSAP(s) {};
     void dump() const;

src/fd_integration/fsap_penalized_ff_heuristic.cc

@@ -327,12 +327,12 @@ int FSAPPenalizedFFHeuristic::compute_heuristic(const State &state) {
 
         // Make sure we don't mark an operator as preferred if it's forbidden
         forbidden_ops.clear();
-        vector<PolicyItem *> reg_items;
+        vector<FSAP *> reg_items;
         PR2State * ps = new PR2State(state);
         PR2.deadend.policy->generate_entailed_items(*ps, reg_items);
         delete ps;
         for (auto item : reg_items)
-            forbidden_ops.insert(((FSAP*)item)->get_index());
+            forbidden_ops.insert(item->get_index());
 
         // Collecting the relaxed plan also sets the preferred operators.
         for (size_t i = 0; i < goal_propositions.size(); ++i)

src/fd_integration/fsap_penalized_ff_heuristic.h

@@ -12,7 +12,7 @@
 
 class State;
 class PR2State;
-class FSAP;
+struct FSAP;
 
 using namespace std;
 

src/fd_integration/pr2_proxies.h

@@ -98,7 +98,7 @@ class PR2OperatorProxy : public OperatorProxy {
         return -1;
     }
     // might be necessary as PR2GoalProxy needs to override
-    virtual EffectsProxy get_all_effects() const {
+    EffectsProxy get_all_effects() const {
         return get_effects();
     }
     // // might be necessary as PR2GoalProxy needs to override

src/fd_integration/pr2_search_algorithm.cc

@@ -125,17 +125,17 @@ void DeadendAwareSuccessorGenerator::generate_applicable_ops(const PR2State &_cu
 
         PR2State curr = PR2State(_curr);
 
-        vector<PolicyItem *> reg_items;
+        vector<FSAP *> reg_items;
         vector<OperatorID> orig_ops;
-        map<int, PolicyItem *> fsap_map;
+        map<int, FSAP *> fsap_map;
 
         PR2.generate_orig_applicable_ops(_curr, orig_ops);
         PR2.deadend.policy->generate_entailed_items(curr, reg_items);
 
         set<int> forbidden;
         for (auto item : reg_items) {
 
-            int index = ((FSAP*)item)->get_index();
+            int index = item->get_index();
 
             forbidden.insert(index);
 
@@ -159,7 +159,7 @@ void DeadendAwareSuccessorGenerator::generate_applicable_ops(const PR2State &_cu
             // Combind all of the FSAPs
             PR2State *newDE = new PR2State();
             for (unsigned i = 0; i < ruled_out.size(); i++) {
-                newDE->combine_with(*(((FSAP*)(fsap_map[ruled_out[i]]))->state));
+                newDE->combine_with(*((fsap_map[ruled_out[i]])->state));
             }
 
             // Also rule out all of the unapplicable actions

src/fond_search.cc

@@ -474,7 +474,7 @@ void strengthen_and_mark(PR2SearchStatus * status,
                          int successor_id_for_dst) {
 
     // Strengthen the solsteps all the way back
-    list<PolicyItem *> new_steps;
+    list<SolutionStep *> new_steps;
 
     PR2.solution.incumbent->network->fixed_point_regression(
         previous_step, // src

src/partial_state_graph.cc

@@ -12,7 +12,7 @@ void PSGraph::fixed_point_regression(SolutionStep * src,
                                      PR2SearchNode * dst_node,
                                      int successor_id_for_dst,
                                      map< SolutionStep*, set< PR2SearchNode * > * > &solstep2searchnode,
-                                     list<PolicyItem *> &new_steps,
+                                     list<SolutionStep *> &new_steps,
                                      bool make_connection) {
 
     #ifndef NDEBUG

src/partial_state_graph.h

@@ -26,7 +26,7 @@ struct PSGraph {
                                 PR2SearchNode * dst_node,
                                 int successor_id_for_dst,
                                 map< SolutionStep* , set< PR2SearchNode * > * > &solstep2searchnode,
-                                list<PolicyItem *> &new_steps,
+                                list<SolutionStep *> &new_steps,
                                 bool make_connection = false);
 
     void fixed_point_marking(SolutionStep * node);

src/policy.cc

@@ -30,23 +30,29 @@ vector< pair<int,int> > * PolicyItem::varvals() {
     return state->varvals();
 }
 
-
-Policy::~Policy() {
+template <typename T>
+Policy<T>::~Policy() {
     if (root)
         delete root;
 
     for (auto item : all_items)
          delete item;
 }
+template Policy<PolicyItem>::~Policy();
+template Policy<FSAP>::~Policy();
+template Policy<SolutionStep>::~Policy();
 
 // TODO: Revisit this comparison -- just doing a pointer comparison for now
-bool fsap_compare(PolicyItem* first, PolicyItem* second) {
+bool fsap_compare(PolicyItem *first, PolicyItem *second)
+{
     return ((const FSAP*)first) < ((const FSAP*)second);
 }
 bool solstep_compare(PolicyItem* first, PolicyItem* second) {
     return *((const SolutionStep*)first) < *((const SolutionStep*)second);
 }
-void Policy::write_policy(string fname, bool fsap) {
+
+template <typename T>
+void Policy<T>::write_policy(string fname, bool fsap) {
 
     if (!fsap)
         all_items.sort(fsap ? fsap_compare : solstep_compare);
@@ -76,24 +82,39 @@ void Policy::write_policy(string fname, bool fsap) {
 
     outfile.close();
 }
+template void Policy<PolicyItem>::write_policy(string fname, bool fsap);
+template void Policy<FSAP>::write_policy(string fname, bool fsap);
+template void Policy<SolutionStep>::write_policy(string fname, bool fsap);
 
-void Policy::dump(bool fsap) const {
+template <typename T>
+void Policy<T>::dump(bool fsap) const {
     cout << (fsap ? "FSAP " : "") << "Policy:" << endl;
     for (auto item : all_items)
          item->dump();
 }
+template void Policy<PolicyItem>::dump(bool fsap) const;
+template void Policy<SolutionStep>::dump(bool fsap) const;
 
-void Policy::generate_cpp_input(ofstream &outfile) const {
+template <typename T>
+void Policy<T>::generate_cpp_input(ofstream &outfile) const {
     root->generate_cpp_input(outfile);
 }
+template void Policy<PolicyItem>::generate_cpp_input(ofstream &outfile) const;
+template void Policy<FSAP>::generate_cpp_input(ofstream &outfile) const;
+template void Policy<SolutionStep>::generate_cpp_input(ofstream &outfile) const;
 
-void Policy::add_item(PolicyItem *item) {
-    list<PolicyItem *> reg_items;
+template <typename T>
+void Policy<T>::add_item(T *item) {
+    list<T *> reg_items;
     reg_items.push_back(item);
     update_policy(reg_items);
 }
+template void Policy<PolicyItem>::add_item(PolicyItem *item);
+template void Policy<FSAP>::add_item(FSAP *item);
+template void Policy<SolutionStep>::add_item(SolutionStep *item);
 
-void Policy::update_policy(list<PolicyItem *> &reg_items) {
+template <typename T>
+void Policy<T>::update_policy(list<T *> &reg_items) {
 
     list<MatchtreeItem *> mtis;
     for (auto item : reg_items)
@@ -105,28 +126,36 @@ void Policy::update_policy(list<PolicyItem *> &reg_items) {
     else
         root = new MatchtreeSwitch(mtis, vars_seen);
     all_items.insert(all_items.end(), reg_items.begin(), reg_items.end());
-
 }
+template void Policy<PolicyItem>::update_policy(list<PolicyItem *> &reg_items);
+template void Policy<FSAP>::update_policy(list<FSAP *> &reg_items);
+template void Policy<SolutionStep>::update_policy(list<SolutionStep *> &reg_items);
 
-bool Policy::check_consistent_match(const PR2State &curr) {
+template <typename T>
+bool Policy<T>::check_consistent_match(const PR2State &curr) {
     if (root)
         return root->check_consistent_match(curr);
     else
         return false;
 }
 
-bool Policy::check_entailed_match(const PR2State &curr) {
+template <typename T>
+bool Policy<T>::check_entailed_match(const PR2State &curr) {
     if (root)
         return root->check_entailed_match(curr);
     else
         return false;
 }
+template bool Policy<PolicyItem>::check_entailed_match(const PR2State &curr);
+template bool Policy<FSAP>::check_entailed_match(const PR2State &curr);
+template bool Policy<SolutionStep>::check_entailed_match(const PR2State &curr);
 
-void Policy::rebuild() {
+template <typename T>
+void Policy<T>::rebuild() {
 
     // We are only going to keep the items that are active
     list<MatchtreeItem *> mtis;
-    list<PolicyItem *> new_items;
+    list<T *> new_items;
     for (auto item : all_items) {
         if (item->is_active) {
             mtis.push_back((MatchtreeItem *)item);
@@ -143,3 +172,7 @@ void Policy::rebuild() {
     all_items.swap(new_items);
 
 }
+template void Policy<PolicyItem>::rebuild();
+template void Policy<FSAP>::rebuild();
+template void Policy<SolutionStep>::rebuild();
+