stringify xbt::config and plugins

diff --git a/include/xbt/config.hpp b/include/xbt/config.hpp
index c8888e6..d9c3de9 100644 (file)
--- a/include/xbt/config.hpp
+++ b/include/xbt/config.hpp
@@ -69,12 +69,12 @@ XBT_PUBLIC void set_parse(std::string options);
 
 // Get config
 
 
 // Get config
 

-template <class T> XBT_PUBLIC T const& get_value(const char* name);
+template <class T> XBT_PUBLIC T const& get_value(std::string name);

 
 

-extern template XBT_PUBLIC int const& get_value<int>(const char* name);
-extern template XBT_PUBLIC double const& get_value<double>(const char* name);
-extern template XBT_PUBLIC bool const& get_value<bool>(const char* name);
-extern template XBT_PUBLIC std::string const& get_value<std::string>(const char* name);
+extern template XBT_PUBLIC int const& get_value<int>(std::string name);
+extern template XBT_PUBLIC double const& get_value<double>(std::string name);
+extern template XBT_PUBLIC bool const& get_value<bool>(std::string name);
+extern template XBT_PUBLIC std::string const& get_value<std::string>(std::string name);

 
 // Register:
 
 
 // Register:
 


@@ -86,16 +86,16 @@ extern template XBT_PUBLIC std::string const& get_value<std::string>(const char*
  *  @param callback    called with the option value
  */
 template <class T>
  *  @param callback    called with the option value
  */
 template <class T>

-XBT_PUBLIC void declare_flag(const char* name, const char* description, T value,
+XBT_PUBLIC void declare_flag(std::string name, std::string description, T value,

                              std::function<void(const T&)> callback = std::function<void(const T&)>());
 
                              std::function<void(const T&)> callback = std::function<void(const T&)>());
 

-extern template XBT_PUBLIC void declare_flag(const char* name, const char* description, int value,
+extern template XBT_PUBLIC void declare_flag(std::string name, std::string description, int value,

                                              std::function<void(int const&)> callback);
                                              std::function<void(int const&)> callback);

-extern template XBT_PUBLIC void declare_flag(const char* name, const char* description, double value,
+extern template XBT_PUBLIC void declare_flag(std::string name, std::string description, double value,

                                              std::function<void(double const&)> callback);
                                              std::function<void(double const&)> callback);

-extern template XBT_PUBLIC void declare_flag(const char* name, const char* description, bool value,
+extern template XBT_PUBLIC void declare_flag(std::string name, std::string description, bool value,

                                              std::function<void(bool const&)> callback);
                                              std::function<void(bool const&)> callback);

-extern template XBT_PUBLIC void declare_flag(const char* name, const char* description, std::string value,
+extern template XBT_PUBLIC void declare_flag(std::string name, std::string description, std::string value,

                                              std::function<void(std::string const&)> callback);
 
 // ***** alias *****
                                              std::function<void(std::string const&)> callback);
 
 // ***** alias *****

diff --git a/src/plugins/host_dvfs.cpp b/src/plugins/host_dvfs.cpp
index 2024426..2cb3ffa 100644 (file)
--- a/src/plugins/host_dvfs.cpp
+++ b/src/plugins/host_dvfs.cpp
@@ -20,8 +20,8 @@ SIMGRID_REGISTER_PLUGIN(host_dvfs, "Dvfs support", &sg_host_dvfs_plugin_init)
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_plugin_dvfs, surf, "Logging specific to the SURF HostDvfs plugin");
 
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_plugin_dvfs, surf, "Logging specific to the SURF HostDvfs plugin");
 

-static const char* property_sampling_rate = "plugin/dvfs/sampling_rate";
-static const char* property_governor      = "plugin/dvfs/governor";
+static std::string property_sampling_rate = "plugin/dvfs/sampling_rate";
+static std::string property_governor      = "plugin/dvfs/governor";

 
 namespace simgrid {
 namespace plugin {
 
 namespace simgrid {
 namespace plugin {

diff --git a/src/plugins/vm/VirtualMachineImpl.cpp b/src/plugins/vm/VirtualMachineImpl.cpp
index 3f32d02..3c25ade 100644 (file)
--- a/src/plugins/vm/VirtualMachineImpl.cpp
+++ b/src/plugins/vm/VirtualMachineImpl.cpp
@@ -224,9 +224,9 @@ void VirtualMachineImpl::shutdown(smx_actor_t issuer)
  */
 void VirtualMachineImpl::set_physical_host(s4u::Host* destination)
 {
  */
 void VirtualMachineImpl::set_physical_host(s4u::Host* destination)
 {

-  const char* vm_name     = piface_->get_cname();
-  const char* pm_name_src = physical_host_->get_cname();
-  const char* pm_name_dst = destination->get_cname();
+  std::string vm_name     = piface_->get_name();
+  std::string pm_name_src = physical_host_->get_name();
+  std::string pm_name_dst = destination->get_name();

 
   /* update net_elm with that of the destination physical host */
   piface_->pimpl_netpoint = destination->pimpl_netpoint;
 
   /* update net_elm with that of the destination physical host */
   piface_->pimpl_netpoint = destination->pimpl_netpoint;


@@ -244,7 +244,7 @@ void VirtualMachineImpl::set_physical_host(s4u::Host* destination)
   /* keep the bound value of the cpu action of the VM. */
   double old_bound = action_->get_bound();
   if (old_bound > 0) {
   /* keep the bound value of the cpu action of the VM. */
   double old_bound = action_->get_bound();
   if (old_bound > 0) {

-    XBT_DEBUG("migrate VM(%s): set bound (%f) at %s", vm_name, old_bound, pm_name_dst);
+    XBT_DEBUG("migrate VM(%s): set bound (%f) at %s", vm_name.c_str(), old_bound, pm_name_dst.c_str());

     new_cpu_action->set_bound(old_bound);
   }
 
     new_cpu_action->set_bound(old_bound);
   }
 


@@ -253,7 +253,7 @@ void VirtualMachineImpl::set_physical_host(s4u::Host* destination)
 
   action_ = new_cpu_action;
 
 
   action_ = new_cpu_action;
 

-  XBT_DEBUG("migrate VM(%s): change PM (%s to %s)", vm_name, pm_name_src, pm_name_dst);
+  XBT_DEBUG("migrate VM(%s): change PM (%s to %s)", vm_name.c_str(), pm_name_src.c_str(), pm_name_dst.c_str());

 }
 
 void VirtualMachineImpl::set_bound(double bound)
 }
 
 void VirtualMachineImpl::set_bound(double bound)

diff --git a/src/plugins/vm/VmHostExt.cpp b/src/plugins/vm/VmHostExt.cpp
index f85143a..613199f 100644 (file)
--- a/src/plugins/vm/VmHostExt.cpp
+++ b/src/plugins/vm/VmHostExt.cpp
@@ -5,8 +5,7 @@
 
 #include "src/plugins/vm/VmHostExt.hpp"
 
 
 #include "src/plugins/vm/VmHostExt.hpp"
 

-XBT_LOG_EXTERNAL_CATEGORY(surf_vm);
-XBT_LOG_DEFAULT_CATEGORY(surf_vm);
+XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_vm);

 
 namespace simgrid {
 namespace vm {
 
 namespace simgrid {
 namespace vm {

diff --git a/src/plugins/vm/s4u_VirtualMachine.cpp b/src/plugins/vm/s4u_VirtualMachine.cpp
index bb23fed..2e3a673 100644 (file)
--- a/src/plugins/vm/s4u_VirtualMachine.cpp
+++ b/src/plugins/vm/s4u_VirtualMachine.cpp
@@ -32,6 +32,9 @@ VirtualMachine::VirtualMachine(std::string name, s4u::Host* physical_host, int c
 VirtualMachine::VirtualMachine(std::string name, s4u::Host* physical_host, int core_amount, size_t ramsize)
     : Host(name), pimpl_vm_(new vm::VirtualMachineImpl(this, physical_host, core_amount, ramsize))
 {
 VirtualMachine::VirtualMachine(std::string name, s4u::Host* physical_host, int core_amount, size_t ramsize)
     : Host(name), pimpl_vm_(new vm::VirtualMachineImpl(this, physical_host, core_amount, ramsize))
 {

+  // xbt_assert(s4u::Host::by_name(name) == nullptr,
+  //           "Cannot create a VM named %s: this name is already used by an host or a VM", name.c_str());
+

   XBT_DEBUG("Create VM %s", name.c_str());
 
   /* Currently, a VM uses the network resource of its physical host */
   XBT_DEBUG("Create VM %s", name.c_str());
 
   /* Currently, a VM uses the network resource of its physical host */


@@ -194,9 +197,6 @@ sg_vm_t sg_vm_create_core(sg_host_t pm, const char* name)
  */
 sg_vm_t sg_vm_create_multicore(sg_host_t pm, const char* name, int coreAmount)
 {
  */
 sg_vm_t sg_vm_create_multicore(sg_host_t pm, const char* name, int coreAmount)
 {

-  xbt_assert(sg_host_by_name(name) == nullptr,
-             "Cannot create a VM named %s: this name is already used by an host or a VM", name);
-

   return new simgrid::s4u::VirtualMachine(name, pm, coreAmount);
 }
 
   return new simgrid::s4u::VirtualMachine(name, pm, coreAmount);
 }
 

diff --git a/src/xbt/config.cpp b/src/xbt/config.cpp
index 4c3b69e..3d12053 100644 (file)
--- a/src/xbt/config.cpp
+++ b/src/xbt/config.cpp
@@ -143,9 +143,8 @@ public:
   /* Callback */
   xbt_cfg_cb_t old_callback = nullptr;
 
   /* Callback */
   xbt_cfg_cb_t old_callback = nullptr;
 

-  ConfigurationElement(const char* key, const char* desc) : key(key ? key : ""), desc(desc ? desc : "") {}
-  ConfigurationElement(const char* key, const char* desc, xbt_cfg_cb_t cb)
-    : key(key ? key : ""), desc(desc ? desc : ""), old_callback(cb) {}
+  ConfigurationElement(std::string key, std::string desc) : key(key), desc(desc) {}
+  ConfigurationElement(std::string key, std::string desc, xbt_cfg_cb_t cb) : key(key), desc(desc), old_callback(cb) {}

 
   virtual ~ConfigurationElement() = default;
 
 
   virtual ~ConfigurationElement() = default;
 


@@ -182,13 +181,13 @@ private:
   std::function<void(T&)> callback;
 
 public:
   std::function<void(T&)> callback;
 
 public:

-  TypedConfigurationElement(const char* key, const char* desc, T value = T())
-    : ConfigurationElement(key, desc), content(std::move(value))
+  TypedConfigurationElement(std::string key, std::string desc, T value = T())
+      : ConfigurationElement(key, desc), content(std::move(value))

   {}
   {}

-  TypedConfigurationElement(const char* key, const char* desc, T value, xbt_cfg_cb_t cb)
+  TypedConfigurationElement(std::string key, std::string desc, T value, xbt_cfg_cb_t cb)

       : ConfigurationElement(key, desc, cb), content(std::move(value))
   {}
       : ConfigurationElement(key, desc, cb), content(std::move(value))
   {}

-  TypedConfigurationElement(const char* key, const char* desc, T value, std::function<void(T&)> callback)
+  TypedConfigurationElement(std::string key, std::string desc, T value, std::function<void(T&)> callback)

       : ConfigurationElement(key, desc), content(std::move(value)), callback(std::move(callback))
   {}
   ~TypedConfigurationElement() = default;
       : ConfigurationElement(key, desc), content(std::move(value)), callback(std::move(callback))
   {}
   ~TypedConfigurationElement() = default;


@@ -263,15 +262,16 @@ public:
   Config(Config const&) = delete;
   Config& operator=(Config const&) = delete;
 
   Config(Config const&) = delete;
   Config& operator=(Config const&) = delete;
 

-  ConfigurationElement& operator[](const char* name);
-  void alias(const char* realname, const char* aliasname);
+  ConfigurationElement& operator[](std::string name);
+  void alias(std::string realname, std::string aliasname);

 
   template <class T, class... A>
 
   template <class T, class... A>

-  simgrid::config::TypedConfigurationElement<T>* register_option(const char* name, A&&... a)
+  simgrid::config::TypedConfigurationElement<T>* register_option(std::string name, A&&... a)

   {
   {

-    xbt_assert(options.find(name) == options.end(), "Refusing to register the config element '%s' twice.", name);
+    xbt_assert(options.find(name) == options.end(), "Refusing to register the config element '%s' twice.",
+               name.c_str());

     TypedConfigurationElement<T>* variable = new TypedConfigurationElement<T>(name, std::forward<A>(a)...);
     TypedConfigurationElement<T>* variable = new TypedConfigurationElement<T>(name, std::forward<A>(a)...);

-    XBT_DEBUG("Register cfg elm %s (%s) of type %s @%p in set %p)", name, variable->get_description().c_str(),
+    XBT_DEBUG("Register cfg elm %s (%s) of type %s @%p in set %p)", name.c_str(), variable->get_description().c_str(),

               variable->get_type_name(), variable, this);
     options.insert({name, variable});
     variable->update();
               variable->get_type_name(), variable, this);
     options.insert({name, variable});
     variable->update();


@@ -284,7 +284,7 @@ public:
   void help();
 
 protected:
   void help();
 
 protected:

-  ConfigurationElement* get_dict_element(const char* name);
+  ConfigurationElement* get_dict_element(std::string name);

 };
 
 Config::Config()
 };
 
 Config::Config()


@@ -298,7 +298,7 @@ Config::~Config()
     delete elm.second;
 }
 
     delete elm.second;
 }
 

-inline ConfigurationElement* Config::get_dict_element(const char* name)
+inline ConfigurationElement* Config::get_dict_element(std::string name)

 {
   auto opt = options.find(name);
   if (opt != options.end()) {
 {
   auto opt = options.find(name);
   if (opt != options.end()) {


@@ -308,24 +308,24 @@ inline ConfigurationElement* Config::get_dict_element(const char* name)
     if (als != aliases.end()) {
       ConfigurationElement* res = als->second;
       if (warn_for_aliases)
     if (als != aliases.end()) {
       ConfigurationElement* res = als->second;
       if (warn_for_aliases)

-        XBT_INFO("Option %s has been renamed to %s. Consider switching.", name, res->get_key().c_str());
+        XBT_INFO("Option %s has been renamed to %s. Consider switching.", name.c_str(), res->get_key().c_str());

       return res;
     } else {
       return res;
     } else {

-      THROWF(not_found_error, 0, "Bad config key: %s", name);
+      THROWF(not_found_error, 0, "Bad config key: %s", name.c_str());

     }
   }
 }
 
     }
   }
 }
 

-inline ConfigurationElement& Config::operator[](const char* name)
+inline ConfigurationElement& Config::operator[](std::string name)

 {
   return *(get_dict_element(name));
 }
 
 {
   return *(get_dict_element(name));
 }
 

-void Config::alias(const char* realname, const char* aliasname)
+void Config::alias(std::string realname, std::string aliasname)

 {
 {

-  xbt_assert(aliases.find(aliasname) == aliases.end(), "Alias '%s' already.", aliasname);
+  xbt_assert(aliases.find(aliasname) == aliases.end(), "Alias '%s' already.", aliasname.c_str());

   ConfigurationElement* element = this->get_dict_element(realname);
   ConfigurationElement* element = this->get_dict_element(realname);

-  xbt_assert(element, "Cannot define an alias to the non-existing option '%s'.", realname);
+  xbt_assert(element, "Cannot define an alias to the non-existing option '%s'.", realname.c_str());

   this->aliases.insert({aliasname, element});
 }
 
   this->aliases.insert({aliasname, element});
 }
 


@@ -435,15 +435,15 @@ void set_parse(std::string options)
 
 // ***** get_value *****
 
 
 // ***** get_value *****
 

-template <class T> XBT_PUBLIC T const& get_value(const char* name)
+template <class T> XBT_PUBLIC T const& get_value(std::string name)

 {
   return (*simgrid_config)[name].get_value<T>();
 }
 
 {
   return (*simgrid_config)[name].get_value<T>();
 }
 

-template XBT_PUBLIC int const& get_value<int>(const char* name);
-template XBT_PUBLIC double const& get_value<double>(const char* name);
-template XBT_PUBLIC bool const& get_value<bool>(const char* name);
-template XBT_PUBLIC std::string const& get_value<std::string>(const char* name);
+template XBT_PUBLIC int const& get_value<int>(std::string name);
+template XBT_PUBLIC double const& get_value<double>(std::string name);
+template XBT_PUBLIC bool const& get_value<bool>(std::string name);
+template XBT_PUBLIC std::string const& get_value<std::string>(std::string name);

 
 // ***** alias *****
 
 
 // ***** alias *****
 


@@ -456,20 +456,20 @@ void alias(const char* realname, std::initializer_list<const char*> aliases)
 // ***** declare_flag *****
 
 template <class T>
 // ***** declare_flag *****
 
 template <class T>

-XBT_PUBLIC void declare_flag(const char* name, const char* description, T value, std::function<void(const T&)> callback)
+XBT_PUBLIC void declare_flag(std::string name, std::string description, T value, std::function<void(const T&)> callback)

 {
   if (simgrid_config == nullptr)
     simgrid_config = new simgrid::config::Config();
   simgrid_config->register_option<T>(name, description, std::move(value), std::move(callback));
 }
 
 {
   if (simgrid_config == nullptr)
     simgrid_config = new simgrid::config::Config();
   simgrid_config->register_option<T>(name, description, std::move(value), std::move(callback));
 }
 

-template XBT_PUBLIC void declare_flag(const char* name, const char* description, int value,
+template XBT_PUBLIC void declare_flag(std::string name, std::string description, int value,

                                       std::function<void(int const&)> callback);
                                       std::function<void(int const&)> callback);

-template XBT_PUBLIC void declare_flag(const char* name, const char* description, double value,
+template XBT_PUBLIC void declare_flag(std::string name, std::string description, double value,

                                       std::function<void(double const&)> callback);
                                       std::function<void(double const&)> callback);

-template XBT_PUBLIC void declare_flag(const char* name, const char* description, bool value,
+template XBT_PUBLIC void declare_flag(std::string name, std::string description, bool value,

                                       std::function<void(bool const&)> callback);
                                       std::function<void(bool const&)> callback);

-template XBT_PUBLIC void declare_flag(const char* name, const char* description, std::string value,
+template XBT_PUBLIC void declare_flag(std::string name, std::string description, std::string value,

                                       std::function<void(std::string const&)> callback);
 
 void finalize()
                                       std::function<void(std::string const&)> callback);
 
 void finalize()