Implement basic_solver and resolver classes with flaw management and enum handling

Author: riccardodebenedictis

extern/ac

@@ -2,13 +2,132 @@
 
 #include "solver_core.hpp"
 
+#ifdef ORATIO_ENABLE_LISTENERS
+#define NEW_FLAW(f) flaw_created(f)
+#define NEW_RESOLVER(r) resolver_created(r)
+#else
+#define NEW_FLAW(f)
+#define NEW_RESOLVER(r)
+#endif
+
 namespace ratio
 {
+  class basic_solver;
+  class resolver;
+
+  class flaw
+  {
+  public:
+    flaw(basic_solver &slv) noexcept;
+    flaw(const flaw &) = delete;
+    virtual ~flaw() = default;
+
+  private:
+    virtual void compute_resolvers() = 0;
+
+  protected:
+    basic_solver &slv; // The solver managing this flaw..
+  };
+
+  class resolver
+  {
+  public:
+    resolver(flaw &flw, utils::rational &&intrinsic_cost) noexcept;
+    resolver(const resolver &) = delete;
+    virtual ~resolver() = default;
+
+  private:
+    virtual void apply() = 0;
+
+  protected:
+    flaw &flw;                      // The flaw this resolver addresses..
+    utils::rational intrinsic_cost; // The intrinsic cost of applying this resolver..
+  };
+
   class basic_solver : public solver_core
   {
   public:
     basic_solver() noexcept;
 
+    [[nodiscard]] riddle::expr new_enum(riddle::component_type &tp, std::vector<riddle::expr> &&values) override;
+
+    /**
+     * @brief Creates a new flaw of the given type.
+     *
+     * @tparam Tp The type of the flaw to create.
+     * @tparam Args The types of the arguments to pass to the flaw
+     * @param args The arguments to pass to the flaw
+     * @return Tp& The created flaw
+     */
+    template <typename Tp, typename... Args>
+    Tp &new_flaw(Args &&...args) noexcept
+    {
+      static_assert(std::is_base_of_v<flaw, Tp>, "Tp must be a subclass of flaw");
+      auto f = std::make_unique<Tp>(std::forward<Args>(args)...);
+      auto &f_ref = *f;
+      NEW_FLAW(f_ref);
+      flaws.emplace_back(std::move(f));
+      return f_ref;
+    }
+
+    /**
+     * @brief Creates a new resolver of the given type.
+     *
+     * @tparam Tp The type of the resolver to create.
+     * @tparam Args The types of the arguments to pass to the resolver
+     * @param args The arguments to pass to the resolver
+     * @return Tp& The created resolver
+     */
+    template <typename Tp, typename... Args>
+    Tp &new_resolver(Args &&...args) noexcept
+    {
+      static_assert(std::is_base_of_v<resolver, Tp>, "Tp must be a subclass of resolver");
+      auto r = std::make_unique<Tp>(std::forward<Args>(args)...);
+      auto &r_ref = *r;
+      NEW_RESOLVER(r_ref);
+      resolvers.emplace_back(std::move(r));
+      return r_ref;
+    }
+
     void solve() override;
+
+#ifdef ORATIO_ENABLE_LISTENERS
+  private:
+    /**
+     * @brief Notifies that a new flaw has been created.
+     *
+     * This function is called whenever a new flaw is created in the solver.
+     *
+     * @param f The newly created flaw.
+     */
+    virtual void flaw_created([[maybe_unused]] flaw &f) noexcept {}
+
+    /**
+     * @brief Notifies that a new resolver has been created.
+     *
+     * This function is called whenever a new resolver is created in the solver.
+     *
+     * @param r The newly created resolver.
+     */
+    virtual void resolver_created([[maybe_unused]] resolver &r) noexcept {}
+#endif
+
+  private:
+    std::vector<std::unique_ptr<flaw>> flaws;         // The set of flaws
+    std::vector<std::unique_ptr<resolver>> resolvers; // The set of resolvers
+  };
+
+  class enum_flaw final : public flaw
+  {
+  public:
+    enum_flaw(basic_solver &slv, riddle::enum_expr var) noexcept;
+
+    [[nodiscard]] const riddle::enum_expr &get_var() const noexcept { return var; }
+
+  private:
+    void compute_resolvers() override;
+
+  private:
+    riddle::enum_expr var;
   };
 } // namespace ratio

include/basic_solver.hpp

@@ -34,7 +34,6 @@ namespace ratio
     [[nodiscard]] riddle::string_expr new_string(std::string &&value) override;
     [[nodiscard]] std::string string_value(const riddle::string_term &expr) const noexcept override;
 
-    [[nodiscard]] riddle::expr new_enum(riddle::component_type &tp, std::vector<riddle::expr> &&values) override;
     [[nodiscard]] std::vector<riddle::expr> enum_value(const riddle::enum_term &expr) const noexcept override;
 
     [[nodiscard]] riddle::arith_expr new_negation(riddle::arith_expr xpr) override;
@@ -53,8 +52,8 @@ namespace ratio
     [[nodiscard]] riddle::atom_expr create_atom(bool is_fact, riddle::predicate &pred, std::map<std::string, riddle::expr, std::less<>> &&args) override;
     [[nodiscard]] riddle::atom_state get_atom_state(const riddle::atom_term &atom) const noexcept override;
 
-  private:
+  protected:
     arc_consistency::solver ac_slv; // The arc consistency solver..
-    linspire::solver lin_slv;
+    linspire::solver lin_slv;       // The linear programming solver..
   };
 } // namespace ratio

include/solver_core.hpp

@@ -1 +1,39 @@
-#include "basic_solver.hpp"
+#include "basic_solver.hpp"
+#include "items.hpp"
+#include "logging.hpp"
+#include <cassert>
+
+namespace ratio
+{
+    flaw::flaw(basic_solver &slv) noexcept : slv(slv) {}
+
+    resolver::resolver(flaw &flw, utils::rational &&intrinsic_cost) noexcept : flw(flw), intrinsic_cost(std::move(intrinsic_cost)) {}
+
+    basic_solver::basic_solver() noexcept : solver_core("oRatio Basic Solver") {}
+
+    riddle::expr basic_solver::new_enum(riddle::component_type &tp, std::vector<riddle::expr> &&values)
+    {
+        assert(!values.empty());
+        if (values.size() == 1)
+        { // Single-valued enum
+            assert(&values.front()->get_type() == &tp);
+            return values.front();
+        }
+        else
+        {
+            std::vector<std::reference_wrapper<const utils::enum_val>> ev_refs;
+            for (auto &ev_ptr : values)
+                ev_refs.emplace_back(*ev_ptr);
+            auto ev = ac_slv.new_var(ev_refs);
+            // .. and create a new enum flaw to manage the variable..
+            auto &ef = new_flaw<enum_flaw>(*this, std::make_shared<riddle::enum_item>(tp, std::move(values), ev));
+            return ef.get_var();
+        }
+    }
+
+    void basic_solver::solve() {}
+
+    enum_flaw::enum_flaw(basic_solver &slv, riddle::enum_expr var) noexcept : flaw(slv), var(std::move(var)) {}
+
+    void enum_flaw::compute_resolvers() {}
+} // namespace ratio

src/basic_solver.cpp

@@ -1,5 +1,7 @@
 #include "solver_core.hpp"
 #include "items.hpp"
+#include "logging.hpp"
+#include <cassert>
 
 namespace ratio
 {
@@ -31,4 +33,14 @@ namespace ratio
     riddle::string_expr solver_core::new_string() { return std::make_shared<riddle::string_item>(static_cast<riddle::string_type &>(get_type(riddle::string_kw)), ""); }
     riddle::string_expr solver_core::new_string(std::string &&value) { return std::make_shared<riddle::string_item>(static_cast<riddle::string_type &>(get_type(riddle::string_kw)), std::move(value)); }
     std::string solver_core::string_value(const riddle::string_term &expr) const noexcept { return static_cast<const riddle::string_item &>(expr).get_string(); }
+
+    std::vector<riddle::expr> solver_core::enum_value(const riddle::enum_term &expr) const noexcept
+    {
+        auto &dom = ac_slv.domain(static_cast<const riddle::enum_item &>(expr).get_var());
+        std::vector<riddle::expr> values;
+        for (auto ev_ptr : static_cast<const riddle::enum_item &>(expr).get_values())
+            if (dom.find(&*ev_ptr) != dom.end())
+                values.push_back(ev_ptr);
+        return values;
+    };
 } // namespace ratio