X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/52ce912c49d61c252e301393740350f4f0e41d8b..83a986331633ba19391ce14e6605a5b423311ad7:/src/xbt/config.cpp

diff --git a/src/xbt/config.cpp b/src/xbt/config.cpp
index 8e7084e30a..4c3b69eba1 100644
--- a/src/xbt/config.cpp
+++ b/src/xbt/config.cpp
@@ -366,17 +366,84 @@ void Config::help()
   }
 }
 
-// ***** get_config *****
+// ***** set_default *****
 
-template <class T> XBT_PUBLIC T const& get_config(const char* name)
+template <class T> XBT_PUBLIC void set_default(const char* name, T value)
+{
+  (*simgrid_config)[name].set_default_value<T>(std::move(value));
+}
+
+template XBT_PUBLIC void set_default<int>(const char* name, int value);
+template XBT_PUBLIC void set_default<double>(const char* name, double value);
+template XBT_PUBLIC void set_default<bool>(const char* name, bool value);
+template XBT_PUBLIC void set_default<std::string>(const char* name, std::string value);
+
+bool is_default(const char* name)
+{
+  return (*simgrid_config)[name].is_default();
+}
+
+// ***** set_value *****
+
+template <class T> XBT_PUBLIC void set_value(const char* name, T value)
+{
+  (*simgrid_config)[name].set_value<T>(std::move(value));
+}
+
+template XBT_PUBLIC void set_value<int>(const char* name, int value);
+template XBT_PUBLIC void set_value<double>(const char* name, double value);
+template XBT_PUBLIC void set_value<bool>(const char* name, bool value);
+template XBT_PUBLIC void set_value<std::string>(const char* name, std::string value);
+
+void set_as_string(const char* name, const std::string& value)
+{
+  (*simgrid_config)[name].set_string_value(value.c_str());
+}
+
+void set_parse(std::string options)
+{
+  XBT_DEBUG("List to parse and set:'%s'", options.c_str());
+  while (not options.empty()) {
+    XBT_DEBUG("Still to parse and set: '%s'", options.c_str());
+
+    // skip separators
+    size_t pos = options.find_first_not_of(" \t\n,");
+    options.erase(0, pos);
+    // find option
+    pos              = options.find_first_of(" \t\n,");
+    std::string name = options.substr(0, pos);
+    options.erase(0, pos);
+    XBT_DEBUG("parse now:'%s'; parse later:'%s'", name.c_str(), options.c_str());
+
+    if (name.empty())
+      continue;
+
+    pos = name.find(':');
+    xbt_assert(pos != std::string::npos, "Option '%s' badly formatted. Should be of the form 'name:value'",
+               name.c_str());
+
+    std::string val = name.substr(pos + 1);
+    name.erase(pos);
+
+    const std::string path("path");
+    if (name.compare(0, path.length(), path) != 0)
+      XBT_INFO("Configuration change: Set '%s' to '%s'", name.c_str(), val.c_str());
+
+    set_as_string(name.c_str(), val);
+  }
+}
+
+// ***** get_value *****
+
+template <class T> XBT_PUBLIC T const& get_value(const char* name)
 {
   return (*simgrid_config)[name].get_value<T>();
 }
 
-template XBT_PUBLIC int const& get_config<int>(const char* name);
-template XBT_PUBLIC double const& get_config<double>(const char* name);
-template XBT_PUBLIC bool const& get_config<bool>(const char* name);
-template XBT_PUBLIC std::string const& get_config<std::string>(const char* name);
+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);
 
 // ***** alias *****
 
@@ -392,7 +459,7 @@ template <class T>
 XBT_PUBLIC void declare_flag(const char* name, const char* description, T value, std::function<void(const T&)> callback)
 {
   if (simgrid_config == nullptr)
-    simgrid_config = xbt_cfg_new();
+    simgrid_config = new simgrid::config::Config();
   simgrid_config->register_option<T>(name, description, std::move(value), std::move(callback));
 }
 
@@ -404,6 +471,22 @@ template XBT_PUBLIC void declare_flag(const char* name, const char* description,
                                       std::function<void(bool const&)> callback);
 template XBT_PUBLIC void declare_flag(const char* name, const char* description, std::string value,
                                       std::function<void(std::string const&)> callback);
+
+void finalize()
+{
+  delete simgrid_config;
+  simgrid_config = nullptr;
+}
+
+void show_aliases()
+{
+  simgrid_config->show_aliases();
+}
+
+void help()
+{
+  simgrid_config->help();
+}
 }
 }
 
@@ -426,35 +509,35 @@ void xbt_cfg_register_double(const char *name, double default_value,
   xbt_cfg_cb_t cb_set, const char *desc)
 {
   if (simgrid_config == nullptr)
-    simgrid_config = xbt_cfg_new();
+    simgrid_config = new simgrid::config::Config();
   simgrid_config->register_option<double>(name, desc, default_value, cb_set);
 }
 
 void xbt_cfg_register_int(const char *name, int default_value,xbt_cfg_cb_t cb_set, const char *desc)
 {
   if (simgrid_config == nullptr)
-    simgrid_config = xbt_cfg_new();
+    simgrid_config = new simgrid::config::Config();
   simgrid_config->register_option<int>(name, desc, default_value, cb_set);
 }
 
 void xbt_cfg_register_string(const char *name, const char *default_value, xbt_cfg_cb_t cb_set, const char *desc)
 {
   if (simgrid_config == nullptr)
-    simgrid_config = xbt_cfg_new();
+    simgrid_config = new simgrid::config::Config();
   simgrid_config->register_option<std::string>(name, desc, default_value ? default_value : "", cb_set);
 }
 
 void xbt_cfg_register_boolean(const char *name, const char*default_value,xbt_cfg_cb_t cb_set, const char *desc)
 {
   if (simgrid_config == nullptr)
-    simgrid_config = xbt_cfg_new();
+    simgrid_config = new simgrid::config::Config();
   simgrid_config->register_option<bool>(name, desc, simgrid::config::parse_bool(default_value), cb_set);
 }
 
 void xbt_cfg_register_alias(const char *realname, const char *aliasname)
 {
   if (simgrid_config == nullptr)
-    simgrid_config = xbt_cfg_new();
+    simgrid_config = new simgrid::config::Config();
   simgrid_config->alias(realname, aliasname);
 }
 
@@ -479,40 +562,8 @@ void xbt_cfg_help()
  */
 void xbt_cfg_set_parse(const char *options)
 {
-  if (not options || not strlen(options)) { /* nothing to do */
-    return;
-  }
-
-  XBT_DEBUG("List to parse and set:'%s'", options);
-  std::string optionlist(options);
-  while (not optionlist.empty()) {
-    XBT_DEBUG("Still to parse and set: '%s'", optionlist.c_str());
-
-    // skip separators
-    size_t pos = optionlist.find_first_not_of(" \t\n,");
-    optionlist.erase(0, pos);
-    // find option
-    pos              = optionlist.find_first_of(" \t\n,");
-    std::string name = optionlist.substr(0, pos);
-    optionlist.erase(0, pos);
-    XBT_DEBUG("parse now:'%s'; parse later:'%s'", name.c_str(), optionlist.c_str());
-
-    if (name.empty())
-      continue;
-
-    pos = name.find(':');
-    xbt_assert(pos != std::string::npos, "Option '%s' badly formatted. Should be of the form 'name:value'",
-               name.c_str());
-
-    std::string val = name.substr(pos + 1);
-    name.erase(pos);
-
-    const std::string path("path");
-    if (name.compare(0, path.length(), path) != 0)
-      XBT_INFO("Configuration change: Set '%s' to '%s'", name.c_str(), val.c_str());
-
-    (*simgrid_config)[name.c_str()].set_string_value(val.c_str());
-  }
+  if (options && strlen(options) > 0)
+    simgrid::config::set_parse(std::string(options));
 }
 
 /** @brief Set the value of a variable, using the string representation of that value
@@ -678,7 +729,7 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_cfg);
 
 XBT_TEST_SUITE("config", "Configuration support");
 
-XBT_PUBLIC_DATA xbt_cfg_t simgrid_config;
+XBT_PUBLIC_DATA simgrid::config::Config* simgrid_config;
 
 static void make_set()
 {
@@ -694,8 +745,8 @@ XBT_TEST_UNIT("memuse", test_config_memuse, "Alloc and free a config set")
   auto temp = simgrid_config;
   make_set();
   xbt_test_add("Alloc and free a config set");
-  xbt_cfg_set_parse("peername:veloce user:bidule");
-  xbt_cfg_free(&simgrid_config);
+  simgrid::config::set_parse("peername:veloce user:bidule");
+  simgrid::config::finalize();
   simgrid_config = temp;
 }
 
@@ -706,8 +757,8 @@ XBT_TEST_UNIT("use", test_config_use, "Data retrieving tests")
   xbt_test_add("Get a single value");
   {
     /* get_single_value */
-    xbt_cfg_set_parse("peername:toto:42 speed:42");
-    int ival = xbt_cfg_get_int("speed");
+    simgrid::config::set_parse("peername:toto:42 speed:42");
+    int ival = simgrid::config::get_value<int>("speed");
     if (ival != 42)
       xbt_test_fail("Speed value = %d, I expected 42", ival);
   }
@@ -715,13 +766,13 @@ XBT_TEST_UNIT("use", test_config_use, "Data retrieving tests")
   xbt_test_add("Access to a non-existant entry");
   {
     try {
-      xbt_cfg_set_parse("color:blue");
+      simgrid::config::set_parse("color:blue");
     } catch(xbt_ex& e) {
       if (e.category != not_found_error)
         xbt_test_exception(e);
     }
   }
-  xbt_cfg_free(&simgrid_config);
+  simgrid::config::finalize();
   simgrid_config = temp;
 }
 
@@ -738,14 +789,14 @@ XBT_TEST_UNIT("c++flags", test_config_cxx_flags, "C++ flags")
   simgrid::config::Flag<bool> bool_flag2("bool2", "", true);
 
   xbt_test_add("Parse values");
-  xbt_cfg_set_parse("int:42 string:bar double:8.0 bool1:true bool2:false");
+  simgrid::config::set_parse("int:42 string:bar double:8.0 bool1:true bool2:false");
   xbt_test_assert(int_flag == 42, "Check int flag");
   xbt_test_assert(string_flag == "bar", "Check string flag");
   xbt_test_assert(double_flag == 8.0, "Check double flag");
   xbt_test_assert(bool_flag1, "Check bool1 flag");
   xbt_test_assert(not bool_flag2, "Check bool2 flag");
 
-  xbt_cfg_free(&simgrid_config);
+  simgrid::config::finalize();
   simgrid_config = temp;
 }