Add causal link handling in solver_core and server classes

- Introduced add_causal_link method in solver_core to manage causal relationships between flaws and resolvers.
- Implemented causal_link_added method in server to notify clients when a causal link is established.
- Updated basic_solver to utilize the new causal link functionality.

Author: riccardodebenedictis

include/server/basic_solver_server.hpp

@@ -25,6 +25,8 @@ namespace ratio
     void current_flaw(std::optional<std::reference_wrapper<ratio::flaw>> f) noexcept override;
     void current_resolver(std::optional<std::reference_wrapper<ratio::resolver>> r) noexcept override;
 
+    void causal_link_added(const flaw &f, const resolver &r) override;
+    
   private:
     std::unordered_set<network::ws_server_session_base *> clients;
   };

include/solver_core.hpp

@@ -168,6 +168,8 @@ namespace ratio
       return r_ref;
     }
 
+    virtual void add_causal_link(flaw &f, resolver &r) noexcept;
+
     virtual void solve() = 0;
 
     [[nodiscard]] bool match(riddle::term &lhs, riddle::term &rhs) const;
@@ -234,6 +236,16 @@ namespace ratio
      * @param The current resolver being applied.
      */
     virtual void current_resolver([[maybe_unused]] std::optional<std::reference_wrapper<ratio::resolver>>) noexcept {}
+
+    /**
+     * @brief Notifies when a causal link has been added.
+     *
+     * This function is called when a causal link has been added. It is a virtual function that can be overridden by derived classes to perform specific actions when a causal link is added.
+     *
+     * @param flaw The flaw that is the source of the causal link.
+     * @param resolver The resolver that is the destination of the causal link.
+     */
+    virtual void causal_link_added([[maybe_unused]] const flaw &, [[maybe_unused]] const resolver &) {}
 #endif
 
   protected:

src/basic_solver.cpp

@@ -288,6 +288,7 @@ namespace ratio
     {
         execute(get_solver().new_eq(static_cast<atom_flaw &>(flw).get_atom(), atm));
         add_ac_constraint(get_ac().new_assign(utils::variable(static_cast<riddle::atom &>(*static_cast<atom_flaw &>(flw).get_atom()).get_sigma()), arc_consistency::solver::False));
+        get_solver().add_causal_link(static_cast<atom &>(*atm).get_flaw(), *this);
     }
 
     json::json unify_atom::to_json() const

src/server/basic_solver_server.cpp

@@ -89,4 +89,12 @@ namespace ratio
         for (auto client : clients)
             client->send(msg);
     }
+
+    void server::causal_link_added(const ratio::flaw &f, const ratio::resolver &r)
+    {
+        auto j_msg = json::json{{"msg_type", "causal_link_added"}, {"flaw", f.get_id()}, {"resolver", r.get_id()}};
+        auto msg = j_msg.dump();
+        for (auto client : clients)
+            client->send(msg);
+    }
 } // namespace ratio

src/solver_core.cpp

@@ -6,9 +6,11 @@
 #ifdef ORATIO_ENABLE_LISTENERS
 #define CURRENT_FLAW(f) current_flaw(f)
 #define CURRENT_RESOLVER(r) current_resolver(r)
+#define NEW_CAUSAL_LINK(f, r) causal_link_added(f, r)
 #else
 #define CURRENT_FLAW(f)
 #define CURRENT_RESOLVER(r)
+#define NEW_CAUSAL_LINK(f, r)
 #endif
 
 namespace ratio
@@ -166,6 +168,13 @@ namespace ratio
             throw std::runtime_error("Invalid type");
     }
 
+    void solver_core::add_causal_link(flaw &f, resolver &r) noexcept
+    {
+        f.supports.push_back(r);
+        r.preconditions.push_back(f);
+        NEW_CAUSAL_LINK(f, r);
+    }
+
     bool solver_core::match(riddle::term &lhs, riddle::term &rhs) const
     {
         if (&lhs == &rhs) // the terms are the same, so they match..