keep track of input actions in the environment

Currently, the only action type that is an input action is a physical action.
Later we will add enclave and federate connections.

Author: cmnrd

include/reactor-cpp/action.hh

@@ -9,6 +9,8 @@
 #ifndef REACTOR_CPP_ACTION_HH
 #define REACTOR_CPP_ACTION_HH
 
+#include "environment.hh"
+#include "fwd.hh"
 #include "logical_time.hh"
 #include "reactor.hh"
 #include "value_ptr.hh"
@@ -37,6 +39,12 @@ protected:
       : ReactorElement(name, ReactorElement::Type::Action, container)
       , min_delay_(min_delay)
       , logical_(logical) {}
+  BaseAction(const std::string& name, Environment* environment, bool logical, Duration min_delay)
+      : ReactorElement(name, ReactorElement::Type::Action, environment)
+      , min_delay_(min_delay)
+      , logical_(logical) {
+    environment->register_input_action(this);
+  }
 
 public:
   [[nodiscard]] auto inline triggers() const noexcept -> const auto& { return triggers_; }
@@ -63,6 +71,8 @@ protected:
 
   Action(const std::string& name, Reactor* container, bool logical, Duration min_delay)
       : BaseAction(name, container, logical, min_delay) {}
+  Action(const std::string& name, Environment* environment, bool logical, Duration min_delay)
+      : BaseAction(name, environment, logical, min_delay) {}
 
 public:
   // Normally, we should lock the mutex while moving to make this
@@ -107,6 +117,8 @@ template <> class Action<void> : public BaseAction {
 protected:
   Action(const std::string& name, Reactor* container, bool logical, Duration min_delay)
       : BaseAction(name, container, logical, min_delay) {}
+  Action(const std::string& name, Environment* environment, bool logical, Duration min_delay)
+      : BaseAction(name, environment, logical, min_delay) {}
 
 public:
   template <class Dur = Duration> void schedule(Dur delay = Dur::zero());
@@ -118,7 +130,11 @@ public:
 template <class T> class PhysicalAction : public Action<T> {
 public:
   PhysicalAction(const std::string& name, Reactor* container)
-      : Action<T>(name, container, false, Duration::zero()) {}
+      : Action<T>(name, container, false, Duration::zero()) {
+    // all physical actions act as input actions to the program as they can be
+    // scheduled from external threads
+    container->environment()->register_input_action(this);
+  }
 };
 
 template <class T> class LogicalAction : public Action<T> {

include/reactor-cpp/environment.hh

@@ -13,6 +13,7 @@
 #include <string>
 #include <vector>
 
+#include "fwd.hh"
 #include "reactor-cpp/logging.hh"
 #include "reactor-cpp/time.hh"
 #include "reactor.hh"
@@ -40,6 +41,8 @@ private:
   const bool fast_fwd_execution_{default_fast_fwd_execution};
 
   std::set<Reactor*> top_level_reactors_{};
+  /// Set of actions that act as an input to the reactor program in this environment
+  std::set<BaseAction*> input_actions_{};
   std::set<Reaction*> reactions_{};
   std::vector<Dependency> dependencies_{};
 
@@ -71,6 +74,7 @@ public:
   auto name() -> const std::string& { return name_; }
 
   void register_reactor(Reactor* reactor);
+  void register_input_action(BaseAction* action);
   void assemble();
   auto startup() -> std::thread;
   void sync_shutdown();

lib/environment.cc

@@ -52,6 +52,12 @@ void Environment::register_reactor(Reactor* reactor) {
   reactor_assert(top_level_reactors_.insert(reactor).second);
 }
 
+void Environment::register_input_action(BaseAction* action) {
+  reactor_assert(action != nullptr);
+  validate(this->phase() == Phase::Construction, "Input actions may only be registered during construction phase!");
+  reactor_assert(input_actions_.insert(action).second);
+}
+
 void recursive_assemble(Reactor* container) { // NOLINT
   container->assemble();
   for (auto* reactor : container->reactors()) {