code cleaning

Author: tanneberger

examples/multiport_mutation/consumer.hh

@@ -11,28 +11,27 @@ using namespace reactor;
 using namespace std::chrono_literals;
 
 class Consumer : public Reactor {
-private:
   class Inner: public Scope {
     Inner(Reactor* reactor, std::size_t index) : Scope(reactor), index_(index) {}
-    std::size_t index_;
+    std::size_t index_ = 0;
 
-    [[maybe_unused]] const Inner& __lf_inner = *this;
+    const Inner& _lf_inner = *this;
 
-    void reaction_1([[maybe_unused]] const Input<unsigned>& in) {
-      std::cout << "consumer: " << index_ << " received value:" << *in.get() << std::endl;
+    void reaction_1(const Input<unsigned>& in) const {
+      std::cout << "consumer: " << index_ << " received value:" << *in.get() << '\n';
     }
 
     friend Consumer;
   };
 
-  Inner __lf_inner;
-  Reaction handle{"handle", 1, this, [this]() { __lf_inner.reaction_1(this->in); }};
+  Inner _lf_inner;
+  Reaction handle{"handle", 1, this, [this]() { _lf_inner.reaction_1(this->in); }};
 public:
-  Consumer(const std::string& name, Environment* env, std::size_t index) : Reactor(name, env), __lf_inner(this, index) {
-    std::cout << "creating instance of consumer" << std::endl;
+  Consumer(const std::string& name, Environment* env, std::size_t index) : Reactor(name, env), _lf_inner(this, index) {
+    std::cout << "creating instance of consumer" << '\n';
   }
   ~Consumer() override {
-    std::cout << "Consumer Object is deleted" << std::endl;
+    std::cout << "Consumer Object is deleted" << '\n';
   };
 
   Input<unsigned> in{"in", this};

examples/multiport_mutation/load_balancer.hh

@@ -17,7 +17,7 @@ class LoadBalancer : public Reactor {
 private:
   class Inner: public MutableScope {
     Inner(Reactor* reactor) : MutableScope(reactor) {}
-    [[maybe_unused]] const Inner& __lf_inner = *this;
+    const Inner& __lf_inner = *this;
 
     // reaction bodies
     void reaction_1(const Input<unsigned>& inbound, LogicalAction<unsigned>& scale_action, Multiport<Output<unsigned>>& outbound) {

examples/multiport_mutation/main.cc

@@ -21,40 +21,33 @@ class Deployment : public Reactor {
 
 class Inner: public MutableScope {
     int state = 0;
-    [[maybe_unused]] const Inner& __lf_inner = *this;
+    const Inner& __lf_inner = *this;
 public:
 
     Inner(Reactor* reactor) : MutableScope(reactor) {}
     void reaction_1(const Input<unsigned>& scale, std::vector<std::unique_ptr<Consumer>>& reactor_bank, ModifableMultiport<Output<unsigned>>& load_balancer) {
       std::size_t new_size = *scale.get();
       std::size_t old_size = reactor_bank.size();
 
-      std::function<std::unique_ptr<Consumer>(Reactor*, std::size_t)> lambda = [](Reactor* reactor, std::size_t index) {
+      std::function lambda = [](Reactor* reactor, std::size_t index) {
         std::string __lf_inst_name = "consumer_" + std::to_string(index);
         return std::make_unique<Consumer>(__lf_inst_name, reactor->environment(), index);
       };
+
       auto change_size = std::make_shared<MutationChangeBankSize<std::unique_ptr<Consumer>>>(&reactor_bank, this->reactor_, new_size, lambda);
 
       add_to_transaction(change_size);
 
-      // old topology
       commit_transaction();
-      // new topology
-
-      if (old_size > new_size) {
 
-        for (auto i = 0; i < old_size - new_size; i++) {
-        }
-      } else {
-        std::cout << "load_balancer size:" << load_balancer.size() << " bank size: " << reactor_bank.size() << std::endl;
+      if (old_size < new_size) {
         for (auto i = 0; i < new_size; i++) {
             auto add_conn = std::make_shared<MutationAddConnection<Output<unsigned>, Input<unsigned>>>(&load_balancer[i], &reactor_bank[i].get()->in, reactor_);
             add_to_transaction(add_conn);
         }
-        commit_transaction(true);
       }
 
-      std::cout << "new bank size:" << reactor_bank.size() << std::endl;
+      commit_transaction(true);
     }
 
     friend LoadBalancer;

examples/multiport_mutation/producer.hh

@@ -16,12 +16,14 @@ private:
   Reaction r_timer{"r_timer", 1, this, [this]() { __lf_inner.reaction_1(this->value);}};
 
   class Inner: public Scope {
-    unsigned itr = 0;
-    [[maybe_unused]] const Inner& __lf_inner = *this;
+    unsigned int counter_ = 0;
+    const Inner& __lf_inner = *this;
+
     void reaction_1([[maybe_unused]] Output<unsigned>& out) {
-      std::cout << "producing value:" << itr << std::endl;
-      out.set(itr++);
+      std::cout << "producing value:" << counter_ << std::endl;
+      out.set(counter_++);
     }
+
     explicit Inner(Reactor* reactor) : Scope(reactor) {}
 
     friend Producer;