bugfix, don't use unitialized type attribute of ports

Author: cmnrd

include/reactor-cpp/port.hh

@@ -29,7 +29,10 @@ class BasePort : public ReactorElement {
 
  protected:
   BasePort(const std::string& name, PortType type, Reactor* container)
-      : ReactorElement(name, ReactorElement::Type::Port, container)
+      : ReactorElement(name,
+                       type == PortType::Input ? ReactorElement::Type::Input
+                                               : ReactorElement::Type::Output,
+                       container)
       , type(type) {}
 
   void base_bind_to(BasePort* port);
@@ -89,7 +92,6 @@ class Port : public BasePort {
 
   const ImmutableValuePtr<T>& get() const;
   bool is_present() const;
-
 };
 
 template <>

include/reactor-cpp/reactor.hh

@@ -19,7 +19,7 @@ namespace reactor {
 
 class ReactorElement {
  public:
-  enum class Type { Action, Port, Reaction, Reactor };
+  enum class Type { Action, Input, Output, Reaction, Reactor };
 
  private:
   const std::string _name;
@@ -62,7 +62,8 @@ class Reactor : public ReactorElement {
   std::set<Reactor*> _reactors;
 
   void register_action(BaseAction* action);
-  void register_port(BasePort* port);
+  void register_input(BasePort* port);
+  void register_output(BasePort* port);
   void register_reaction(Reaction* reaction);
   void register_reactor(Reactor* reactor);
 

lib/reactor.cc

@@ -37,8 +37,11 @@ ReactorElement::ReactorElement(const std::string& name,
     case Type::Action:
       container->register_action(reinterpret_cast<BaseAction*>(this));
       break;
-    case Type::Port:
-      container->register_port(reinterpret_cast<BasePort*>(this));
+    case Type::Input:
+      container->register_input(reinterpret_cast<BasePort*>(this));
+      break;
+    case Type::Output:
+      container->register_output(reinterpret_cast<BasePort*>(this));
       break;
     case Type::Reaction:
       container->register_reaction(reinterpret_cast<Reaction*>(this));
@@ -73,29 +76,34 @@ Reactor::Reactor(const std::string& name, Environment* environment)
   environment->register_reactor(this);
 }
 
-void Reactor::register_action([[maybe_unused]]BaseAction* action) {
+void Reactor::register_action([[maybe_unused]] BaseAction* action) {
   toggle_assert(action != nullptr);
-  reactor::validate(this->environment()->phase() == Environment::Phase::Construction,
-           "Actions can only be registered during construction phase!");
+  reactor::validate(
+      this->environment()->phase() == Environment::Phase::Construction,
+      "Actions can only be registered during construction phase!");
   toggle_assert(_actions.insert(action).second);
 }
-void Reactor::register_port(BasePort* port) {
+void Reactor::register_input(BasePort* port) {
   toggle_assert(port != nullptr);
-  reactor::validate(this->environment()->phase() == Environment::Phase::Construction,
-           "Ports can only be registered during construction phase!");
-  if (port->is_input()) {
-    toggle_assert(_inputs.insert(port).second);
-  } else {
-    toggle_assert(_outputs.insert(port).second);
-  }
+  reactor::validate(
+      this->environment()->phase() == Environment::Phase::Construction,
+      "Ports can only be registered during construction phase!");
+  toggle_assert(_inputs.insert(port).second);
+}
+void Reactor::register_output(BasePort* port) {
+  toggle_assert(port != nullptr);
+  reactor::validate(
+      this->environment()->phase() == Environment::Phase::Construction,
+      "Ports can only be registered during construction phase!");
+  toggle_assert(_outputs.insert(port).second);
 }
-void Reactor::register_reaction([[maybe_unused]]Reaction* reaction) {
+void Reactor::register_reaction([[maybe_unused]] Reaction* reaction) {
   toggle_assert(reaction != nullptr);
   validate(this->environment()->phase() == Environment::Phase::Construction,
            "Reactions can only be registered during construction phase!");
   toggle_assert(_reactions.insert(reaction).second);
 }
-void Reactor::register_reactor([[maybe_unused]]Reactor* reactor) {
+void Reactor::register_reactor([[maybe_unused]] Reactor* reactor) {
   toggle_assert(reactor != nullptr);
   validate(this->environment()->phase() == Environment::Phase::Construction,
            "Reactions can only be registered during construction phase!");