compose callbacks instead of using a vector of callbacks

Author: cmnrd

include/reactor-cpp/port.hh

@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "assert.hh"
+#include "fwd.hh"
 #include "multiport.hh"
 #include "reactor.hh"
 #include "value_ptr.hh"
@@ -31,7 +32,7 @@ private:
   std::set<Reaction*> triggers_{};
   std::set<Reaction*> anti_dependencies_{};
 
-  std::vector<PortCallback> set_callbacks_{};
+  PortCallback set_callback_{nullptr};
   PortCallback clean_callback_{nullptr};
 
 protected:
@@ -58,8 +59,8 @@ protected:
   }
 
   inline void invoke_set_callback() noexcept {
-    for (auto& callback : set_callbacks_) {
-      callback(*this);
+    if (set_callback_ != nullptr) {
+      set_callback_(*this);
     }
   }
 
@@ -92,12 +93,8 @@ public:
   [[nodiscard]] inline auto anti_dependencies() const noexcept -> const auto& { return anti_dependencies_; }
   [[nodiscard]] inline auto port_type() const noexcept -> PortType { return type_; }
 
-  void register_set_callback(const PortCallback& callback) { set_callbacks_.emplace_back(callback); }
-
-  void register_clean_callback(const PortCallback& callback) {
-    reactor_assert(clean_callback_ == nullptr);
-    clean_callback_ = callback;
-  }
+  void register_set_callback(const PortCallback& callback);
+  void register_clean_callback(const PortCallback& callback);
 
   friend class Reaction;
   friend class Scheduler;

lib/port.cc

@@ -94,12 +94,41 @@ auto Port<void>::typed_inward_binding() const noexcept -> Port<void>* {
 }
 
 void Port<void>::set() {
-  validate(!has_inward_binding(), "set() may only be called on a ports that do not have an inward "
+  validate(!has_inward_binding(), "set() may only be called on ports that do not have an inward "
                                   "binding!");
 
   auto* scheduler = environment()->scheduler();
   scheduler->set_port(this);
   this->present_ = true;
 }
 
+// This function can be used to chain two callbacks. This mechanism is not
+// very efficient if many callbacks are registered on the same port. However,
+// it is more efficient than, e.g., a vector of callbacks if usually only one
+// callback is registered. At the moment, we use at most two callbacks on the
+// same port (one if the port is in a multiport, and one if it is upstream of
+// a delayed connection).
+auto compose_callbacks(const PortCallback& callback1, const PortCallback& callback2) -> PortCallback {
+  return [=](const BasePort& port) {
+    callback1(port);
+    callback2(port);
+  };
+}
+
+void BasePort::register_set_callback(const PortCallback& callback) {
+  if (set_callback_ == nullptr) {
+    set_callback_ = callback;
+  } else {
+    set_callback_ = compose_callbacks(set_callback_, callback);
+  }
+}
+
+void BasePort::register_clean_callback(const PortCallback& callback) {
+  if (clean_callback_ == nullptr) {
+    clean_callback_ = callback;
+  } else {
+    clean_callback_ = compose_callbacks(clean_callback_, callback);
+  }
+}
+
 } // namespace reactor