enum class for e_s4u_activity_state_t

diff --git a/include/simgrid/s4u/Activity.hpp b/include/simgrid/s4u/Activity.hpp
index c508d9d..c68bcc9 100644 (file)
--- a/include/simgrid/s4u/Activity.hpp
+++ b/include/simgrid/s4u/Activity.hpp
@@ -9,8 +9,6 @@
 #include <simgrid/s4u/forward.hpp>
 #include <simgrid/forward.h>
 
-enum e_s4u_activity_state_t { inited = 0, started, canceled, errored, finished };
-
 namespace simgrid {
 namespace s4u {
 
@@ -34,6 +32,8 @@ public:
   Activity(Activity const&) = delete;
   Activity& operator=(Activity const&) = delete;
 
+  enum class State { inited = 0, started, canceled, errored, finished };
+
   /** Starts a previously created activity.
    *
    * This function is optional: you can call wait() even if you didn't call start()
@@ -49,7 +49,7 @@ public:
   /** Cancel that activity */
   //virtual void cancel();
   /** Retrieve the current state of the activity */
-  e_s4u_activity_state_t getState() {return state_;}
+  Activity::State getState() { return state_; }
 
   /** Get the remaining amount of work that this Activity entails. When it's 0, it's done. */
   virtual double getRemains();
@@ -69,7 +69,7 @@ public:
 
 private:
   simgrid::kernel::activity::ActivityImplPtr pimpl_ = nullptr;
-  e_s4u_activity_state_t state_ = inited;
+  Activity::State state_                            = Activity::State::inited;
   double remains_ = 0;
   void* user_data_                                  = nullptr;
 }; // class

diff --git a/include/simgrid/s4u/Comm.hpp b/include/simgrid/s4u/Comm.hpp
index 077718b..35d601a 100644 (file)
--- a/include/simgrid/s4u/Comm.hpp
+++ b/include/simgrid/s4u/Comm.hpp
@@ -44,9 +44,9 @@ public:
       intrusive_ptr_release(*(simgrid::kernel::activity::ActivityImpl**)ptr);
     });
     for (auto const& comm : *comms_in) {
-      if (comm->state_ == inited)
+      if (comm->state_ == Activity::State::inited)
         comm->start();
-      xbt_assert(comm->state_ == started);
+      xbt_assert(comm->state_ == Activity::State::started);
       simgrid::kernel::activity::ActivityImpl* ptr = comm->pimpl_.get();
       intrusive_ptr_add_ref(ptr);
       xbt_dynar_push_as(comms, simgrid::kernel::activity::ActivityImpl*, ptr);

diff --git a/src/s4u/s4u_activity.cpp b/src/s4u/s4u_activity.cpp
index d2cc31b..daceb75 100644 (file)
--- a/src/s4u/s4u_activity.cpp
+++ b/src/s4u/s4u_activity.cpp
@@ -22,7 +22,7 @@ double Activity::getRemains()
 
 Activity* Activity::setRemains(double remains)
 {
-  xbt_assert(state_ == inited, "Cannot change the remaining amount of work once the Activity is started");
+  xbt_assert(state_ == State::inited, "Cannot change the remaining amount of work once the Activity is started");
   remains_ = remains;
   return this;
 }

diff --git a/src/s4u/s4u_comm.cpp b/src/s4u/s4u_comm.cpp
index f2ab1fd..549b1bf 100644 (file)
--- a/src/s4u/s4u_comm.cpp
+++ b/src/s4u/s4u_comm.cpp
@@ -15,8 +15,8 @@ namespace simgrid {
 namespace s4u {
 Comm::~Comm()
 {
-  if (state_ == started && not detached_ && (pimpl_ == nullptr || pimpl_->state == SIMIX_RUNNING)) {
-    XBT_INFO("Comm %p freed before its completion. Detached: %d, State: %d", this, detached_, state_);
+  if (state_ == State::started && not detached_ && (pimpl_ == nullptr || pimpl_->state == SIMIX_RUNNING)) {
+    XBT_INFO("Comm %p freed before its completion. Detached: %d, State: %d", this, detached_, (int)state_);
     if (pimpl_ != nullptr)
       XBT_INFO("pimpl_->state: %d", pimpl_->state);
     else
@@ -27,27 +27,27 @@ Comm::~Comm()
 
 Activity* Comm::setRate(double rate)
 {
-  xbt_assert(state_==inited);
+  xbt_assert(state_ == State::inited);
   rate_ = rate;
   return this;
 }
 
 Activity* Comm::setSrcData(void* buff)
 {
-  xbt_assert(state_==inited);
+  xbt_assert(state_ == State::inited);
   xbt_assert(dstBuff_ == nullptr, "Cannot set the src and dst buffers at the same time");
   srcBuff_ = buff;
   return this;
 }
 Activity* Comm::setSrcDataSize(size_t size)
 {
-  xbt_assert(state_==inited);
+  xbt_assert(state_ == State::inited);
   srcBuffSize_ = size;
   return this;
 }
 Activity* Comm::setSrcData(void* buff, size_t size)
 {
-  xbt_assert(state_==inited);
+  xbt_assert(state_ == State::inited);
 
   xbt_assert(dstBuff_ == nullptr, "Cannot set the src and dst buffers at the same time");
   srcBuff_ = buff;
@@ -56,18 +56,18 @@ Activity* Comm::setSrcData(void* buff, size_t size)
 }
 Activity* Comm::setDstData(void** buff)
 {
-  xbt_assert(state_==inited);
+  xbt_assert(state_ == State::inited);
   xbt_assert(srcBuff_ == nullptr, "Cannot set the src and dst buffers at the same time");
   dstBuff_ = buff;
   return this;
 }
 size_t Comm::getDstDataSize(){
-  xbt_assert(state_==finished);
+  xbt_assert(state_ == State::finished);
   return dstBuffSize_;
 }
 Activity* Comm::setDstData(void** buff, size_t size)
 {
-  xbt_assert(state_==inited);
+  xbt_assert(state_ == State::inited);
 
   xbt_assert(srcBuff_ == nullptr, "Cannot set the src and dst buffers at the same time");
   dstBuff_ = buff;
@@ -77,7 +77,7 @@ Activity* Comm::setDstData(void** buff, size_t size)
 
 Activity* Comm::start()
 {
-  xbt_assert(state_ == inited);
+  xbt_assert(state_ == State::inited);
 
   if (srcBuff_ != nullptr) { // Sender side
     pimpl_ = simcall_comm_isend(sender_, mailbox_->getImpl(), remains_, rate_, srcBuff_, srcBuffSize_, matchFunction_,
@@ -90,7 +90,7 @@ Activity* Comm::start()
   } else {
     xbt_die("Cannot start a communication before specifying whether we are the sender or the receiver");
   }
-  state_ = started;
+  state_ = State::started;
   return this;
 }
 
@@ -109,10 +109,10 @@ Activity* Comm::wait()
 Activity* Comm::wait(double timeout)
 {
   switch (state_) {
-    case finished:
+    case State::finished:
       return this;
 
-    case inited: // It's not started yet. Do it in one simcall
+    case State::inited: // It's not started yet. Do it in one simcall
       if (srcBuff_ != nullptr) {
         simcall_comm_send(sender_, mailbox_->getImpl(), remains_, rate_, srcBuff_, srcBuffSize_, matchFunction_,
                           copyDataFunction_, user_data_, timeout);
@@ -120,12 +120,12 @@ Activity* Comm::wait(double timeout)
         simcall_comm_recv(receiver_, mailbox_->getImpl(), dstBuff_, &dstBuffSize_, matchFunction_, copyDataFunction_,
                           user_data_, timeout, rate_);
       }
-      state_ = finished;
+      state_ = State::finished;
       return this;
 
-    case started:
+    case State::started:
       simcall_comm_wait(pimpl_, timeout);
-      state_ = finished;
+      state_ = State::finished;
       return this;
 
     default:
@@ -146,7 +146,7 @@ int Comm::test_any(std::vector<CommPtr>* comms)
 
 Activity* Comm::detach()
 {
-  xbt_assert(state_ == inited, "You cannot detach communications once they are started.");
+  xbt_assert(state_ == State::inited, "You cannot detach communications once they are started (not implemented).");
   xbt_assert(srcBuff_ != nullptr && srcBuffSize_ != 0, "You can only detach sends, not recvs");
   detached_ = true;
   return start();
@@ -162,18 +162,16 @@ Activity* Comm::cancel()
 
 bool Comm::test()
 {
-  xbt_assert(state_ == inited || state_ == started || state_ == finished);
+  xbt_assert(state_ == State::inited || state_ == State::started || state_ == State::finished);
 
-  if (state_ == finished) {
+  if (state_ == State::finished)
     return true;
-  }
 
-  if (state_ == inited) {
+  if (state_ == State::inited)
     this->start();
-  }
 
   if(simcall_comm_test(pimpl_)){
-    state_ = finished;
+    state_ = State::finished;
     return true;
   }
   return false;

diff --git a/src/s4u/s4u_exec.cpp b/src/s4u/s4u_exec.cpp
index e7a16ae..3b90193 100644 (file)
--- a/src/s4u/s4u_exec.cpp
+++ b/src/s4u/s4u_exec.cpp
@@ -17,14 +17,14 @@ Activity* Exec::start()
 {
   pimpl_ = simcall_execution_start(nullptr, flops_amount_, 1 / priority_, 0., host_);
   boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(pimpl_)->setBound(bound_);
-  state_ = started;
+  state_ = State::started;
   return this;
 }
 
 Activity* Exec::wait()
 {
   simcall_execution_wait(pimpl_);
-  state_ = finished;
+  state_ = State::finished;
   return this;
 }
 
@@ -36,18 +36,16 @@ Activity* Exec::wait(double timeout)
 
 bool Exec::test()
 {
-  xbt_assert(state_ == inited || state_ == started || state_ == finished);
+  xbt_assert(state_ == State::inited || state_ == State::started || state_ == State::finished);
 
-  if (state_ == finished) {
+  if (state_ == State::finished)
     return true;
-  }
 
-  if (state_ == inited) {
+  if (state_ == State::inited)
     this->start();
-  }
 
   if (simcall_execution_test(pimpl_)) {
-    state_ = finished;
+    state_ = State::finished;
     return true;
   }
 
@@ -56,22 +54,23 @@ bool Exec::test()
 
 ExecPtr Exec::setPriority(double priority)
 {
-  xbt_assert(state_ == inited, "Cannot change the priority of an exec after its start");
+  xbt_assert(state_ == State::inited, "Cannot change the priority of an exec after its start");
   priority_ = priority;
   return this;
 }
 
 ExecPtr Exec::setBound(double bound)
 {
-  xbt_assert(state_ == inited, "Cannot change the bound of an exec after its start");
+  xbt_assert(state_ == State::inited, "Cannot change the bound of an exec after its start");
   bound_ = bound;
   return this;
 }
 
 ExecPtr Exec::setHost(Host* host)
 {
-  xbt_assert(state_ == inited || state_ == started, "Cannot change the host of an exec once it's done (state: %d)", state_);
-  if (state_ == started)
+  xbt_assert(state_ == State::inited || state_ == State::started,
+             "Cannot change the host of an exec once it's done (state: %d)", (int)state_);
+  if (state_ == State::started)
     boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(pimpl_)->migrate(host);
   host_ = host;
   return this;