From: Gabriel Corona Date: Mon, 2 May 2016 09:14:04 +0000 (+0200) Subject: [config] Rewrite the config core X-Git-Tag: v3_14~1287^2 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/f9541e9299d8464d8a4d13ada458a7883a36a9d5 [config] Rewrite the config core * the core is written in C++ and has a to-be-deprecated C API; * remove the type union (fix the problem where the C++-style flags were defined with with the string type; * remove some advanced/unused C API. --- diff --git a/include/xbt/config.h b/include/xbt/config.h index b995d5efc1..b5df791099 100644 --- a/include/xbt/config.h +++ b/include/xbt/config.h @@ -139,7 +139,6 @@ XBT_PUBLIC(void) xbt_cfg_register_int (const char *name, int default_val, XBT_PUBLIC(void) xbt_cfg_register_string (const char *name, const char*default_val,xbt_cfg_cb_t cb_set, const char *desc); XBT_PUBLIC(void) xbt_cfg_register_boolean(const char *name, const char*default_val,xbt_cfg_cb_t cb_set, const char *desc); XBT_PUBLIC(void) xbt_cfg_register_alias(const char *newname, const char *oldname); -XBT_PUBLIC(void) xbt_cfg_register_str(xbt_cfg_t * cfg, const char *entry); XBT_PUBLIC(void) xbt_cfg_aliases(void); XBT_PUBLIC(void) xbt_cfg_help(void); diff --git a/include/xbt/config.hpp b/include/xbt/config.hpp index ecdb613df8..0866cf44e3 100644 --- a/include/xbt/config.hpp +++ b/include/xbt/config.hpp @@ -21,54 +21,6 @@ namespace simgrid { namespace config { -XBT_PUBLIC(bool) parseBool(const char* value); -XBT_PUBLIC(double) parseDouble(const char* value); -XBT_PUBLIC(long int) parseLong(const char* value); - -template struct parse_option { - static inline T parse(const char* value) - { - return T(value); - } -}; - -template<> struct parse_option { - static inline std::string parse(const char* value) - { - return std::string(value); - } -}; - -template<> -struct parse_option { - static inline double parse(const char* value) - { - return parseDouble(value); - } -}; - -template<> -struct parse_option { - static inline double parse(const char* value) - { - return parseLong(value); - } -}; - -template<> -struct parse_option { - static inline bool parse(const char* value) - { - return parseBool(value); - } -}; - -template inline -T parse(const char* value) -{ - return parse_option::parse(value); -} - template inline std::string to_string(T&& value) { @@ -87,24 +39,37 @@ inline std::string to_string(std::string&& value) return std::move(value); } +// Get config + +template +XBT_PUBLIC(T const&) getConfig(const char* name); + +extern template XBT_PUBLIC(int const&) getConfig(const char* name); +extern template XBT_PUBLIC(double const&) getConfig(const char* name); +extern template XBT_PUBLIC(bool const&) getConfig(const char* name); +extern template XBT_PUBLIC(std::string const&) getConfig(const char* name); + // Register: /** Register a configuration flag * * @param name name of the option * @param description Description of the option + * @param value Initial/default value * @param callback called with the option value */ +template XBT_PUBLIC(void) declareFlag(const char* name, const char* description, - std::function callback); + T value, std::function callback = std::function()); -template -void declareFlag(const char* name, const char* description, F callback) -{ - declareFlag(name, description, [callback](const char* value) { - callback(parse(value)); - }); -} +extern template XBT_PUBLIC(void) declareFlag(const char* name, + const char* description, int value, std::function callback); +extern template XBT_PUBLIC(void) declareFlag(const char* name, + const char* description, double value, std::function callback); +extern template XBT_PUBLIC(void) declareFlag(const char* name, + const char* description, bool value, std::function callback); +extern template XBT_PUBLIC(void) declareFlag(const char* name, + const char* description, std::string value, std::function callback); /** Bind a variable to configuration flag * @@ -116,10 +81,9 @@ template void bindFlag(T& value, const char* name, const char* description) { using namespace std; - declareFlag(name, description, [&value](const char* val) { - value = simgrid::config::parse(val); + declareFlag(name, description, value, [&value](T const& val) { + value = val; }); - xbt_cfg_setdefault_string(name, simgrid::config::to_string(value).c_str()); } /** Bind a variable to configuration flag @@ -142,10 +106,9 @@ typename std::enable_if(val); - callback(res); - value = std::move(res); + declareFlag(name, description, value, [&value,callback](const T& val) { + callback(val); + value = std::move(val); }); - xbt_cfg_setdefault_string(name, to_string(value).c_str()); } /** Bind a variable to configuration flag @@ -191,13 +152,11 @@ typename std::enable_if(val); - if (!callback(res)) + declareFlag(name, description, value, [&value,callback](const T& val) { + if (!callback(val)) throw std::range_error("invalid value"); - value = std::move(res); + value = std::move(val); }); - xbt_cfg_setdefault_string(name, to_string(value).c_str()); } /** A variable bound to a CLI option diff --git a/src/mc/mc_record.cpp b/src/mc/mc_record.cpp index 2bc655b633..f5d3f2b333 100644 --- a/src/mc/mc_record.cpp +++ b/src/mc/mc_record.cpp @@ -79,7 +79,7 @@ RecordTrace parseRecordTrace(const char* data) { RecordTrace res; XBT_INFO("path=%s", data); - if (!data || !data[0]) + if (data == nullptr || data[0] == '\0') throw std::runtime_error("Could not parse record path"); const char* current = data; diff --git a/src/simgrid/sg_config.cpp b/src/simgrid/sg_config.cpp index a2e3f35c87..f90dfa98c3 100644 --- a/src/simgrid/sg_config.cpp +++ b/src/simgrid/sg_config.cpp @@ -115,7 +115,7 @@ static void _sg_cfg_cb__plugin(const char *name) xbt_assert(_sg_cfg_init_status < 2, "Cannot load a plugin after the initialization"); char *val = xbt_cfg_get_string(name); - if (val==nullptr) + if (val==nullptr || val[0] == '\0') return; if (!strcmp(val, "help")) { @@ -335,6 +335,8 @@ static void _sg_cfg_cb__surf_path(const char *name) static void _sg_cfg_cb_model_check_replay(const char *name) { MC_record_path = xbt_cfg_get_string(name); + if (MC_record_path[0] == '\0') + MC_record_path = nullptr; } #if HAVE_MC diff --git a/src/smpi/smpi_coll.cpp b/src/smpi/smpi_coll.cpp index dcf92403e8..3d50a570b6 100644 --- a/src/smpi/smpi_coll.cpp +++ b/src/smpi/smpi_coll.cpp @@ -124,7 +124,8 @@ int find_coll_description(s_mpi_coll_description_t * table, { char *name_list = NULL; int selector_on=0; - if(name==NULL){//no argument provided, use active selector's algorithm + if (name==NULL || name[0] == '\0') { + //no argument provided, use active selector's algorithm name=(char*)xbt_cfg_get_string("smpi/coll-selector"); selector_on=1; } diff --git a/src/xbt/config.cpp b/src/xbt/config.cpp index acc34ba67f..f915d8461b 100644 --- a/src/xbt/config.cpp +++ b/src/xbt/config.cpp @@ -6,9 +6,11 @@ #include #include #include + #include #include #include +#include #include #include @@ -26,102 +28,235 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_cfg, xbt, "configuration support"); XBT_EXPORT_NO_IMPORT(xbt_cfg_t) simgrid_config = NULL; -/** @brief possible content of each configuration cell */ -typedef enum { - xbt_cfgelm_int = 0, /**< int */ - xbt_cfgelm_double, /**< double */ - xbt_cfgelm_string, /**< char* */ - xbt_cfgelm_boolean, /**< int */ - //! @cond - xbt_cfgelm_any, /* not shown to users to prevent errors */ - xbt_cfgelm_type_count - //! @endcond -} e_xbt_cfgelm_type_t; +namespace simgrid { +namespace config { +class Config; namespace { -static inline -void increment(e_xbt_cfgelm_type_t& type) +const char* true_values[] = { + "yes", "on", "true", "1" +}; +const char* false_values[] = { + "no", "off", "false", "0" +}; + +static bool parseBool(const char* value) { - typedef std::underlying_type::type underlying_type; - type = (e_xbt_cfgelm_type_t) ((underlying_type) type + 1); + for (const char* true_value : true_values) + if (std::strcmp(true_value, value) == 0) + return true; + for (const char* false_value : false_values) + if (std::strcmp(false_value, value) == 0) + return false; + throw std::domain_error("not a boolean"); } +static double parseDouble(const char* value) +{ + char* end; + errno = 0; + double res = std::strtod(value, &end); + if (errno == ERANGE) + throw std::range_error("out of range"); + else if (errno) + xbt_die("Unexpected errno"); + if (end == value || *end != '\0') + throw std::range_error("invalid double"); + else + return res; } -static const char *xbt_cfgelm_type_name[xbt_cfgelm_type_count] = { - "int", "double", "string", "boolean", "any" -}; +static long int parseLong(const char* value) +{ + char* end; + errno = 0; + long int res = std::strtol(value, &end, 0); + if (errno) { + if (res == LONG_MIN && errno == ERANGE) + throw std::range_error("underflow"); + else if (res == LONG_MAX && errno == ERANGE) + throw std::range_error("overflow"); + xbt_die("Unexpected errno"); + } + if (end == value || *end != '\0') + throw std::range_error("invalid integer"); + else + return res; +} -/** Boolean possible values **/ -struct xbt_boolean_couple { - const char *true_val; - const char *false_val; -}; +// ***** ConfigType ***** -const struct xbt_boolean_couple xbt_cfgelm_boolean_values[] = { - { "yes", "no"}, - { "on", "off"}, - {"true", "false"}, - { "1", "0"}, - { NULL, NULL} +/// A trait which define possible options types: +template struct ConfigType; + +template<> struct ConfigType { + static constexpr const char* type_name = "int"; + static inline double parse(const char* value) + { + return parseLong(value); + } +}; +template<> struct ConfigType { + static constexpr const char* type_name = "double"; + static inline double parse(const char* value) + { + return parseDouble(value); + } +}; +template<> struct ConfigType { + static constexpr const char* type_name = "string"; + static inline std::string parse(const char* value) + { + return std::string(value); + } +}; +template<> struct ConfigType { + static constexpr const char* type_name = "boolean"; + static inline bool parse(const char* value) + { + return parseBool(value); + } }; -namespace simgrid { -namespace config { - struct ConfigurationElement ; - class Config; -} -} +// **** Forward declarations **** -/* Retrieve the variable we'll modify */ -static simgrid::config::ConfigurationElement* xbt_cfgelm_get(xbt_cfg_t cfg, const char *name, e_xbt_cfgelm_type_t type); +class ConfigurationElement ; +template class TypedConfigurationElement; -namespace simgrid { -namespace config { +// **** ConfigurationElement **** -// A configuration variable: -struct ConfigurationElement { - /* Description */ +class ConfigurationElement { +protected: + std::string key; std::string desc; - - /* Allowed type of the variable */ - e_xbt_cfgelm_type_t type; bool isdefault = true; +public: + /* Callback */ - xbt_cfg_cb_t cb_set = nullptr; + 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) {} - /* Advanced callback (for xbt_cfgelm_string only) */ - std::function callback; + virtual ~ConfigurationElement(); - union { - int int_content; - double double_content; - char* string_content; - bool boolean_content; - }; + virtual std::string getStringValue() = 0; + virtual void setStringValue(const char* value) = 0; + virtual const char* getTypeName() = 0; - ~ConfigurationElement() + template + T const& getValue() const { - XBT_DEBUG("Frees cfgelm %p", this); - switch(this->type) { - case xbt_cfgelm_int: - case xbt_cfgelm_double: - case xbt_cfgelm_boolean: - break; - case xbt_cfgelm_string: - free(string_content); - break; - default: - xbt_die("Unexpected config type"); - } + return dynamic_cast&>(*this).getValue(); + } + template + void setValue(T value) + { + dynamic_cast&>(*this).setValue(std::move(value)); + } + template + void setDefaultValue(T value) + { + dynamic_cast&>(*this).setDefaultValue(std::move(value)); + } + bool isDefault() const { return isdefault; } + + std::string const& getDescription() const { return desc; } +}; + +ConfigurationElement::~ConfigurationElement() {} + +// **** TypedConfigurationElement **** + +// TODO, could we use boost::any with some Type* reference? +template +class TypedConfigurationElement : public ConfigurationElement { +private: + T content; + std::function callback; + +public: + TypedConfigurationElement(const char* key, const char* 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) + : ConfigurationElement(key, desc, cb), content(std::move(value)) + {} + TypedConfigurationElement(const char* key, const char* desc, T value, + std::function callback) + : ConfigurationElement(key, desc), content(std::move(value)), + callback(std::move(callback)) + {} + ~TypedConfigurationElement() override; + + std::string getStringValue() override; + const char* getTypeName() override; + void setStringValue(const char* value) override; + + void update() + { + if (old_callback) + this->old_callback(key.c_str()); + if (this->callback) + this->callback(this->content); + } + + T const& getValue() const { return content; } + + void setValue(T value) + { + this->content = std::move(value); + this->update(); } + void setDefaultValue(T value) + { + if (this->isdefault) { + this->content = std::move(value); + this->update(); + } else { + XBT_DEBUG("Do not override configuration variable '%s' with value '%s'" + " because it was already set.", key.c_str(), to_string(value).c_str()); + } + } }; +template +std::string TypedConfigurationElement::getStringValue() // override +{ + return to_string(content); +} + +template +void TypedConfigurationElement::setStringValue(const char* value) // override +{ + this->content = ConfigType::parse(value); + this->isdefault = false; + this->update(); +} + +template +const char* TypedConfigurationElement::getTypeName() // override +{ + return ConfigType::type_name; +} + +template +TypedConfigurationElement::~TypedConfigurationElement() +{} + +} // end of anonymous namespace + +// **** Config **** + class Config { +private: // name -> ConfigElement: xbt_dict_t options; // alias -> xbt_dict_elm_t from options: @@ -135,18 +270,35 @@ public: Config(Config const&) = delete; Config& operator=(Config const&) = delete; - xbt_dictelm_t getElement(const char* name); - ConfigurationElement* operator[](const char* name); + ConfigurationElement& operator[](const char* name); + template + TypedConfigurationElement& getTyped(const char* name); void alias(const char* realname, const char* aliasname); - simgrid::config::ConfigurationElement* registerOption( - const char *name, const char *desc, e_xbt_cfgelm_type_t type, - xbt_cfg_cb_t cb_set); + template + simgrid::config::TypedConfigurationElement* + registerOption(const char* name, A&&... a) + { + xbt_assert(xbt_dict_get_or_null(this->options, name) == nullptr, + "Refusing to register the config element '%s' twice.", name); + TypedConfigurationElement* variable = + new TypedConfigurationElement(name, std::forward(a)...); + XBT_DEBUG("Register cfg elm %s (%s) of type %s @%p in set %p)", + name, + variable->getDescription().c_str(), + variable->getTypeName(), variable, this); + xbt_dict_set(this->options, name, variable, NULL); + variable->update(); + return variable; + } // Debug: void dump(const char *name, const char *indent); void showAliases(); void help(); + +protected: + xbt_dictelm_t getDictElement(const char* name); }; /* Internal stuff used in cache to free a variable */ @@ -169,7 +321,7 @@ Config::~Config() } inline -xbt_dictelm_t Config::getElement(const char* name) +xbt_dictelm_t Config::getDictElement(const char* name) { // We are interested in the options dictelm: xbt_dictelm_t res = xbt_dict_get_elm_or_null(options, name); @@ -183,19 +335,18 @@ xbt_dictelm_t Config::getElement(const char* name) } inline -ConfigurationElement* Config::operator[](const char* name) +ConfigurationElement& Config::operator[](const char* name) { - xbt_dictelm_t elm = getElement(name); - if (elm) - return (ConfigurationElement*) elm->content; - else - return nullptr; + xbt_dictelm_t elm = getDictElement(name); + if (elm == nullptr) + throw std::invalid_argument(std::string("Bad config key, ") + name); + return *(ConfigurationElement*)elm->content; } void Config::alias(const char* realname, const char* aliasname) { - xbt_assert(this->getElement(aliasname) == nullptr, "Alias '%s' already.", aliasname); - xbt_dictelm_t element = this->getElement(realname); + xbt_assert(this->getDictElement(aliasname) == nullptr, "Alias '%s' already.", aliasname); + xbt_dictelm_t element = this->getDictElement(realname); xbt_assert(element, "Cannot define an alias to the non-existing option '%s'.", realname); xbt_dict_set(this->aliases, aliasname, element, NULL); } @@ -215,27 +366,10 @@ void Config::dump(const char *name, const char *indent) if (name) printf("%s>> Dumping of the config set '%s':\n", indent, name); - xbt_dict_foreach(dict, cursor, key, variable) { - const char* type_name = xbt_cfgelm_type_name[variable->type]; - switch (variable->type) { - case xbt_cfgelm_int: - printf("%s %s: ()%s) %i", indent, key, type_name, variable->int_content); - break; - case xbt_cfgelm_double: - printf("%s %s: ()%s) %f", indent, key, type_name, variable->double_content); - break; - case xbt_cfgelm_string: - printf("%s %s: ()%s) %s", indent, key, type_name, variable->string_content); - break; - case xbt_cfgelm_boolean: - printf("%s %s: ()%s) %s", indent, key, type_name, - variable->boolean_content ? "true" : "false"); - break; - default: - printf("%s Invalid type!!\n", indent); - break; - } - } + xbt_dict_foreach(dict, cursor, key, variable) + printf("%s %s: ()%s) %s", indent, key, + variable->getTypeName(), + variable->getStringValue().c_str()); if (name) printf("%s<< End of the config set '%s'\n", indent, name); @@ -244,47 +378,6 @@ void Config::dump(const char *name, const char *indent) xbt_dict_cursor_free(&cursor); } -simgrid::config::ConfigurationElement* Config::registerOption( - const char *name, const char *desc, e_xbt_cfgelm_type_t type, xbt_cfg_cb_t cb_set) -{ - xbt_assert(type >= xbt_cfgelm_int && type <= xbt_cfgelm_boolean, - "type of %s not valid (%d should be between %d and %d)", - name, (int)type, xbt_cfgelm_int, xbt_cfgelm_boolean); - - simgrid::config::ConfigurationElement* res = (simgrid::config::ConfigurationElement*) xbt_dict_get_or_null(this->options, name); - xbt_assert(NULL == res, "Refusing to register the config element '%s' twice.", name); - - res = new simgrid::config::ConfigurationElement(); - XBT_DEBUG("Register cfg elm %s (%s) (%s (=%d) @%p in set %p)", - name, desc, xbt_cfgelm_type_name[type], (int)type, res, this); - res->type = type; - res->cb_set = cb_set; - if (desc) - res->desc = desc; - - // Set a default default value: - switch (type) { - case xbt_cfgelm_int: - res->int_content = 0; - break; - case xbt_cfgelm_double: - res->double_content = 0.0; - break; - case xbt_cfgelm_string: - res->string_content = nullptr; - break; - case xbt_cfgelm_boolean: - res->boolean_content = false; - break; - default: - XBT_ERROR("%d is an invalid type code", (int)type); - break; - } - - xbt_dict_set(this->options, name, res, NULL); - return res; -} - /** @brief Displays the declared aliases and their description */ void Config::showAliases() { @@ -298,11 +391,8 @@ void Config::showAliases() xbt_dynar_push(names, &name); xbt_dynar_sort_strings(names); - xbt_dynar_foreach(names, dynar_cursor, name) { - simgrid::config::ConfigurationElement* variable = (*this)[name]; - if (variable) - printf(" %s: %s\n", name, variable->desc.c_str()); - } + xbt_dynar_foreach(names, dynar_cursor, name) + printf(" %s: %s\n", name, (*this)[name].getDescription().c_str()); } /** @brief Displays the declared options and their description */ @@ -320,41 +410,54 @@ void Config::help() xbt_dynar_foreach(names, dynar_cursor, name) { variable = (simgrid::config::ConfigurationElement*) xbt_dict_get(this->options, name); - - printf(" %s: %s\n", name, variable->desc.c_str()); - printf(" Type: %s; ", xbt_cfgelm_type_name[variable->type]); - printf("Current value: "); - - switch (variable->type) { - case xbt_cfgelm_int: - printf("%d\n", variable->int_content); - break; - case xbt_cfgelm_double: - printf("%f\n", variable->double_content); - break; - case xbt_cfgelm_string: - printf("'%s'\n", variable->string_content); - break; - case xbt_cfgelm_boolean: - printf("'%s'\n", variable->boolean_content ? "true" : "false"); - break; - default: - printf("Invalid type!!\n"); - break; - } - + printf(" %s: %s\n", name, variable->getDescription().c_str()); + printf(" Type: %s; ", variable->getTypeName()); + printf("Current value: %s\n", variable->getStringValue().c_str()); } xbt_dynar_free(&names); } +// ***** getConfig ***** + +template +XBT_PUBLIC(T const&) getConfig(const char* name) +{ + return (*simgrid_config)[name].getValue(); } + +template XBT_PUBLIC(int const&) getConfig(const char* name); +template XBT_PUBLIC(double const&) getConfig(const char* name); +template XBT_PUBLIC(bool const&) getConfig(const char* name); +template XBT_PUBLIC(std::string const&) getConfig(const char* name); + +// ***** declareFlag ***** + +template +XBT_PUBLIC(void) declareFlag(const char* name, const char* description, + T value, std::function callback) +{ + if (simgrid_config == NULL) + simgrid_config = xbt_cfg_new(); + simgrid_config->registerOption( + name, description, std::move(value), std::move(callback)); } -// C bindings: +template XBT_PUBLIC(void) declareFlag(const char* name, + const char* description, int value, std::function callback); +template XBT_PUBLIC(void) declareFlag(const char* name, + const char* description, double value, std::function callback); +template XBT_PUBLIC(void) declareFlag(const char* name, + const char* description, bool value, std::function callback); +template XBT_PUBLIC(void) declareFlag(const char* name, + const char* description, std::string value, std::function callback); + + +} +} + +// ***** C bindings ***** -/** @brief Constructor */ xbt_cfg_t xbt_cfg_new(void) { return new simgrid::config::Config(); } -/** @brief Destructor */ void xbt_cfg_free(xbt_cfg_t * cfg) { delete *cfg; } void xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cfg) @@ -363,41 +466,35 @@ void xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cfg) } /*----[ Registering stuff ]-----------------------------------------------*/ -/** @brief Register an element within a config set - * - * @param cfg the config set - * @param name the name of the config element - * @param desc a description for this item (used by xbt_cfg_help()) - * @param type the type of the config element - * @param cb_set callback function called when a value is set - */ -static simgrid::config::ConfigurationElement* xbt_cfg_register( - xbt_cfg_t * cfg, const char *name, const char *desc, e_xbt_cfgelm_type_t type, xbt_cfg_cb_t cb_set) -{ - if (*cfg == NULL) - *cfg = xbt_cfg_new(); - return (*cfg)->registerOption(name, desc, type, cb_set); -} -void xbt_cfg_register_double(const char *name, double default_value,xbt_cfg_cb_t cb_set, const char *desc) +void xbt_cfg_register_double(const char *name, double default_value, + xbt_cfg_cb_t cb_set, const char *desc) { - xbt_cfg_register(&simgrid_config, name, desc, xbt_cfgelm_double, cb_set); - xbt_cfg_setdefault_double(name, default_value); + if (simgrid_config == NULL) + simgrid_config = xbt_cfg_new(); + simgrid_config->registerOption(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) { - xbt_cfg_register(&simgrid_config, name, desc, xbt_cfgelm_int, cb_set); - xbt_cfg_setdefault_int(name, default_value); + if (simgrid_config == NULL) + simgrid_config = xbt_cfg_new(); + simgrid_config->registerOption(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) { - xbt_cfg_register(&simgrid_config,name,desc,xbt_cfgelm_string,cb_set); - xbt_cfg_setdefault_string(name, default_value); + if (simgrid_config == NULL) + simgrid_config = xbt_cfg_new(); + simgrid_config->registerOption(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) { - xbt_cfg_register(&simgrid_config,name,desc,xbt_cfgelm_boolean,cb_set); - xbt_cfg_setdefault_boolean(name, default_value); + if (simgrid_config == NULL) + simgrid_config = xbt_cfg_new(); + simgrid_config->registerOption(name, desc, simgrid::config::parseBool(default_value), cb_set); } void xbt_cfg_register_alias(const char *realname, const char *aliasname) @@ -407,58 +504,9 @@ void xbt_cfg_register_alias(const char *realname, const char *aliasname) simgrid_config->alias(realname, aliasname); } -/** - * @brief Parse a string and register the stuff described. - * - * @param cfg the config set - * @param entry a string describing the element to register - * - * The string may consist in several variable descriptions separated by a space. - * Each of them must use the following syntax: \:\ - * with type being one of 'string','int','bool' or 'double'. - * - * Note that this does not allow to set the description, so you should prefer the other interface - */ -void xbt_cfg_register_str(xbt_cfg_t * cfg, const char *entry) -{ - char *entrycpy = xbt_strdup(entry); - char *tok; - - e_xbt_cfgelm_type_t type; - XBT_DEBUG("Register string '%s'", entry); - - tok = strchr(entrycpy, ':'); - xbt_assert(tok, "Invalid config element descriptor: %s; Should be :", entry); - *(tok++) = '\0'; - - for (type = (e_xbt_cfgelm_type_t)0; type < xbt_cfgelm_type_count && strcmp(tok, xbt_cfgelm_type_name[type]); increment(type)); - xbt_assert(type < xbt_cfgelm_type_count, - "Invalid type in config element descriptor: %s; Should be one of 'string', 'int' or 'double'.", entry); - - xbt_cfg_register(cfg, entrycpy, NULL, type, NULL); - - free(entrycpy); /* strdup'ed by dict mechanism, but cannot be const */ -} - void xbt_cfg_aliases(void) { simgrid_config->showAliases(); } void xbt_cfg_help(void) { simgrid_config->help(); } -static simgrid::config::ConfigurationElement* xbt_cfgelm_get(xbt_cfg_t cfg, const char *name, e_xbt_cfgelm_type_t type) -{ - simgrid::config::ConfigurationElement* res = (*cfg)[name]; - - if (!res) { - xbt_cfg_help(); - fflush(stdout); - THROWF(not_found_error, 0, "No registered variable '%s' in this config set.", name); - } - - xbt_assert(type == xbt_cfgelm_any || res->type == type, - "You tried to access to the config element %s as an %s, but its type is %s.", - name, xbt_cfgelm_type_name[type], xbt_cfgelm_type_name[res->type]); - return res; -} - /*----[ Setting ]---------------------------------------------------------*/ /** @brief Add values parsed from a string into a config set @@ -519,13 +567,14 @@ void xbt_cfg_set_parse(const char *options) if (strncmp(name, "contexts/", strlen("contexts/")) && strncmp(name, "path", strlen("path"))) XBT_INFO("Configuration change: Set '%s' to '%s'", name, val); - TRY { - xbt_cfg_set_as_string(name,val); - } CATCH_ANONYMOUS { - free(optionlist_cpy); - RETHROW; + try { + (*simgrid_config)[name].setStringValue(val); + } + catch (...) { + THROWF(not_found_error, 0, "Could not set the value %s for %s", val, name); } } + free(optionlist_cpy); } @@ -537,36 +586,11 @@ void xbt_cfg_set_parse(const char *options) void xbt_cfg_set_as_string(const char *key, const char *value) { - simgrid::config::ConfigurationElement* variable = (*simgrid_config)[key]; - if (variable == nullptr) - THROWF(not_found_error, 0, "No registered variable corresponding to '%s'.", key); - - char *ret; - int i; - double d; - - switch (variable->type) { - case xbt_cfgelm_string: - xbt_cfg_set_string(key, value); /* throws */ - break; - case xbt_cfgelm_int: - i = strtol(value, &ret, 0); - if (ret == value || *ret != '\0') - xbt_die("Value of option %s not valid. Should be an integer", key); - xbt_cfg_set_int(key, i); /* throws */ - break; - case xbt_cfgelm_double: - d = strtod(value, &ret); - if (ret == value || *ret != '\0') - xbt_die("Value of option %s not valid. Should be a double", key); - xbt_cfg_set_double(key, d); /* throws */ - break; - case xbt_cfgelm_boolean: - xbt_cfg_set_boolean(key, value); /* throws */ - break; - default: - THROWF(unknown_error, 0, "Type of config element %s is not valid.", key); - break; + try { + (*simgrid_config)[key].setStringValue(value); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); } } @@ -577,13 +601,12 @@ void xbt_cfg_set_as_string(const char *key, const char *value) */ void xbt_cfg_setdefault_int(const char *name, int val) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_int); - - if (variable->isdefault){ - xbt_cfg_set_int(name, val); - variable->isdefault = true; - } else - XBT_DEBUG("Do not override configuration variable '%s' with value '%d' because it was already set.", name, val); + try { + (*simgrid_config)[name].setDefaultValue(val); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); + } } /** @brief Set an integer value to \a name within \a cfg if it wasn't changed yet @@ -593,13 +616,12 @@ void xbt_cfg_setdefault_int(const char *name, int val) */ void xbt_cfg_setdefault_double(const char *name, double val) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_double); - - if (variable->isdefault) { - xbt_cfg_set_double(name, val); - variable->isdefault = true; - } else - XBT_DEBUG("Do not override configuration variable '%s' with value '%f' because it was already set.", name, val); + try { + (*simgrid_config)[name].setDefaultValue(val); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); + } } /** @brief Set a string value to \a name within \a cfg if it wasn't changed yet @@ -609,13 +631,12 @@ void xbt_cfg_setdefault_double(const char *name, double val) */ void xbt_cfg_setdefault_string(const char *name, const char *val) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_string); - - if (variable->isdefault){ - xbt_cfg_set_string(name, val); - variable->isdefault = true; - } else - XBT_DEBUG("Do not override configuration variable '%s' with value '%s' because it was already set.", name, val); + try { + (*simgrid_config)[name].setDefaultValue(val ? val : ""); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); + } } /** @brief Set an boolean value to \a name within \a cfg if it wasn't changed yet @@ -625,14 +646,12 @@ void xbt_cfg_setdefault_string(const char *name, const char *val) */ void xbt_cfg_setdefault_boolean(const char *name, const char *val) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_boolean); - - if (variable->isdefault){ - xbt_cfg_set_boolean(name, val); - variable->isdefault = true; + try { + (*simgrid_config)[name].setDefaultValue(simgrid::config::parseBool(val)); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); } - else - XBT_DEBUG("Do not override configuration variable '%s' with value '%s' because it was already set.", name, val); } /** @brief Set an integer value to \a name within \a cfg @@ -642,11 +661,12 @@ void xbt_cfg_setdefault_boolean(const char *name, const char *val) */ void xbt_cfg_set_int(const char *name, int val) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_int); - variable->int_content = val; - if (variable->cb_set) - variable->cb_set(name); - variable->isdefault = false; + try { + (*simgrid_config)[name].setValue(val); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); + } } /** @brief Set or add a double value to \a name within \a cfg @@ -656,11 +676,12 @@ void xbt_cfg_set_int(const char *name, int val) */ void xbt_cfg_set_double(const char *name, double val) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_double); - variable->double_content = val; - if (variable->cb_set) - variable->cb_set(name); - variable->isdefault = false; + try { + (*simgrid_config)[name].setValue(val); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); + } } /** @brief Set or add a string value to \a name within \a cfg @@ -672,26 +693,11 @@ void xbt_cfg_set_double(const char *name, double val) */ void xbt_cfg_set_string(const char *name, const char *val) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_string); - free(variable->string_content); - variable->string_content = xbt_strdup(val); - if (variable->cb_set) - variable->cb_set(name); - variable->isdefault = false; - - if (variable->callback) { - try { - variable->callback(val); - } - catch(std::range_error& e) { - xbt_die("Invalid flag %s=%s: %s", val, name, e.what()); - } - catch(std::exception& e) { - xbt_die("Error for flag %s=%s: %s", val, name, e.what()); - } - catch(...) { - xbt_die("Error for flag %s=%s", val, name); - } + try { + (*simgrid_config)[name].setValue(val ? val : ""); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); } } @@ -702,32 +708,24 @@ void xbt_cfg_set_string(const char *name, const char *val) */ void xbt_cfg_set_boolean(const char *name, const char *val) { - int bval=-1; - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_boolean); - - for (int i = 0; xbt_cfgelm_boolean_values[i].true_val != NULL; i++) { - if (strcmp(val, xbt_cfgelm_boolean_values[i].true_val) == 0){ - bval = 1; - break; - } - if (strcmp(val, xbt_cfgelm_boolean_values[i].false_val) == 0){ - bval = 0; - break; - } + try { + (*simgrid_config)[name].setValue(simgrid::config::parseBool(val)); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); } - xbt_assert(bval != -1, "Value of option '%s' not valid. Should be a boolean (yes,no,on,off,true,false,0,1)", val); - variable->boolean_content = bval; - if (variable->cb_set) - variable->cb_set(name); - variable->isdefault = false; } /* Say if the value is the default value */ int xbt_cfg_is_default_value(const char *name) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_any); - return variable->isdefault; + try { + return (*simgrid_config)[name].isDefault() ? 1 : 0; + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); + } } /*----[ Getting ]---------------------------------------------------------*/ @@ -739,8 +737,12 @@ int xbt_cfg_is_default_value(const char *name) */ int xbt_cfg_get_int(const char *name) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_int); - return variable->int_content; + try { + return (*simgrid_config)[name].getValue(); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); + } } /** @brief Retrieve a double value of a variable (get a warning if not uniq) @@ -752,8 +754,12 @@ int xbt_cfg_get_int(const char *name) */ double xbt_cfg_get_double(const char *name) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_double); - return variable->double_content; + try { + return (*simgrid_config)[name].getValue(); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); + } } /** @brief Retrieve a string value of a variable (get a warning if not uniq) @@ -769,8 +775,12 @@ double xbt_cfg_get_double(const char *name) */ char *xbt_cfg_get_string(const char *name) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_string); - return variable->string_content; + try { + return (char*) (*simgrid_config)[name].getValue().c_str(); + } + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); + } } /** @brief Retrieve a boolean value of a variable (get a warning if not uniq) @@ -783,66 +793,12 @@ char *xbt_cfg_get_string(const char *name) */ int xbt_cfg_get_boolean(const char *name) { - simgrid::config::ConfigurationElement* variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_boolean); - return variable->boolean_content; -} - -namespace simgrid { -namespace config { - -bool parseBool(const char* value) -{ - for (int i = 0; xbt_cfgelm_boolean_values[i].true_val != NULL; i++) { - if (std::strcmp(value, xbt_cfgelm_boolean_values[i].true_val) == 0) - return true; - if (std::strcmp(value, xbt_cfgelm_boolean_values[i].false_val) == 0) - return false; + try { + return (*simgrid_config)[name].getValue() ? 1 : 0; } - throw std::range_error("not a boolean"); -} - -double parseDouble(const char* value) -{ - char* end; - errno = 0; - double res = std::strtod(value, &end); - if (errno == ERANGE) - throw std::range_error("out of range"); - else if (errno) - xbt_die("Unexpected errno"); - if (end == value || *end != '\0') - throw std::range_error("invalid double"); - else - return res; -} - -long int parseLong(const char* value) -{ - char* end; - errno = 0; - long int res = std::strtol(value, &end, 0); - if (errno) { - if (res == LONG_MIN && errno == ERANGE) - throw std::range_error("underflow"); - else if (res == LONG_MAX && errno == ERANGE) - throw std::range_error("overflow"); - xbt_die("Unexpected errno"); + catch (std::exception const& e) { + THROWF(unknown_error, 0, "%s", e.what()); } - if (end == value || *end != '\0') - throw std::range_error("invalid integer"); - else - return res; -} - -void declareFlag(const char* name, const char* description, - std::function callback) -{ - simgrid::config::ConfigurationElement* e = xbt_cfg_register( - &simgrid_config, name, description, xbt_cfgelm_string, NULL); - e->callback = std::move(callback); -} - -} } #ifdef SIMGRID_TEST @@ -858,31 +814,31 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_cfg); XBT_TEST_SUITE("config", "Configuration support"); -static xbt_cfg_t make_set() -{ - xbt_cfg_t set = NULL; +XBT_PUBLIC_DATA(xbt_cfg_t) simgrid_config; +static void make_set() +{ + simgrid_config = NULL; xbt_log_threshold_set(&_XBT_LOGV(xbt_cfg), xbt_log_priority_critical); - xbt_cfg_register_str(&set, "speed:int"); - xbt_cfg_register_str(&set, "peername:string"); - xbt_cfg_register_str(&set, "user:string"); - - return set; + xbt_cfg_register_int("speed", 0, NULL, ""); + xbt_cfg_register_string("peername", "", NULL, ""); + xbt_cfg_register_string("user", "", NULL, ""); } /* end_of_make_set */ -XBT_PUBLIC_DATA(xbt_cfg_t) simgrid_config; - XBT_TEST_UNIT("memuse", test_config_memuse, "Alloc and free a config set") { - simgrid_config = make_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 = temp; } XBT_TEST_UNIT("use", test_config_use, "Data retrieving tests") { - simgrid_config = make_set(); + auto temp = simgrid_config; + make_set(); xbt_test_add("Get a single value"); { /* get_single_value */ @@ -907,11 +863,13 @@ XBT_TEST_UNIT("use", test_config_use, "Data retrieving tests") } } xbt_cfg_free(&simgrid_config); + simgrid_config = temp; } XBT_TEST_UNIT("c++flags", test_config_cxx_flags, "C++ flags") { - simgrid_config = make_set(); + auto temp = simgrid_config; + make_set(); xbt_test_add("C++ declaration of flags"); simgrid::config::Flag int_flag("int", "", 0); @@ -929,6 +887,7 @@ XBT_TEST_UNIT("c++flags", test_config_cxx_flags, "C++ flags") xbt_test_assert(!bool_flag2, "Check bool2 flag"); xbt_cfg_free(&simgrid_config); + simgrid_config = temp; } #endif /* SIMGRID_TEST */