added reaction internals class that would help users define reactions for reactors and would make sure user functions don't use unintended ports and actions

Author: OmerMajNition

examples/sdk-WorkersParams/main.cc

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "reactor-cpp/reactor-cpp.hh"
-#include "BaseTrigger.hh"
+#include "ReactionBase.hh"
 #include "Reactor.hh"
 
 namespace sdk
@@ -26,7 +26,7 @@ inline constexpr bool is_specialization_v = is_specialization<T, Template>::valu
 
 
 template <typename InputTuple, typename DependencyTuple, typename OutputTuple>
-class ReactionOutput: public BaseTrigger
+class ReactionOutput: public ReactionBase
 {
 private:
     InputTuple input_triggers;
@@ -35,28 +35,32 @@ private:
 
 public:
     explicit ReactionOutput(std::string name, Reactor *parent, InputTuple inputs, DependencyTuple deps, OutputTuple outputs)
-        : BaseTrigger (name, parent), input_triggers(std::move(inputs)), dependencies(std::move(deps)), output_triggers(std::move(outputs)) {}
+        : ReactionBase (name, parent), input_triggers(std::move(inputs)), dependencies(std::move(deps)), output_triggers(std::move(outputs)) {}
     ~ReactionOutput() {}
 
     template <typename Fn>
     Reaction<Fn, InputTuple, DependencyTuple, OutputTuple> &function(Fn func)
     {
+        if (sizeof(func) != sizeof(void*)) {
+            reactor::log::Error() << "Reactor: " << reactor->fqn() << " Reaction: " << name << " Accesses variables outside of its scope";
+            exit(EXIT_FAILURE);
+        }
         auto ReactionRef = std::make_shared<Reaction<Fn, InputTuple, DependencyTuple, OutputTuple>> (name, reactor, std::move(input_triggers), std::move(dependencies), std::move(output_triggers), std::forward<Fn>(func));
         ReactionRef->execute();
         return *ReactionRef;
     }
 };
 
 template <typename InputTuple, typename DependencyTuple>
-class ReactionDependency: public BaseTrigger
+class ReactionDependency: public ReactionBase
 {
 private:
     InputTuple input_triggers;
     DependencyTuple dependencies;
 
 public:
     explicit ReactionDependency(std::string name, Reactor *parent, InputTuple inputs, DependencyTuple deps)
-        : BaseTrigger (name, parent), input_triggers(inputs), dependencies(std::move(deps)) {}
+        : ReactionBase (name, parent), input_triggers(inputs), dependencies(std::move(deps)) {}
     ~ReactionDependency() {}
 
     template <typename... Outputs>
@@ -70,14 +74,14 @@ public:
 };
 
 template <typename InputTuple>
-class ReactionInput: public BaseTrigger
+class ReactionInput: public ReactionBase
 {
 private:
     InputTuple input_triggers;
 
 public:
     explicit ReactionInput(std::string name, Reactor *parent, InputTuple inputs)
-        : BaseTrigger (name, parent), input_triggers(std::move(inputs)) {}
+        : ReactionBase (name, parent), input_triggers(std::move(inputs)) {}
     ~ReactionInput() {}
 
     template <typename... Dependencies>
@@ -90,8 +94,27 @@ public:
     }
 };
 
+class ReactionName: public ReactionBase {
+public:
+    explicit ReactionName(std::string name, Reactor *parent)
+        : ReactionBase (name, parent) {}
+    ~ReactionName() = default;
+
+    template <typename... Inputs>
+    ReactionInput<std::tuple<Inputs...>> &triggers(Inputs&&... inputs)
+    {
+        auto input_tuple = std::make_tuple(inputs...);
+        auto ReactionInputRef = std::make_shared<ReactionInput<std::tuple<Inputs...>>> (name, reactor, std::move(input_tuple));
+        next = ReactionInputRef;
+        return *ReactionInputRef;
+    }
+
+    // template <typename ReactorType, typename ParameterType>
+    // friend class ReactionInternals;
+};
+
 template <typename Fn, typename InputTuple, typename DependencyTuple, typename OutputTuple>
-class Reaction: public BaseTrigger
+class Reaction: public ReactionBase
 {
 private:
     InputTuple input_triggers;
@@ -195,7 +218,7 @@ private:
 
 public:
     Reaction(std::string name, Reactor *parent, InputTuple inputs, DependencyTuple deps, OutputTuple outputs, Fn func)
-        : BaseTrigger(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"; */ }
+        : 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"; */ }
     ~Reaction() {}
 
     void execute () {
@@ -222,7 +245,6 @@ public:
         set_input_triggers(reaction, input_triggers);
         set_dependencies(reaction, dependencies);
         set_output_triggers(reaction, output_triggers);
-        
     }
 
     template <typename Dfn>
@@ -248,4 +270,34 @@ public:
     }
 };
 
+template <typename ReactorType, typename ParameterType>
+class ReactionInternals : public ReactionBase {
+    ReactorType *reactor_;
+
+protected:
+    const ParameterType &parameters;
+public:
+    ReactionInternals(Reactor *owner, ParameterType &param)
+        : ReactionBase("reaction-internals", owner), reactor_((ReactorType*) owner), parameters(param) {
+        reactor_->add_reaction_internals(this);
+    }
+
+    ReactionName &reaction (const std::string name) {
+        auto ReactionNameRef = std::make_shared<ReactionName>(name, reactor);
+        next = ReactionNameRef;
+        return *ReactionNameRef;
+    }
+
+    virtual void add_reactions(ReactorType *reactor) = 0;
+    virtual void assemble() override {
+        add_reactions(reactor_);
+    }
+
+    auto fqn() const noexcept -> const std::string& { return reactor_->fqn(); }
+    auto get_elapsed_logical_time() const noexcept -> Duration { return reactor_->get_elapsed_logical_time(); }
+    auto get_microstep() const noexcept -> reactor::mstep_t { return reactor_->get_microstep(); }
+    auto get_elapsed_physical_time() const noexcept -> Duration { return reactor_->get_elapsed_physical_time(); }
+    void request_stop() { reactor_->environment()->sync_shutdown(); }
+};
+
 } // namespace sdk

include/reactor-sdk/BaseTrigger.hh

@@ -0,0 +1,22 @@
+#pragma once
+
+namespace sdk
+{
+class Reactor;
+
+class ReactionBase : public std::enable_shared_from_this<ReactionBase>
+{
+public:
+    Reactor *reactor;
+    std::shared_ptr<ReactionBase> next;
+    std::string name;
+
+public:
+    ReactionBase(std::string name, Reactor *parent)
+    : reactor(parent), next(nullptr), name(name) {}
+    virtual ~ReactionBase() = default;
+
+    virtual void assemble() {}
+};
+    
+} // namespace sdk

include/reactor-sdk/Reaction.hh

@@ -2,7 +2,7 @@
 
 #include "reactor-cpp/reactor-cpp.hh"
 #include <string.h>
-#include "BaseTrigger.hh"
+#include "ReactionBase.hh"
 #include "SystemParameterBase.hh"
 #include "Environment.hh"
 
@@ -91,14 +91,14 @@ private:
     SystemParameterBase *p_param = nullptr;
     Environment *env{nullptr};
     Reactor *parent{nullptr};
-    std::string current_reaction_name;
-    std::unordered_map<std::string, std::shared_ptr<BaseTrigger>> reaction_map;
+    std::unordered_map<std::string, std::shared_ptr<ReactionBase>> reaction_map;
+    ReactionBase *reaction_internals_;
     int priority = 1;
     std::set<Reactor*> child_reactors;
     std::string homog_name = "";
 
     void add_child(Reactor* reactor);
-    void add_to_reaction_map (std::string &name, std::shared_ptr<BaseTrigger> reaction);
+    void add_to_reaction_map (std::string &name, std::shared_ptr<ReactionBase> reaction);
     int get_priority() { return priority++;}
 
     template <typename Fn, typename... InputTriggers, typename... Dependencies, typename... OutputTriggers>
@@ -125,38 +125,21 @@ public:
     Reactor(const std::string &name, Environment *env);
     Reactor(const std::string &name, Reactor *container);
 
+    void add_reaction_internals (ReactionBase* internals) {
+        reaction_internals_ = internals;
+    }
+
     static std::string BankName(const std::string& name);
     static std::string HomogName(const std::string& name);
 
     void set_param (SystemParameterBase *param) { p_param = param; }
 
     Environment *get_env() { return env; }
 
-    Reactor &reaction (const std::string name);
-
     auto homog_fqn() const noexcept -> const std::string& { return homog_name; }
 
-    template <typename... Inputs>
-    ReactionInput<std::tuple<Inputs...>> &operator()(Inputs&&... inputs)
-    {
-        auto input_tuple = std::make_tuple(inputs...);
-        auto ReactionInputRef = std::make_shared<ReactionInput<std::tuple<Inputs...>>> (current_reaction_name, this, std::move(input_tuple));
-        reaction_map[current_reaction_name] = ReactionInputRef;
-        return *ReactionInputRef;
-    }
-
-    template <typename... Inputs>
-    ReactionInput<std::tuple<Inputs...>> &triggers(Inputs&&... inputs)
-    {
-        auto input_tuple = std::make_tuple(inputs...);
-        auto ReactionInputRef = std::make_shared<ReactionInput<std::tuple<Inputs...>>> (current_reaction_name, this, std::move(input_tuple));
-        reaction_map[current_reaction_name] = ReactionInputRef;
-        return *ReactionInputRef;
-    }
-
-    void request_stop() { environment()->sync_shutdown(); }
     virtual void construction() = 0;
-    virtual void assembling() = 0;
+    virtual void wiring() = 0;
     void construct() override;
     void assemble() override;
 

include/reactor-sdk/ReactionBase.hh

@@ -47,7 +47,7 @@ struct ParameterMetadata {
     ParameterMetadata<Type> variable_name = ParameterMetadata<Type>{ #variable_name, description, min_value, max_value, default_value, #Type }
 
 template <typename... ParameterValueType>
-class SystemParameter : public SystemParameterBase {
+class SystemParametersStandalone : public SystemParameterBase {
 public:
     using ParameterValue = std::variant<ParameterMetadata<ParameterValueType>*...>;
 
@@ -56,7 +56,7 @@ public:
         ParameterValue param;
     };
 
-    SystemParameter(Reactor *owner)
+    SystemParametersStandalone(Reactor *owner)
     : reactor(owner), env(owner->get_env()) {
         reactor->set_param (this);
     }
@@ -142,11 +142,11 @@ private:
 };
 
 template <typename Defaults, typename... ParameterValueType>
-class SystemParameterWithDefault : public SystemParameter<ParameterValueType...> {
+class SystemParameters : public SystemParametersStandalone<ParameterValueType...> {
 public:
     Defaults defaults;
-    SystemParameterWithDefault(Reactor *owner, Defaults &&param)
-    : SystemParameter<ParameterValueType...>(owner), defaults(std::forward<Defaults>(param)) {}
+    SystemParameters(Reactor *owner, Defaults &&param)
+    : SystemParametersStandalone<ParameterValueType...>(owner), defaults(std::forward<Defaults>(param)) {}
 };
 
 } // namespace sdk

include/reactor-sdk/Reactor.hh

@@ -44,23 +44,21 @@ void Reactor::add_child(Reactor* reactor) {
     reactor_assert(result);
 }
 
-void Reactor::add_to_reaction_map (std::string &name, std::shared_ptr<BaseTrigger> reaction) {
+void Reactor::add_to_reaction_map (std::string &name, std::shared_ptr<ReactionBase> reaction) {
     reaction_map[name] = reaction;
 }
 
-Reactor &Reactor::reaction (const std::string name) {
-    current_reaction_name = name;
-    return *this;
-}
-
 void Reactor::construct() {
     if (p_param) {
         p_param->fetch_config();
     }
     construction();
 }
 void Reactor::assemble() {
-    assembling();
+    if (reaction_internals_) {
+        reaction_internals_->assemble();
+    }
+    wiring();
 }
 
 void Reactor::populate_params(std::set<std::string> &types, std::map<std::string, std::string> &homog_map_entries, std::map<std::string, std::string> &hetero_map_entries) {