[issue1082] Use Options objects only in Features

src/search/cartesian_abstractions/utils.cc

@@ -1,8 +1,6 @@
 #include "utils.h"
 
-#include "../plugins/plugin.h"
 #include "../heuristics/additive_heuristic.h"
-#include "../task_utils/task_properties.h"
 #include "../utils/logging.h"
 #include "../utils/memory.h"
 
@@ -15,11 +13,8 @@ using namespace std;
 namespace cartesian_abstractions {
 unique_ptr<additive_heuristic::AdditiveHeuristic> create_additive_heuristic(
     const shared_ptr<AbstractTask> &task) {
-    plugins::Options opts;
-    opts.set<shared_ptr<AbstractTask>>("transform", task);
-    opts.set<bool>("cache_estimates", false);
-    opts.set<utils::Verbosity>("verbosity", utils::Verbosity::SILENT);
-    return utils::make_unique_ptr<additive_heuristic::AdditiveHeuristic>(opts);
+    return utils::make_unique_ptr<additive_heuristic::AdditiveHeuristic>(
+        task, false, "h^add within CEGAR abstractions", utils::Verbosity::SILENT);
 }
 
 static bool operator_applicable(

src/search/evaluator.cc

@@ -9,11 +9,24 @@
 using namespace std;
 
 
+Evaluator::Evaluator(bool use_for_reporting_minima,
+                     bool use_for_boosting,
+                     bool use_for_counting_evaluations,
+                     const string &name,
+                     utils::Verbosity verbosity)
+    : name(name),
+      use_for_reporting_minima(use_for_reporting_minima),
+      use_for_boosting(use_for_boosting),
+      use_for_counting_evaluations(use_for_counting_evaluations),
+      log(utils::get_log_from_verbosity(verbosity)) {
+}
+
+
 Evaluator::Evaluator(const plugins::Options &opts,
                      bool use_for_reporting_minima,
                      bool use_for_boosting,
                      bool use_for_counting_evaluations)
-    : description(opts.get_unparsed_config()),
+    : name(opts.get_unparsed_config()),
       use_for_reporting_minima(use_for_reporting_minima),
       use_for_boosting(use_for_boosting),
       use_for_counting_evaluations(use_for_counting_evaluations),
@@ -28,7 +41,7 @@ void Evaluator::report_value_for_initial_state(
     const EvaluationResult &result) const {
     if (log.is_at_least_normal()) {
         assert(use_for_reporting_minima);
-        log << "Initial heuristic value for " << description << ": ";
+        log << "Initial heuristic value for " << name << ": ";
         if (result.is_infinite())
             log << "infinity";
         else
@@ -41,13 +54,13 @@ void Evaluator::report_new_minimum_value(
     const EvaluationResult &result) const {
     if (log.is_at_least_normal()) {
         assert(use_for_reporting_minima);
-        log << "New best heuristic value for " << description << ": "
+        log << "New best heuristic value for " << name << ": "
             << result.get_evaluator_value() << endl;
     }
 }
 
-const string &Evaluator::get_description() const {
-    return description;
+const string &Evaluator::get_name() const {
+    return name;
 }
 
 bool Evaluator::is_used_for_reporting_minima() const {
@@ -75,6 +88,9 @@ int Evaluator::get_cached_estimate(const State &) const {
 }
 
 void add_evaluator_options_to_feature(plugins::Feature &feature) {
+    feature.add_option<string>("name",
+                               "name used to identify evaluator in logs",
+                               "\"<Evaluator>\"");
     utils::add_log_options_to_feature(feature);
 }
 

src/search/evaluator.h

@@ -15,13 +15,19 @@ class Options;
 }
 
 class Evaluator {
-    const std::string description;
+    const std::string name;
     const bool use_for_reporting_minima;
     const bool use_for_boosting;
     const bool use_for_counting_evaluations;
 protected:
     mutable utils::LogProxy log;
 public:
+    explicit Evaluator(
+        bool use_for_reporting_minima,
+        bool use_for_boosting,
+        bool use_for_counting_evaluations,
+        const std::string &name,
+        utils::Verbosity verbosity);
     explicit Evaluator(
         const plugins::Options &opts,
         bool use_for_reporting_minima = false,
@@ -86,7 +92,7 @@ class Evaluator {
     void report_value_for_initial_state(const EvaluationResult &result) const;
     void report_new_minimum_value(const EvaluationResult &result) const;
 
-    const std::string &get_description() const;
+    const std::string &get_name() const;
     bool is_used_for_reporting_minima() const;
     bool is_used_for_boosting() const;
     bool is_used_for_counting_evaluations() const;

src/search/heuristic.cc

@@ -13,6 +13,18 @@
 #include <limits>
 
 using namespace std;
+Heuristic::Heuristic(
+    shared_ptr<AbstractTask> transform,
+    bool cache_estimates,
+    const string &name,
+    utils::Verbosity verbosity
+    )
+    : Evaluator(true, true, true, name, verbosity),
+      heuristic_cache(HEntry(NO_VALUE, true)),     //TODO: is true really a good idea here?
+      cache_evaluator_values(cache_estimates),
+      task(transform),
+      task_proxy(*task) {
+}
 
 Heuristic::Heuristic(const plugins::Options &opts)
     : Evaluator(opts, true, true, true),
@@ -22,9 +34,6 @@ Heuristic::Heuristic(const plugins::Options &opts)
       task_proxy(*task) {
 }
 
-Heuristic::~Heuristic() {
-}
-
 void Heuristic::set_preferred(const OperatorProxy &op) {
     preferred_operators.insert(op.get_ancestor_operator_id(tasks::g_root_task.get()));
 }

src/search/heuristic.h

@@ -7,6 +7,7 @@
 #include "task_proxy.h"
 
 #include "algorithms/ordered_set.h"
+#include "tasks/root_task.h"
 
 #include <memory>
 #include <vector>
@@ -73,8 +74,11 @@ class Heuristic : public Evaluator {
     State convert_ancestor_state(const State &ancestor_state) const;
 
 public:
+    explicit Heuristic(std::shared_ptr<AbstractTask> transform,
+                       bool cache_estimates,
+                       const std::string &name,
+                       utils::Verbosity verbosity);
     explicit Heuristic(const plugins::Options &opts);
-    virtual ~Heuristic() override;
 
     virtual void get_path_dependent_evaluators(
         std::set<Evaluator *> & /*evals*/) override {

src/search/heuristics/additive_heuristic.cc

@@ -13,9 +13,12 @@ using namespace std;
 namespace additive_heuristic {
 const int AdditiveHeuristic::MAX_COST_VALUE;
 
-// construction and destruction
-AdditiveHeuristic::AdditiveHeuristic(const plugins::Options &opts)
-    : RelaxationHeuristic(opts),
+AdditiveHeuristic::AdditiveHeuristic(const shared_ptr<AbstractTask> &transform,
+                                     bool cache_estimates,
+                                     const string &name,
+                                     utils::Verbosity verbosity
+                                     )
+    : RelaxationHeuristic(transform, cache_estimates, name, verbosity),
       did_write_overflow_warning(false) {
     if (log.is_at_least_normal()) {
         log << "Initializing additive heuristic..." << endl;
@@ -165,6 +168,14 @@ class AdditiveHeuristicFeature : public plugins::TypedFeature<Evaluator, Additiv
         document_property("safe", "yes for tasks without axioms");
         document_property("preferred operators", "yes");
     }
+
+    virtual shared_ptr<AdditiveHeuristic> create_component(
+        const plugins::Options &opts, const utils::Context &) const override {
+        return make_shared<AdditiveHeuristic>(opts.get<shared_ptr<AbstractTask>>("transform"),
+                                              opts.get<bool>("cache_estimates"),
+                                              opts.get<string>("name"),
+                                              opts.get<utils::Verbosity>("verbosity"));
+    }
 };
 
 static plugins::FeaturePlugin<AdditiveHeuristicFeature> _plugin;

src/search/heuristics/additive_heuristic.h

@@ -65,7 +65,10 @@ class AdditiveHeuristic : public relaxation_heuristic::RelaxationHeuristic {
     // Common part of h^add and h^ff computation.
     int compute_add_and_ff(const State &state);
 public:
-    explicit AdditiveHeuristic(const plugins::Options &opts);
+    AdditiveHeuristic(const std::shared_ptr<AbstractTask> &transform,
+                      bool cache_estimates,
+                      const std::string &name,
+                      utils::Verbosity verbosity);
 
     /*
       TODO: The two methods below are temporarily needed for the CEGAR

src/search/heuristics/blind_search_heuristic.cc

@@ -12,17 +12,18 @@
 using namespace std;
 
 namespace blind_search_heuristic {
-BlindSearchHeuristic::BlindSearchHeuristic(const plugins::Options &opts)
-    : Heuristic(opts),
+BlindSearchHeuristic::BlindSearchHeuristic(const shared_ptr<AbstractTask> &transform,
+                                           bool cache_estimates,
+                                           const string &name,
+                                           utils::Verbosity verbosity
+                                           )
+    : Heuristic(transform, cache_estimates, name, verbosity),
       min_operator_cost(task_properties::get_min_operator_cost(task_proxy)) {
     if (log.is_at_least_normal()) {
         log << "Initializing blind search heuristic..." << endl;
     }
 }
 
-BlindSearchHeuristic::~BlindSearchHeuristic() {
-}
-
 int BlindSearchHeuristic::compute_heuristic(const State &ancestor_state) {
     State state = convert_ancestor_state(ancestor_state);
     if (task_properties::is_goal_state(task_proxy, state))
@@ -50,6 +51,14 @@ class BlindSearchHeuristicFeature : public plugins::TypedFeature<Evaluator, Blin
         document_property("safe", "yes");
         document_property("preferred operators", "no");
     }
+
+    virtual shared_ptr<BlindSearchHeuristic> create_component(
+        const plugins::Options &opts, const utils::Context &) const override {
+        return make_shared<BlindSearchHeuristic>(opts.get<shared_ptr<AbstractTask>>("transform"),
+                                                 opts.get<bool>("cache_estimates"),
+                                                 opts.get<string>("name"),
+                                                 opts.get<utils::Verbosity>("verbosity"));
+    }
 };
 
 static plugins::FeaturePlugin<BlindSearchHeuristicFeature> _plugin;

src/search/heuristics/blind_search_heuristic.h

@@ -9,8 +9,10 @@ class BlindSearchHeuristic : public Heuristic {
 protected:
     virtual int compute_heuristic(const State &ancestor_state) override;
 public:
-    BlindSearchHeuristic(const plugins::Options &opts);
-    ~BlindSearchHeuristic();
+    BlindSearchHeuristic(const std::shared_ptr<AbstractTask> &transform,
+                         bool cache_estimates,
+                         const std::string &name,
+                         utils::Verbosity verbosity);
 };
 }
 

src/search/heuristics/ff_heuristic.cc

@@ -11,8 +11,12 @@ using namespace std;
 
 namespace ff_heuristic {
 // construction and destruction
-FFHeuristic::FFHeuristic(const plugins::Options &opts)
-    : AdditiveHeuristic(opts),
+FFHeuristic::FFHeuristic(const shared_ptr<AbstractTask> &transform,
+                         bool cache_estimates,
+                         const string &name,
+                         utils::Verbosity verbosity
+                         )
+    : AdditiveHeuristic(transform, cache_estimates, name, verbosity),
       relaxed_plan(task_proxy.get_operators().size(), false) {
     if (log.is_at_least_normal()) {
         log << "Initializing FF heuristic..." << endl;
@@ -89,6 +93,14 @@ class FFHeuristicFeature : public plugins::TypedFeature<Evaluator, FFHeuristic>
         document_property("safe", "yes for tasks without axioms");
         document_property("preferred operators", "yes");
     }
+
+    virtual shared_ptr<FFHeuristic> create_component(
+        const plugins::Options &opts, const utils::Context &) const override {
+        return make_shared<FFHeuristic>(opts.get<shared_ptr<AbstractTask>>("transform"),
+                                        opts.get<bool>("cache_estimates"),
+                                        opts.get<string>("name"),
+                                        opts.get<utils::Verbosity>("verbosity"));
+    }
 };
 
 static plugins::FeaturePlugin<FFHeuristicFeature> _plugin;

src/search/heuristics/ff_heuristic.h

@@ -32,7 +32,10 @@ class FFHeuristic : public additive_heuristic::AdditiveHeuristic {
 protected:
     virtual int compute_heuristic(const State &ancestor_state) override;
 public:
-    explicit FFHeuristic(const plugins::Options &opts);
+    explicit FFHeuristic(const std::shared_ptr<AbstractTask> &transform,
+                         bool cache_estimates,
+                         const std::string &name,
+                         utils::Verbosity verbosity);
 };
 }
 

src/search/heuristics/max_heuristic.cc

@@ -22,8 +22,12 @@ namespace max_heuristic {
  */
 
 // construction and destruction
-HSPMaxHeuristic::HSPMaxHeuristic(const plugins::Options &opts)
-    : RelaxationHeuristic(opts) {
+HSPMaxHeuristic::HSPMaxHeuristic(const shared_ptr<AbstractTask> &transform,
+                                 bool cache_estimates,
+                                 const string &name,
+                                 utils::Verbosity verbosity
+                                 )
+    : RelaxationHeuristic(transform, cache_estimates, name, verbosity) {
     if (log.is_at_least_normal()) {
         log << "Initializing HSP max heuristic..." << endl;
     }
@@ -118,6 +122,14 @@ class HSPMaxHeuristicFeature : public plugins::TypedFeature<Evaluator, HSPMaxHeu
         document_property("safe", "yes for tasks without axioms");
         document_property("preferred operators", "no");
     }
+
+    virtual shared_ptr<HSPMaxHeuristic> create_component(
+        const plugins::Options &opts, const utils::Context &) const override {
+        return make_shared<HSPMaxHeuristic>(opts.get<shared_ptr<AbstractTask>>("transform"),
+                                            opts.get<bool>("cache_estimates"),
+                                            opts.get<string>("name"),
+                                            opts.get<utils::Verbosity>("verbosity"));
+    }
 };
 
 static plugins::FeaturePlugin<HSPMaxHeuristicFeature> _plugin;

src/search/heuristics/max_heuristic.h

@@ -33,7 +33,10 @@ class HSPMaxHeuristic : public relaxation_heuristic::RelaxationHeuristic {
 protected:
     virtual int compute_heuristic(const State &ancestor_state) override;
 public:
-    explicit HSPMaxHeuristic(const plugins::Options &opts);
+    explicit HSPMaxHeuristic(const std::shared_ptr<AbstractTask> &transform,
+                             bool cache_estimates,
+                             const std::string &name,
+                             utils::Verbosity verbosity);
 };
 }
 

src/search/heuristics/relaxation_heuristic.cc

@@ -35,8 +35,12 @@ UnaryOperator::UnaryOperator(
 
 
 // construction and destruction
-RelaxationHeuristic::RelaxationHeuristic(const plugins::Options &opts)
-    : Heuristic(opts) {
+RelaxationHeuristic::RelaxationHeuristic(const shared_ptr<AbstractTask> &transform,
+                                         bool cache_estimates,
+                                         const string &name,
+                                         utils::Verbosity verbosity
+                                         )
+    : Heuristic(transform, cache_estimates, name, verbosity) {
     // Build propositions.
     propositions.resize(task_properties::get_num_facts(task_proxy));
 

src/search/heuristics/relaxation_heuristic.h

@@ -110,7 +110,10 @@ class RelaxationHeuristic : public Heuristic {
     Proposition *get_proposition(int var, int value);
     Proposition *get_proposition(const FactProxy &fact);
 public:
-    explicit RelaxationHeuristic(const plugins::Options &options);
+    RelaxationHeuristic(const std::shared_ptr<AbstractTask> &transform,
+                        bool cache_estimates,
+                        const std::string &name,
+                        utils::Verbosity verbosity);
 
     virtual bool dead_ends_are_reliable() const override;
 };

src/search/utils/logging.cc

@@ -29,6 +29,13 @@ void add_log_options_to_feature(plugins::Feature &feature) {
         "normal");
 }
 
+LogProxy get_log_from_verbosity(const Verbosity &verbosity) {
+    if (verbosity == Verbosity::NORMAL) {
+        return LogProxy(global_log);
+    }
+    return LogProxy(make_shared<Log>(verbosity));
+}
+
 LogProxy get_log_from_options(const plugins::Options &options) {
     /* NOTE: We return (a proxy to) the global log if all options match the
        default values of the global log. */

src/search/utils/logging.h

@@ -130,6 +130,7 @@ class LogProxy {
 extern LogProxy g_log;
 
 extern void add_log_options_to_feature(plugins::Feature &feature);
+extern LogProxy get_log_from_verbosity(const Verbosity &verbosity);
 extern LogProxy get_log_from_options(const plugins::Options &options);
 extern LogProxy get_silent_log();