Use an enum to make a parameter explicit instead of a true/false value

diff --git a/ChangeLog b/ChangeLog
index 81d73c6..43e5acd 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -26,6 +26,7 @@ C API:
 
 Plugins:
  - Revamp the battery plugin: rewrite completely the API, for a better usability.
+   The examples were updated accordingly.
 
 ----------------------------------------------------------------------------
 

diff --git a/examples/cpp/battery-degradation/s4u-battery-degradation.cpp b/examples/cpp/battery-degradation/s4u-battery-degradation.cpp
index 1099c6d..9510404 100644 (file)
--- a/examples/cpp/battery-degradation/s4u-battery-degradation.cpp
+++ b/examples/cpp/battery-degradation/s4u-battery-degradation.cpp
@@ -16,22 +16,25 @@ static void manager()
 
   battery->set_load("load", 100);
 
-  auto handler1 = battery->schedule_handler(0.2, simgrid::plugins::Battery::DISCHARGE, true, [battery]() {
-    XBT_INFO("%f,%f,SoC", simgrid::s4u::Engine::get_clock(), battery->get_state_of_charge());
-    XBT_INFO("%f,%f,SoH", simgrid::s4u::Engine::get_clock(), battery->get_state_of_health());
-    battery->set_load("load", -100);
-  });
+  auto handler1 = battery->schedule_handler(
+      0.2, simgrid::plugins::Battery::DISCHARGE, simgrid::plugins::Battery::Handler::PERSISTANT, [battery]() {
+        XBT_INFO("%f,%f,SoC", simgrid::s4u::Engine::get_clock(), battery->get_state_of_charge());
+        XBT_INFO("%f,%f,SoH", simgrid::s4u::Engine::get_clock(), battery->get_state_of_health());
+        battery->set_load("load", -100);
+      });
 
   std::shared_ptr<simgrid::plugins::Battery::Handler> handler2;
-  handler2 = battery->schedule_handler(0.8, simgrid::plugins::Battery::CHARGE, true, [battery, handler1, handler2]() {
-    XBT_INFO("%f,%f,SoC", simgrid::s4u::Engine::get_clock(), battery->get_state_of_charge());
-    XBT_INFO("%f,%f,SoH", simgrid::s4u::Engine::get_clock(), battery->get_state_of_health());
-    if (battery->get_state_of_health() < 0.1) {
-      battery->delete_handler(handler1);
-      battery->delete_handler(handler2);
-    }
-    battery->set_load("load", 100);
-  });
+  handler2 = battery->schedule_handler(
+      0.8, simgrid::plugins::Battery::CHARGE, simgrid::plugins::Battery::Handler::PERSISTANT,
+      [battery, handler1, handler2]() {
+        XBT_INFO("%f,%f,SoC", simgrid::s4u::Engine::get_clock(), battery->get_state_of_charge());
+        XBT_INFO("%f,%f,SoH", simgrid::s4u::Engine::get_clock(), battery->get_state_of_health());
+        if (battery->get_state_of_health() < 0.1) {
+          battery->delete_handler(handler1);
+          battery->delete_handler(handler2);
+        }
+        battery->set_load("load", 100);
+      });
 }
 
 int main(int argc, char* argv[])

diff --git a/examples/cpp/battery-energy/s4u-battery-energy.cpp b/examples/cpp/battery-energy/s4u-battery-energy.cpp
index d3bea29..c50ef02 100644 (file)
--- a/examples/cpp/battery-energy/s4u-battery-energy.cpp
+++ b/examples/cpp/battery-energy/s4u-battery-energy.cpp
@@ -19,17 +19,19 @@ static void manager()
   auto* host2 = simgrid::s4u::Engine::get_instance()->host_by_name("MyHost2");
   auto* host3 = simgrid::s4u::Engine::get_instance()->host_by_name("MyHost3");
 
-  battery->schedule_handler(0.2, simgrid::plugins::Battery::DISCHARGE, true, [battery, &host1, &host2, &host3]() {
-    XBT_INFO("Handler -> Battery low: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
-             battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
-             battery->get_energy_provided(), battery->get_energy_consumed());
-    XBT_INFO("Disconnecting hosts %s and %s", host1->get_cname(), host2->get_cname());
-    battery->connect_host(host1, false);
-    battery->connect_host(host2, false);
-    XBT_INFO("Energy consumed this far by: %s: %fJ, %s: %fJ, %s: %fJ", host1->get_cname(),
-             sg_host_get_consumed_energy(host1), host2->get_cname(), sg_host_get_consumed_energy(host2),
-             host3->get_cname(), sg_host_get_consumed_energy(host3));
-  });
+  battery->schedule_handler(
+      0.2, simgrid::plugins::Battery::DISCHARGE, simgrid::plugins::Battery::Handler::PERSISTANT,
+      [battery, &host1, &host2, &host3]() {
+        XBT_INFO("Handler -> Battery low: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
+                 battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
+                 battery->get_energy_provided(), battery->get_energy_consumed());
+        XBT_INFO("Disconnecting hosts %s and %s", host1->get_cname(), host2->get_cname());
+        battery->connect_host(host1, false);
+        battery->connect_host(host2, false);
+        XBT_INFO("Energy consumed this far by: %s: %fJ, %s: %fJ, %s: %fJ", host1->get_cname(),
+                 sg_host_get_consumed_energy(host1), host2->get_cname(), sg_host_get_consumed_energy(host2),
+                 host3->get_cname(), sg_host_get_consumed_energy(host3));
+      });
 
   XBT_INFO("Battery state: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
            battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),

diff --git a/examples/cpp/battery-simple/s4u-battery-simple.cpp b/examples/cpp/battery-simple/s4u-battery-simple.cpp
index 510d33f..04eb4f6 100644 (file)
--- a/examples/cpp/battery-simple/s4u-battery-simple.cpp
+++ b/examples/cpp/battery-simple/s4u-battery-simple.cpp
@@ -27,20 +27,22 @@ int main(int argc, char* argv[])
   battery->set_load("load", load_w);
   XBT_INFO("Set load to %fW", load_w);
 
-  battery->schedule_handler(0.2, simgrid::plugins::Battery::DISCHARGE, true, [battery, &load_w]() {
-    XBT_INFO("Discharged state: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
-             battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
-             battery->get_energy_provided(), battery->get_energy_consumed());
-    battery->set_load("load", -load_w);
-    XBT_INFO("Set load to %fW", -load_w);
-  });
-
-  battery->schedule_handler(0.8, simgrid::plugins::Battery::CHARGE, true, [battery]() {
-    XBT_INFO("Charged state: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
-             battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
-             battery->get_energy_provided(), battery->get_energy_consumed());
-    XBT_INFO("Set load to %fW", 0.0);
-  });
+  battery->schedule_handler(
+      0.2, simgrid::plugins::Battery::DISCHARGE, simgrid::plugins::Battery::Handler::PERSISTANT, [battery, &load_w]() {
+        XBT_INFO("Discharged state: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
+                 battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
+                 battery->get_energy_provided(), battery->get_energy_consumed());
+        battery->set_load("load", -load_w);
+        XBT_INFO("Set load to %fW", -load_w);
+      });
+
+  battery->schedule_handler(
+      0.8, simgrid::plugins::Battery::CHARGE, simgrid::plugins::Battery::Handler::PERSISTANT, [battery]() {
+        XBT_INFO("Charged state: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
+                 battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
+                 battery->get_energy_provided(), battery->get_energy_consumed());
+        XBT_INFO("Set load to %fW", 0.0);
+      });
 
   e.run();
   return 0;

diff --git a/include/simgrid/plugins/battery.hpp b/include/simgrid/plugins/battery.hpp
index 51f20c3..7f0c361 100644 (file)
--- a/include/simgrid/plugins/battery.hpp
+++ b/include/simgrid/plugins/battery.hpp
@@ -39,16 +39,19 @@ public:
   class Handler {
     friend Battery;
 
+  public:
+    enum Persistancy { PERSISTANT, ONESHOT };
+
   private:
     double state_of_charge_;
     Flow flow_;
     double time_delta_ = -1;
     std::function<void()> callback_;
-    bool repeat_;
+    Persistancy persistancy_;
 
   public:
-    Handler(double state_of_charge, Flow flow, bool repeat, std::function<void()> callback);
-    static std::shared_ptr<Handler> init(double state_of_charge, Flow flow, bool repeat,
+    Handler(double state_of_charge, Flow flow, Persistancy p, std::function<void()> callback);
+    static std::shared_ptr<Handler> init(double state_of_charge, Flow flow, Persistancy p,
                                          std::function<void()> callback);
 
     /** @ingroup plugin_battery
@@ -77,7 +80,7 @@ public:
      *  @return true if its a recurrent Handler.
      *  @note For Battery::Handler objects
      */
-    bool get_repeat() { return repeat_; }
+    Persistancy get_persistancy() { return persistancy_; }
   };
 
 private:
@@ -132,7 +135,7 @@ public:
   double get_energy_provided();
   double get_energy_consumed();
   double get_energy_stored(std::string unit = "J");
-  std::shared_ptr<Handler> schedule_handler(double state_of_charge, Flow flow, bool repeat,
+  std::shared_ptr<Handler> schedule_handler(double state_of_charge, Flow flow, Handler::Persistancy p,
                                             std::function<void()> callback);
   std::vector<std::shared_ptr<Handler>> get_handlers();
   void delete_handler(std::shared_ptr<Handler> handler);

diff --git a/src/plugins/battery.cpp b/src/plugins/battery.cpp
index 3a870f9..73da963 100644 (file)
--- a/src/plugins/battery.cpp
+++ b/src/plugins/battery.cpp
@@ -117,15 +117,15 @@ double BatteryModel::next_occurring_event(double now)
 
 /* Handler */
 
-Battery::Handler::Handler(double state_of_charge, Flow flow,  bool repeat, std::function<void()> callback)
-    : state_of_charge_(state_of_charge), flow_(flow), callback_(callback), repeat_(repeat)
+Battery::Handler::Handler(double state_of_charge, Flow flow, Persistancy p, std::function<void()> callback)
+    : state_of_charge_(state_of_charge), flow_(flow), callback_(callback), persistancy_(p)
 {
 }
 
-std::shared_ptr<Battery::Handler> Battery::Handler::init(double state_of_charge, Flow flow, bool repeat,
+std::shared_ptr<Battery::Handler> Battery::Handler::init(double state_of_charge, Flow flow, Persistancy p,
                                                          std::function<void()> callback)
 {
-  return std::make_shared<Battery::Handler>(state_of_charge, flow, repeat, callback);
+  return std::make_shared<Battery::Handler>(state_of_charge, flow, p, callback);
 }
 
 /* Battery */
@@ -193,7 +193,7 @@ void Battery::update()
     for (auto handler : handlers_) {
       if (abs(handler->time_delta_ - time_delta_s) < 0.000000001) {
         handler->callback_();
-        if (handler->repeat_)
+        if (handler->persistancy_ == Handler::Persistancy::PERSISTANT)
           handler->time_delta_ = -1;
         else
           to_delete.push_back(handler);
@@ -389,12 +389,13 @@ double Battery::get_energy_stored(std::string unit)
  *  @param state_of_charge The state of charge at which the Handler will happen.
  *  @param flow The flow in which the Handler will happen, either when the Battery is charging or discharging.
  *  @param callback The callable to trigger when the Handler happen.
- *  @param repeat If the Handler is recurrent or unique.
+ *  @param Persistancy If the Handler is recurrent or unique.
  *  @return A shared pointer of the new Handler.
  */
-std::shared_ptr<Battery::Handler> Battery::schedule_handler(double state_of_charge, Flow flow, bool repeat, std::function<void()> callback)
+std::shared_ptr<Battery::Handler> Battery::schedule_handler(double state_of_charge, Flow flow, Handler::Persistancy p,
+                                                            std::function<void()> callback)
 {
-  auto handler = Handler::init(state_of_charge, flow, repeat, callback);
+  auto handler = Handler::init(state_of_charge, flow, p, callback);
   handlers_.push_back(handler);
   return handler;
 }