From: Gabriel Corona <gabriel.corona@loria.fr>
Date: Thu, 30 Jun 2016 07:44:34 +0000 (+0200)
Subject: Remove "using namespace"
X-Git-Tag: v3_14~833
X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/e167326c1369032305b7eb87e166b12d6690df64

Remove "using namespace"
---

diff --git a/include/xbt/config.hpp b/include/xbt/config.hpp
index 8299cede0c..8200bf06c6 100644
--- a/include/xbt/config.hpp
+++ b/include/xbt/config.hpp
@@ -104,7 +104,6 @@ void alias(std::initializer_list<const char*> names)
 template<class T>
 void bindFlag(T& value, const char* name, const char* description)
 {
-  using namespace std;
   declareFlag<T>(name, description, value, [&value](T const& val) {
     value = val;
   });
diff --git a/src/s4u/s4u_activity.cpp b/src/s4u/s4u_activity.cpp
index c49e2c4b93..4568abb6c3 100644
--- a/src/s4u/s4u_activity.cpp
+++ b/src/s4u/s4u_activity.cpp
@@ -11,17 +11,21 @@
 
 XBT_LOG_EXTERNAL_CATEGORY(s4u);
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_activity,s4u,"S4U activities");
-using namespace simgrid;
 
-s4u::Activity::Activity() {
+namespace simgrid {
+namespace s4u {
+
+Activity::Activity() {
 
 }
-s4u::Activity::~Activity() {
+Activity::~Activity() {
 
 }
 
-void s4u::Activity::setRemains(double remains) {
+void Activity::setRemains(double remains) {
   xbt_assert(state_ == inited, "Cannot change the remaining amount of work once the Activity is started");
   remains_ = remains;
 }
 
+}
+}
diff --git a/src/s4u/s4u_actor.cpp b/src/s4u/s4u_actor.cpp
index 0c8b49ad6d..63907cfee3 100644
--- a/src/s4u/s4u_actor.cpp
+++ b/src/s4u/s4u_actor.cpp
@@ -16,9 +16,10 @@
 
 XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor,"S4U actors");
 
-using namespace simgrid;
+namespace simgrid {
+namespace s4u {
 
-s4u::Actor::Actor(const char* name, s4u::Host *host, double killTime, std::function<void()> code)
+Actor::Actor(const char* name, s4u::Host *host, double killTime, std::function<void()> code)
 {
   // TODO, when autorestart is used, the std::function is copied so the new
   // instance will get a fresh (reinitialized) state. Is this what we want?
@@ -27,7 +28,7 @@ s4u::Actor::Actor(const char* name, s4u::Host *host, double killTime, std::funct
     killTime, nullptr, 0));
 }
 
-s4u::Actor::Actor(const char* name, s4u::Host *host, double killTime,
+Actor::Actor(const char* name, s4u::Host *host, double killTime,
   const char* function, std::vector<std::string> args)
 {
   simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(function);
@@ -37,35 +38,35 @@ s4u::Actor::Actor(const char* name, s4u::Host *host, double killTime,
     killTime, nullptr, 0));
 }
 
-void s4u::Actor::join() {
+void Actor::join() {
   simcall_process_join(pimpl_, -1);
 }
 
-void s4u::Actor::setAutoRestart(bool autorestart) {
+void Actor::setAutoRestart(bool autorestart) {
   simcall_process_auto_restart_set(pimpl_,autorestart);
 }
 
-s4u::Host *s4u::Actor::getHost() {
+s4u::Host *Actor::getHost() {
   return s4u::Host::by_name(sg_host_get_name(simcall_process_get_host(pimpl_)));
 }
 
-const char* s4u::Actor::getName() {
+const char* Actor::getName() {
   return simcall_process_get_name(pimpl_);
 }
 
-int s4u::Actor::getPid(){
+int Actor::getPid(){
   return simcall_process_get_PID(pimpl_);
 }
 
-void s4u::Actor::setKillTime(double time) {
+void Actor::setKillTime(double time) {
   simcall_process_set_kill_time(pimpl_,time);
 }
 
-double s4u::Actor::getKillTime() {
+double Actor::getKillTime() {
   return simcall_process_get_kill_time(pimpl_);
 }
 
-void s4u::Actor::kill(int pid) {
+void Actor::kill(int pid) {
   msg_process_t process = SIMIX_process_from_PID(pid);
   if(process != nullptr) {
     simcall_process_kill(process);
@@ -76,11 +77,11 @@ void s4u::Actor::kill(int pid) {
   }
 }
 
-void s4u::Actor::kill() {
+void Actor::kill() {
   simcall_process_kill(pimpl_);
 }
 
-simgrid::s4u::Actor s4u::Actor::forPid(int pid)
+simgrid::s4u::Actor Actor::forPid(int pid)
 {
   // Should we throw if we did not find it?
   smx_process_t process = SIMIX_process_from_PID(pid);
@@ -89,13 +90,10 @@ simgrid::s4u::Actor s4u::Actor::forPid(int pid)
 
 // static stuff:
 
-void s4u::Actor::killAll() {
+void Actor::killAll() {
   simcall_process_killall(1);
 }
 
-
-namespace simgrid {
-namespace s4u {
 namespace this_actor {
 
 void sleep(double duration) {
diff --git a/src/s4u/s4u_comm.cpp b/src/s4u/s4u_comm.cpp
index d27cfb0968..591040574a 100644
--- a/src/s4u/s4u_comm.cpp
+++ b/src/s4u/s4u_comm.cpp
@@ -10,57 +10,59 @@
 #include "simgrid/s4u/comm.hpp"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_comm,s4u_activity,"S4U asynchronous communications");
-using namespace simgrid;
 
-s4u::Comm::~Comm() {
+namespace simgrid {
+namespace s4u {
+
+Comm::~Comm() {
 
 }
 
-s4u::Comm &s4u::Comm::send_init(s4u::Mailbox &chan) {
+s4u::Comm &Comm::send_init(s4u::Mailbox &chan) {
   s4u::Comm *res = new s4u::Comm();
   res->sender_ = SIMIX_process_self();
   res->mailbox_ = &chan;
   return *res;
 }
 
-s4u::Comm &s4u::Comm::recv_init(s4u::Mailbox &chan) {
+s4u::Comm &Comm::recv_init(s4u::Mailbox &chan) {
   s4u::Comm *res = new s4u::Comm();
   res->receiver_ = SIMIX_process_self();
   res->mailbox_ = &chan;
   return *res;
 }
 
-void s4u::Comm::setRate(double rate) {
+void Comm::setRate(double rate) {
   xbt_assert(state_==inited);
   rate_ = rate;
 }
 
-void s4u::Comm::setSrcData(void * buff) {
+void Comm::setSrcData(void * buff) {
   xbt_assert(state_==inited);
   xbt_assert(dstBuff_ == nullptr, "Cannot set the src and dst buffers at the same time");
   srcBuff_ = buff;
 }
-void s4u::Comm::setSrcDataSize(size_t size){
+void Comm::setSrcDataSize(size_t size){
   xbt_assert(state_==inited);
   srcBuffSize_ = size;
 }
-void s4u::Comm::setSrcData(void * buff, size_t size) {
+void Comm::setSrcData(void * buff, size_t size) {
   xbt_assert(state_==inited);
 
   xbt_assert(dstBuff_ == nullptr, "Cannot set the src and dst buffers at the same time");
   srcBuff_ = buff;
   srcBuffSize_ = size;
 }
-void s4u::Comm::setDstData(void ** buff) {
+void Comm::setDstData(void ** buff) {
   xbt_assert(state_==inited);
   xbt_assert(srcBuff_ == nullptr, "Cannot set the src and dst buffers at the same time");
   dstBuff_ = buff;
 }
-size_t s4u::Comm::getDstDataSize(){
+size_t Comm::getDstDataSize(){
   xbt_assert(state_==finished);
   return dstBuffSize_;
 }
-void s4u::Comm::setDstData(void ** buff, size_t size) {
+void Comm::setDstData(void ** buff, size_t size) {
   xbt_assert(state_==inited);
 
   xbt_assert(srcBuff_ == nullptr, "Cannot set the src and dst buffers at the same time");
@@ -68,7 +70,7 @@ void s4u::Comm::setDstData(void ** buff, size_t size) {
   dstBuffSize_ = size;
 }
 
-void s4u::Comm::start() {
+void Comm::start() {
   xbt_assert(state_ == inited);
 
   if (srcBuff_ != nullptr) { // Sender side
@@ -86,7 +88,7 @@ void s4u::Comm::start() {
   }
   state_ = started;
 }
-void s4u::Comm::wait() {
+void Comm::wait() {
   xbt_assert(state_ == started || state_ == inited);
 
   if (state_ == started)
@@ -105,7 +107,7 @@ void s4u::Comm::wait() {
   }
   state_ = finished;
 }
-void s4u::Comm::wait(double timeout) {
+void Comm::wait(double timeout) {
   xbt_assert(state_ == started || state_ == inited);
 
   if (state_ == started) {
@@ -128,7 +130,7 @@ void s4u::Comm::wait(double timeout) {
   state_ = finished;
 }
 
-s4u::Comm &s4u::Comm::send_async(Mailbox &dest, void *data, int simulatedSize) {
+s4u::Comm &Comm::send_async(Mailbox &dest, void *data, int simulatedSize) {
   s4u::Comm &res = s4u::Comm::send_init(dest);
   res.setRemains(simulatedSize);
   res.srcBuff_ = data;
@@ -137,10 +139,12 @@ s4u::Comm &s4u::Comm::send_async(Mailbox &dest, void *data, int simulatedSize) {
   return res;
 }
 
-s4u::Comm &s4u::Comm::recv_async(Mailbox &dest, void **data) {
+s4u::Comm &Comm::recv_async(Mailbox &dest, void **data) {
   s4u::Comm &res = s4u::Comm::recv_init(dest);
   res.setDstData(data);
   res.start();
   return res;
 }
 
+}
+}
diff --git a/src/s4u/s4u_conditionVariable.cpp b/src/s4u/s4u_conditionVariable.cpp
index 8ed32f4d6d..52b5b9089a 100644
--- a/src/s4u/s4u_conditionVariable.cpp
+++ b/src/s4u/s4u_conditionVariable.cpp
@@ -6,20 +6,21 @@
 #include "simgrid/s4u/conditionVariable.hpp"
 #include "simgrid/simix.h"
 
-using namespace simgrid;
+namespace simgrid {
+namespace s4u {
 
-s4u::ConditionVariable::ConditionVariable()  : cond_(simcall_cond_init()){
+ConditionVariable::ConditionVariable()  : cond_(simcall_cond_init()){
     
 }
 
-s4u::ConditionVariable::~ConditionVariable() {
+ConditionVariable::~ConditionVariable() {
   SIMIX_cond_unref(cond_);
 }
 
 /**
  * Wait functions
  */
-void s4u::ConditionVariable::wait(std::unique_lock<Mutex>& lock) {
+void ConditionVariable::wait(std::unique_lock<Mutex>& lock) {
   simcall_cond_wait(cond_, lock.mutex()->mutex_);
 }
 
@@ -49,7 +50,7 @@ std::cv_status s4u::ConditionVariable::wait_for(std::unique_lock<Mutex>& lock, d
   }
 }
 
-std::cv_status s4u::ConditionVariable::wait_until(std::unique_lock<Mutex>& lock, double timeout_time)
+std::cv_status ConditionVariable::wait_until(std::unique_lock<Mutex>& lock, double timeout_time)
 {
   double now = SIMIX_get_clock();
   double timeout;
@@ -63,12 +64,13 @@ std::cv_status s4u::ConditionVariable::wait_until(std::unique_lock<Mutex>& lock,
 /**
  * Notify functions
  */
-void s4u::ConditionVariable::notify_one() {
+void ConditionVariable::notify_one() {
    simcall_cond_signal(cond_);
 }
  
-void s4u::ConditionVariable::notify_all() {
+void ConditionVariable::notify_all() {
   simcall_cond_broadcast(cond_);
 }
 
- 
+}
+}
diff --git a/src/s4u/s4u_engine.cpp b/src/s4u/s4u_engine.cpp
index 73b3b7c380..6bf7a98c6d 100644
--- a/src/s4u/s4u_engine.cpp
+++ b/src/s4u/s4u_engine.cpp
@@ -12,56 +12,61 @@
 #include "simgrid/s4u/mailbox.hpp"
 #include "simgrid/s4u/storage.hpp"
 
+#include "surf/surf.h"               // routing_platf. FIXME:KILLME. SOON
+#include "src/surf/surf_routing.hpp" // routing_platf. FIXME:KILLME. SOON
+
 XBT_LOG_NEW_CATEGORY(s4u,"Log channels of the S4U (Simgrid for you) interface");
-using namespace simgrid;
 
-s4u::Engine *s4u::Engine::instance_ = nullptr; /* That singleton is awful, but I don't see no other solution right now. */
+namespace simgrid {
+namespace s4u {
 
+Engine *Engine::instance_ = nullptr; /* That singleton is awful, but I don't see no other solution right now. */
 
-s4u::Engine::Engine(int *argc, char **argv) {
+
+Engine::Engine(int *argc, char **argv) {
   xbt_assert(s4u::Engine::instance_ == nullptr, "It is currently forbidden to create more than one instance of s4u::Engine");
   s4u::Engine::instance_ = this;
 
   SIMIX_global_init(argc, argv);
 }
 
-s4u::Engine *s4u::Engine::instance() {
+Engine *Engine::instance() {
   if (s4u::Engine::instance_ == nullptr)
     new Engine(0,nullptr);
   return s4u::Engine::instance_;
 }
 
-void s4u::Engine::shutdown() {
+void Engine::shutdown() {
   delete s4u::Engine::instance_;
   s4u::Engine::instance_ = nullptr;
   delete s4u::Mailbox::mailboxes;
   delete s4u::Storage::storages_;
 }
 
-double s4u::Engine::getClock()
+double Engine::getClock()
 {
   return SIMIX_get_clock();
 }
 
-void s4u::Engine::loadPlatform(const char *platf)
+void Engine::loadPlatform(const char *platf)
 {
   SIMIX_create_environment(platf);
 }
 
-void s4u::Engine::registerFunction(const char*name, int (*code)(int,char**))
+void Engine::registerFunction(const char*name, int (*code)(int,char**))
 {
   SIMIX_function_register(name,code);
 }
-void s4u::Engine::registerDefault(int (*code)(int,char**))
+void Engine::registerDefault(int (*code)(int,char**))
 {
   SIMIX_function_register_default(code);
 }
-void s4u::Engine::loadDeployment(const char *deploy)
+void Engine::loadDeployment(const char *deploy)
 {
   SIMIX_launch_application(deploy);
 }
 
-void s4u::Engine::run() {
+void Engine::run() {
   if (MC_is_active()) {
     MC_run();
   } else {
@@ -69,10 +74,7 @@ void s4u::Engine::run() {
   }
 }
 
-#include "surf/surf.h"               // routing_platf. FIXME:KILLME. SOON
-#include "src/surf/surf_routing.hpp" // routing_platf. FIXME:KILLME. SOON
-
-s4u::As *s4u::Engine::rootAs()
+s4u::As *Engine::rootAs()
 {
   return routing_platf->root_; // FIXME: get the root into the Engine directly (and kill the platf)
 }
@@ -92,8 +94,11 @@ static s4u::As *asByNameRecursive(s4u::As *current, const char *name)
   }
   return nullptr;
 }
+
 /** @brief Retrieve the AS of the given name (or nullptr if not found) */
-s4u::As *s4u::Engine::asByNameOrNull(const char *name) {
+As *Engine::asByNameOrNull(const char *name) {
   return asByNameRecursive(rootAs(),name);
 }
 
+}
+}
diff --git a/src/s4u/s4u_mailbox.cpp b/src/s4u/s4u_mailbox.cpp
index f2661289e1..c23816f714 100644
--- a/src/s4u/s4u_mailbox.cpp
+++ b/src/s4u/s4u_mailbox.cpp
@@ -13,21 +13,20 @@
 XBT_LOG_EXTERNAL_CATEGORY(s4u);
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_channel,s4u,"S4U Communication Mailboxes");
 
-
-using namespace simgrid;
+namespace simgrid {
+namespace s4u {
 
 boost::unordered_map <std::string, s4u::Mailbox *> *s4u::Mailbox::mailboxes = new boost::unordered_map<std::string, s4u::Mailbox*> ();
 
-
-s4u::Mailbox::Mailbox(const char*name, smx_mailbox_t inferior) {
+Mailbox::Mailbox(const char*name, smx_mailbox_t inferior) {
   pimpl_ = inferior;
   name_ = name;
   mailboxes->insert({name, this});
 }
-const char *s4u::Mailbox::getName() {
+const char *Mailbox::getName() {
   return name_.c_str();
 }
-s4u::Mailbox *s4u::Mailbox::byName(const char*name) {
+Mailbox *Mailbox::byName(const char*name) {
   s4u::Mailbox *res;
   try {
     res = mailboxes->at(name);
@@ -42,22 +41,25 @@ s4u::Mailbox *s4u::Mailbox::byName(const char*name) {
   return res;
 }
 
-bool s4u::Mailbox::empty() {
+bool Mailbox::empty() {
   return nullptr == simcall_mbox_front(pimpl_);
 }
 
-void s4u::Mailbox::setReceiver(smx_process_t process) {
+void Mailbox::setReceiver(smx_process_t process) {
   simcall_mbox_set_receiver(pimpl_, process);
 }
 /** @brief get the receiver (process associated to the mailbox) */
-smx_process_t s4u::Mailbox::receiver() {
+smx_process_t Mailbox::receiver() {
   return pimpl_->permanent_receiver;
 }
 
+}
+}
+
 /*------- C functions -------*/
 
 sg_mbox_t sg_mbox_by_name(const char*name){
-  return s4u::Mailbox::byName(name);
+  return simgrid::s4u::Mailbox::byName(name);
 }
 int sg_mbox_is_empty(sg_mbox_t mbox) {
   return mbox->empty();
diff --git a/src/surf/network_ib.cpp b/src/surf/network_ib.cpp
index 9023115b3b..831dbdb7bc 100644
--- a/src/surf/network_ib.cpp
+++ b/src/surf/network_ib.cpp
@@ -15,7 +15,8 @@
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_network);
 
 static void IB_create_host_callback(simgrid::s4u::Host& host){
-  using namespace simgrid::surf;
+  using simgrid::surf::NetworkIBModel;
+  using simgrid::surf::IBNode;
 
   static int id=0;
   // pour t->id -> rajouter une nouvelle struct dans le dict, pour stocker les comms actives
@@ -34,7 +35,9 @@ static void IB_action_state_changed_callback(
     simgrid::surf::NetworkAction *action,
     simgrid::surf::Action::State statein, simgrid::surf::Action::State stateout)
 {
-  using namespace simgrid::surf;
+  using simgrid::surf::NetworkIBModel;
+  using simgrid::surf::IBNode;
+
   if(statein!=simgrid::surf::Action::State::running || stateout!=simgrid::surf::Action::State::done)
     return;
   std::pair<IBNode*,IBNode*> pair = ((NetworkIBModel*)surf_network_model)->active_comms[action];