ReactionChamber renaming, fix for gcc < 13 compiler versions

Author: OmerMajNition

examples/sdk-WorkersParams/main.cc

@@ -160,13 +160,11 @@ class Worker : public Reactor {
     };
 
     PublishParameters parameters;
-    const Duration &processing_delay = parameters.processing_delay.value;
-
-    class Internals : public ReactionInternals<Worker, PublishParameters> {
+    class Chamber : public ReactionChamber<Worker, PublishParameters> {
         const Duration &processing_delay = parameters.processing_delay.value;
     public:
-        Internals(Reactor *reactor, PublishParameters &params)
-            : ReactionInternals<Worker, PublishParameters>(reactor, params) {}
+        Chamber(Reactor *reactor, PublishParameters &params)
+            : ReactionChamber<Worker, PublishParameters>(reactor, params) {}
 
         void add_reactions(Worker *reactor) override {
             reaction("reaction_1").
@@ -220,7 +218,7 @@ class Worker : public Reactor {
 
 
     };
-    Internals reaction_internals{this, parameters};
+    Chamber reaction_chamber{this, parameters};
 
 public:
     Worker(const std::string &name, Environment *env, Parameters &&param)
@@ -260,11 +258,10 @@ class Pool : public Reactor {
     ReactorBank<Worker> workers{"workers", this};
     std::unique_ptr<Relay> relay;
 
-    class Internals : public ReactionInternals<Pool, PublishParameters> {
-        const int &n_workers = parameters.n_workers.value;
+    class Chamber : public ReactionChamber<Pool, PublishParameters> {
     public:
-        Internals(Reactor *reactor, PublishParameters &params)
-            : ReactionInternals<Pool, PublishParameters>(reactor, params) {}
+        Chamber(Reactor *reactor, PublishParameters &params)
+            : ReactionChamber<Pool, PublishParameters>(reactor, params) {}
 
         void add_reactions(Pool *reactor) override {
             reaction("reaction_1").
@@ -293,7 +290,7 @@ class Pool : public Reactor {
 
     };
 
-    Internals reaction_internals{this, parameters};
+    Chamber reaction_chamber{this, parameters};
 
 public:
     Pool(const std::string &name, Environment *env, Parameters &&param)
@@ -333,21 +330,20 @@ class Tasks : public Reactor {
 
 private:
     Parameters parameters;
-    const int &n_tasks = parameters.n_tasks;
     const int &n_pools = parameters.n_pools;
 
     LogicalAction<int> sch{"sch", this};
 
-    class Internals : public ReactionInternals<Tasks, Parameters> {
+    class Chamber : public ReactionChamber<Tasks, Parameters> {
         const int &n_tasks = parameters.n_tasks;
         const int &n_pools = parameters.n_pools;
 
         int req_itr = 0;
         int rsp_itr = 0;
         bool *busy = 0;
     public:
-        Internals(Reactor *reactor, Parameters &params)
-            : ReactionInternals<Tasks, Parameters>(reactor, params) {}
+        Chamber(Reactor *reactor, Parameters &params)
+            : ReactionChamber<Tasks, Parameters>(reactor, params) {}
 
         void add_reactions(Tasks *reactor) override {
             reaction("reaction_1").
@@ -457,7 +453,7 @@ class Tasks : public Reactor {
         }
     };
 
-    Internals reaction_internals{this, parameters};
+    Chamber reaction_chamber{this, parameters};
 
 public:
     Tasks(const std::string &name, Environment *env, Parameters &&param)

examples/sdk-hello/main.cc

@@ -11,7 +11,11 @@ class Hello : public Reactor {
 
     Timer timer{"timer", this};
 
-    REACTION_SCOPE_START(Hello, Parameters)
+    class Chamber : public ReactionChamber<Hello, Parameters> {
+    public:
+        Chamber(Reactor *reactor, Parameters &params)
+            : ReactionChamber<Hello, Parameters>(reactor, params) {}
+    private:
 
         void terminate(Shutdown& shutdown) {
             std::cout   << "(" << get_elapsed_logical_time().count() << ", " << get_microstep() << ") physical_time:" << get_elapsed_physical_time().count()
@@ -36,8 +40,8 @@ class Hello : public Reactor {
                 effects().
                 function(pass_function(terminate));
         }
-
-    REACTION_SCOPE_END(this, parameters)
+    };
+    Chamber reaction_chamber{this, parameters};
 
 public:
     Hello(const std::string &name, Environment *env)

include/reactor-sdk/Misc.hh

@@ -13,7 +13,8 @@ using LogicalAction = reactor::LogicalAction<T>;
 using Startup = reactor::StartupTrigger;
 using Shutdown = reactor::ShutdownTrigger;
 
-using Duration = std::chrono::nanoseconds;
+using Duration = reactor::Duration;
+using TimePoint = reactor::TimePoint;
 
 #define select_default(obj) &obj[0]
 
@@ -77,5 +78,30 @@ public:
     Timer(Timer&&) noexcept = default;
 };
 
+inline auto operator<<(std::ostream& os, Duration dur) -> std::ostream& {
+  os << dur.count() << " nsecs";
+  return os;
+}
+
+constexpr std::size_t TIME_TO_STR_BUFFER_SIZE_{20};
+constexpr std::size_t NANOSECONDS_IN_ONE_SECOND_{1'000'000'000UL};
+constexpr std::size_t NANOSECOND_DIGITS_{9};
+
+inline auto operator<<(std::ostream& os, TimePoint tp) -> std::ostream& {
+  std::array<char, TIME_TO_STR_BUFFER_SIZE_> buf{};
+  time_t time =
+      std::chrono::system_clock::to_time_t(std::chrono::time_point_cast<std::chrono::system_clock::duration>(tp));
+  auto res = std::strftime(buf.data(), sizeof(buf), "%Y-%m-%d %H:%M:%S", std::localtime(&time));
+  auto epoch = std::chrono::duration_cast<Duration>(tp.time_since_epoch());
+
+  if (res != 0) {
+    os << buf.data() << '.' << std::setw(NANOSECOND_DIGITS_) << std::setfill('0')
+       << epoch.count() % NANOSECONDS_IN_ONE_SECOND_;
+  } else {
+    os << "[INVALID TIME]";
+  }
+
+  return os;
+}
 
 } // namespace sdk

include/reactor-sdk/Reaction.hh

@@ -23,7 +23,9 @@ struct is_specialization<Template<Args...>, Template> : std::true_type
 template <typename T, template <typename...> class Template>
 inline constexpr bool is_specialization_v = is_specialization<T, Template>::value;
 
-
+// fix for gcc < 13
+template <typename T>
+constexpr bool templated_false = false;
 
 template <typename InputTuple, typename DependencyTuple, typename OutputTuple>
 class ReactionOutput: public ReactionBase
@@ -113,7 +115,7 @@ public:
     }
 
     // template <typename ReactorType, typename ParameterType>
-    // friend class ReactionInternals;
+    // friend class ReactionChamber;
 };
 
 template <typename Fn, typename InputTuple, typename DependencyTuple, typename OutputTuple>
@@ -204,7 +206,7 @@ private:
         }
         else
         {
-            static_assert(false, "Unsupported trigger type");
+            static_assert(templated_false<Trigger>, "Unsupported trigger type");
         }
     }
 
@@ -219,6 +221,9 @@ private:
             outputs);
     }
 
+    template <typename Reaction>
+    void set_output_triggers(std::unique_ptr<Reaction>& reaction, const std::tuple<>& outputs) {}
+
 public:
     Reaction(std::string name, Reactor *parent, InputTuple inputs, DependencyTuple deps, OutputTuple outputs, Fn func)
         : ReactionBase(name, parent), input_triggers(std::move(inputs)), dependencies(std::move(deps)), output_triggers(std::move(outputs)), user_function(std::forward<Fn>(func)) { /* std::cout << "Creating Reaction\n"; */ }
@@ -274,12 +279,12 @@ public:
 };
 
 template <typename ReactorType>
-class ReactionInternalsParameterless : public ReactionBase {
+class ReactionChamberParameterless : public ReactionBase {
     ReactorType *reactor_;
 protected:
     const size_t &bank_index = reactor_->bank_index;
 public:
-    ReactionInternalsParameterless(Reactor *owner)
+    ReactionChamberParameterless(Reactor *owner)
         : ReactionBase("reaction-internals-parameterless", owner), reactor_((ReactorType*) owner) {
         reactor_->add_reaction_internals(this);
     }
@@ -306,14 +311,14 @@ public:
 };
 
 template <typename ReactorType, typename ParameterType>
-class ReactionInternals : public ReactionBase {
+class ReactionChamber : public ReactionBase {
     ReactorType *reactor_;
 
 protected:
     const ParameterType &parameters;
     const size_t &bank_index = reactor_->bank_index;
 public:
-    ReactionInternals(Reactor *owner, ParameterType &param)
+    ReactionChamber(Reactor *owner, ParameterType &param)
         : ReactionBase("reaction-internals", owner), reactor_((ReactorType*) owner), parameters(param) {
         reactor_->add_reaction_internals(this);
     }
@@ -340,21 +345,21 @@ public:
 };
 
 #define REACTION_SCOPE_START(ReactorType, ParamType) \
-class Internals : public ReactionInternals<ReactorType, ParamType> { \
+class Internals : public ReactionChamber<ReactorType, ParamType> { \
 public: \
     Internals(Reactor *reactor, ParamType &params) \
-        : ReactionInternals<ReactorType, ParamType>(reactor, params) {} \
+        : ReactionChamber<ReactorType, ParamType>(reactor, params) {} \
 private:
 
 #define REACTION_SCOPE_END(reactor, param) \
 }; \
 Internals reaction_internals{reactor, param};
 
 #define REACTION_SCOPE_START_NO_PARAMS(ReactorType) \
-class Internals : public ReactionInternalsParameterless<ReactorType> { \
+class Internals : public ReactionChamberParameterless<ReactorType> { \
 public: \
     Internals(Reactor *reactor) \
-        : ReactionInternalsParameterless<ReactorType>(reactor) {} \
+        : ReactionChamberParameterless<ReactorType>(reactor) {} \
 private:
 
 #define REACTION_SCOPE_END_NO_PARAMS(reactor) \