Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
xbt::config: fix doxygen
[simgrid.git] / src / xbt / config.cpp
1 /* Copyright (c) 2004-2014,2016. The SimGrid Team. All rights reserved.     */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include <stdio.h>
7
8 #include <cerrno>
9 #include <cstring>
10 #include <climits>
11
12 #include <functional>
13 #include <stdexcept>
14 #include <string>
15 #include <typeinfo>
16 #include <type_traits>
17
18 #include <xbt/config.h>
19 #include <xbt/config.hpp>
20 #include "xbt/misc.h"
21 #include "xbt/sysdep.h"
22 #include "xbt/log.h"
23 #include "xbt/ex.h"
24 #include "xbt/dynar.h"
25 #include "xbt/dict.h"
26
27 // *****
28
29 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_cfg, xbt, "configuration support");
30
31 XBT_EXPORT_NO_IMPORT(xbt_cfg_t) simgrid_config = NULL;
32
33 namespace simgrid {
34 namespace config {
35
36 missing_key_error::~missing_key_error() noexcept {}
37
38 class Config;
39
40 namespace {
41
42 const char* true_values[] = {
43   "yes", "on", "true", "1"
44 };
45 const char* false_values[] = {
46   "no", "off", "false", "0"
47 };
48
49 static bool parseBool(const char* value)
50 {
51   for (const char* true_value : true_values)
52     if (std::strcmp(true_value, value) == 0)
53       return true;
54   for (const char* false_value : false_values)
55     if (std::strcmp(false_value, value) == 0)
56       return false;
57   throw std::range_error("not a boolean");
58 }
59
60 static double parseDouble(const char* value)
61 {
62   char* end;
63   errno = 0;
64   double res = std::strtod(value, &end);
65   if (errno == ERANGE)
66     throw std::range_error("out of range");
67   else if (errno)
68     xbt_die("Unexpected errno");
69   if (end == value || *end != '\0')
70     throw std::range_error("invalid double");
71   else
72     return res;
73 }
74
75 static long int parseLong(const char* value)
76 {
77   char* end;
78   errno = 0;
79   long int res = std::strtol(value, &end, 0);
80   if (errno) {
81     if (res == LONG_MIN && errno == ERANGE)
82       throw std::range_error("underflow");
83     else if (res == LONG_MAX && errno == ERANGE)
84       throw std::range_error("overflow");
85     xbt_die("Unexpected errno");
86   }
87   if (end == value || *end != '\0')
88     throw std::range_error("invalid integer");
89   else
90     return res;
91 }
92
93 // ***** ConfigType *****
94
95 /// A trait which define possible options types:
96 template<class T> struct ConfigType;
97
98 template<> struct ConfigType<int> {
99   static constexpr const char* type_name = "int";
100   static inline double parse(const char* value)
101   {
102     return parseLong(value);
103   }
104 };
105 template<> struct ConfigType<double> {
106   static constexpr const char* type_name = "double";
107   static inline double parse(const char* value)
108   {
109     return parseDouble(value);
110   }
111 };
112 template<> struct ConfigType<std::string> {
113   static constexpr const char* type_name = "string";
114   static inline std::string parse(const char* value)
115   {
116     return std::string(value);
117   }
118 };
119 template<> struct ConfigType<bool> {
120   static constexpr const char* type_name = "boolean";
121   static inline bool parse(const char* value)
122   {
123     return parseBool(value);
124   }
125 };
126
127 // **** Forward declarations ****
128
129 class ConfigurationElement ;
130 template<class T> class TypedConfigurationElement;
131
132 // **** ConfigurationElement ****
133
134 class ConfigurationElement {
135 protected:
136   std::string key;
137   std::string desc;
138   bool isdefault = true;
139
140 public:
141
142   /* Callback */
143   xbt_cfg_cb_t old_callback = nullptr;
144
145   ConfigurationElement(const char* key, const char* desc)
146     : key(key ? key : ""), desc(desc ? desc : "") {}
147   ConfigurationElement(const char* key, const char* desc, xbt_cfg_cb_t cb)
148     : key(key ? key : ""), desc(desc ? desc : ""), old_callback(cb) {}
149
150   virtual ~ConfigurationElement();
151
152   virtual std::string getStringValue() = 0;
153   virtual void setStringValue(const char* value) = 0;
154   virtual const char* getTypeName() = 0;
155
156   template<class T>
157   T const& getValue() const
158   {
159     return dynamic_cast<const TypedConfigurationElement<T>&>(*this).getValue();
160   }
161   template<class T>
162   void setValue(T value)
163   {
164     dynamic_cast<TypedConfigurationElement<T>&>(*this).setValue(std::move(value));
165   }
166   template<class T>
167   void setDefaultValue(T value)
168   {
169     dynamic_cast<TypedConfigurationElement<T>&>(*this).setDefaultValue(std::move(value));
170   }
171   bool isDefault() const { return isdefault; }
172
173   std::string const& getDescription() const { return desc; }
174 };
175
176 ConfigurationElement::~ConfigurationElement() {}
177
178 // **** TypedConfigurationElement<T> ****
179
180 // TODO, could we use boost::any with some Type* reference?
181 template<class T>
182 class TypedConfigurationElement : public ConfigurationElement {
183 private:
184   T content;
185   std::function<void(T&)> callback;
186
187 public:
188   TypedConfigurationElement(const char* key, const char* desc, T value = T())
189     : ConfigurationElement(key, desc), content(std::move(value))
190   {}
191   TypedConfigurationElement(const char* key, const char* desc, T value,
192       xbt_cfg_cb_t cb)
193     : ConfigurationElement(key, desc, cb), content(std::move(value))
194   {}
195   TypedConfigurationElement(const char* key, const char* desc, T value,
196       std::function<void(T&)> callback)
197     : ConfigurationElement(key, desc), content(std::move(value)),
198       callback(std::move(callback))
199   {}
200   ~TypedConfigurationElement() override;
201
202   std::string getStringValue() override;
203   const char* getTypeName() override;
204   void setStringValue(const char* value) override;
205
206   void update()
207   {
208     if (old_callback)
209       this->old_callback(key.c_str());
210     if (this->callback)
211       this->callback(this->content);
212   }
213
214   T const& getValue() const { return content; }
215
216   void setValue(T value)
217   {
218     this->content = std::move(value);
219     this->update();
220   }
221
222   void setDefaultValue(T value)
223   {
224     if (this->isdefault) {
225       this->content = std::move(value);
226       this->update();
227     } else {
228       XBT_DEBUG("Do not override configuration variable '%s' with value '%s'"
229         " because it was already set.", key.c_str(), to_string(value).c_str());
230     }
231   }
232 };
233
234 template<class T>
235 std::string TypedConfigurationElement<T>::getStringValue() // override
236 {
237   return to_string(content);
238 }
239
240 template<class T>
241 void TypedConfigurationElement<T>::setStringValue(const char* value) // override
242 {
243   this->content = ConfigType<T>::parse(value);
244   this->isdefault = false;
245   this->update();
246 }
247
248 template<class T>
249 const char* TypedConfigurationElement<T>::getTypeName() // override
250 {
251   return ConfigType<T>::type_name;
252 }
253
254 template<class T>
255 TypedConfigurationElement<T>::~TypedConfigurationElement()
256 {}
257
258 } // end of anonymous namespace
259
260 // **** Config ****
261
262 class Config {
263 private:
264   // name -> ConfigElement:
265   xbt_dict_t options;
266   // alias -> xbt_dict_elm_t from options:
267   xbt_dict_t aliases;
268
269 public:
270   Config();
271   ~Config();
272
273   // No copy:
274   Config(Config const&) = delete;
275   Config& operator=(Config const&) = delete;
276
277   ConfigurationElement& operator[](const char* name);
278   template<class T>
279   TypedConfigurationElement<T>& getTyped(const char* name);
280   void alias(const char* realname, const char* aliasname);
281
282   template<class T, class... A>
283   simgrid::config::TypedConfigurationElement<T>*
284     registerOption(const char* name, A&&... a)
285   {
286     xbt_assert(xbt_dict_get_or_null(this->options, name) == nullptr,
287       "Refusing to register the config element '%s' twice.", name);
288     TypedConfigurationElement<T>* variable =
289       new TypedConfigurationElement<T>(name, std::forward<A>(a)...);
290     XBT_DEBUG("Register cfg elm %s (%s) of type %s @%p in set %p)",
291               name,
292               variable->getDescription().c_str(),
293               variable->getTypeName(), variable, this);
294     xbt_dict_set(this->options, name, variable, NULL);
295     variable->update();
296     return variable;
297   }
298
299   // Debug:
300   void dump(const char *name, const char *indent);
301   void showAliases();
302   void help();
303
304 protected:
305   xbt_dictelm_t getDictElement(const char* name);
306 };
307
308 /* Internal stuff used in cache to free a variable */
309 static void xbt_cfgelm_free(void *data)
310 {
311   if (data)
312     delete (simgrid::config::ConfigurationElement*) data;
313 }
314
315 Config::Config() :
316   options(xbt_dict_new_homogeneous(xbt_cfgelm_free)),
317   aliases(xbt_dict_new_homogeneous(NULL))
318 {}
319
320 Config::~Config()
321 {
322   XBT_DEBUG("Frees cfg set %p", this);
323   xbt_dict_free(&this->options);
324   xbt_dict_free(&this->aliases);
325 }
326
327 inline
328 xbt_dictelm_t Config::getDictElement(const char* name)
329 {
330   // We are interested in the options dictelm:
331   xbt_dictelm_t res = xbt_dict_get_elm_or_null(options, name);
332   if (res)
333     return res;
334   // The aliases dict stores pointers to the options dictelm:
335   res = (xbt_dictelm_t) xbt_dict_get_or_null(aliases, name);
336   if (res)
337     XBT_INFO("Option %s has been renamed to %s. Consider switching.", name, res->key);
338   return res;
339 }
340
341 inline
342 ConfigurationElement& Config::operator[](const char* name)
343 {
344   xbt_dictelm_t elm = getDictElement(name);
345   if (elm == nullptr)
346     throw simgrid::config::missing_key_error(std::string("Bad config key, ") + name);
347   return *(ConfigurationElement*)elm->content;
348 }
349
350 void Config::alias(const char* realname, const char* aliasname)
351 {
352   xbt_assert(this->getDictElement(aliasname) == nullptr, "Alias '%s' already.", aliasname);
353   xbt_dictelm_t element = this->getDictElement(realname);
354   xbt_assert(element, "Cannot define an alias to the non-existing option '%s'.", realname);
355   xbt_dict_set(this->aliases, aliasname, element, NULL);
356 }
357
358 /** @brief Dump a config set for debuging purpose
359  *
360  * @param name The name to give to this config set
361  * @param indent what to write at the beginning of each line (right number of spaces)
362  */
363 void Config::dump(const char *name, const char *indent)
364 {
365   xbt_dict_t dict = this->options;
366   xbt_dict_cursor_t cursor = NULL;
367   simgrid::config::ConfigurationElement* variable = NULL;
368   char *key = NULL;
369
370   if (name)
371     printf("%s>> Dumping of the config set '%s':\n", indent, name);
372
373   xbt_dict_foreach(dict, cursor, key, variable)
374     printf("%s  %s: ()%s) %s", indent, key,
375       variable->getTypeName(),
376       variable->getStringValue().c_str());
377
378   if (name)
379     printf("%s<< End of the config set '%s'\n", indent, name);
380   fflush(stdout);
381
382   xbt_dict_cursor_free(&cursor);
383 }
384
385 /** @brief Displays the declared aliases and their description */
386 void Config::showAliases()
387 {
388   xbt_dict_cursor_t dict_cursor;
389   unsigned int dynar_cursor;
390   xbt_dictelm_t dictel;
391   char *name;
392   xbt_dynar_t names = xbt_dynar_new(sizeof(char *), NULL);
393
394   xbt_dict_foreach(this->aliases, dict_cursor, name, dictel)
395     xbt_dynar_push(names, &name);
396   xbt_dynar_sort_strings(names);
397
398   xbt_dynar_foreach(names, dynar_cursor, name)
399     printf("   %s: %s\n", name, (*this)[name].getDescription().c_str());
400 }
401
402 /** @brief Displays the declared options and their description */
403 void Config::help()
404 {
405   xbt_dict_cursor_t dict_cursor;
406   unsigned int dynar_cursor;
407   simgrid::config::ConfigurationElement* variable;
408   char *name;
409   xbt_dynar_t names = xbt_dynar_new(sizeof(char *), NULL);
410
411   xbt_dict_foreach(this->options, dict_cursor, name, variable)
412     xbt_dynar_push(names, &name);
413   xbt_dynar_sort_strings(names);
414
415   xbt_dynar_foreach(names, dynar_cursor, name) {
416     variable = (simgrid::config::ConfigurationElement*) xbt_dict_get(this->options, name);
417     printf("   %s: %s\n", name, variable->getDescription().c_str());
418     printf("       Type: %s; ", variable->getTypeName());
419     printf("Current value: %s\n", variable->getStringValue().c_str());
420   }
421   xbt_dynar_free(&names);
422 }
423
424 // ***** getConfig *****
425
426 template<class T>
427 XBT_PUBLIC(T const&) getConfig(const char* name)
428 {
429   return (*simgrid_config)[name].getValue<T>();
430 }
431
432 template XBT_PUBLIC(int const&) getConfig<int>(const char* name);
433 template XBT_PUBLIC(double const&) getConfig<double>(const char* name);
434 template XBT_PUBLIC(bool const&) getConfig<bool>(const char* name);
435 template XBT_PUBLIC(std::string const&) getConfig<std::string>(const char* name);
436
437 // ***** alias *****
438
439 void alias(const char* realname, const char* aliasname)
440 {
441   simgrid_config->alias(realname, aliasname);
442 }
443
444 // ***** declareFlag *****
445
446 template<class T>
447 XBT_PUBLIC(void) declareFlag(const char* name, const char* description,
448   T value, std::function<void(const T&)> callback)
449 {
450   if (simgrid_config == NULL)
451     simgrid_config = xbt_cfg_new();
452   simgrid_config->registerOption<T>(
453     name, description, std::move(value), std::move(callback));
454 }
455
456 template XBT_PUBLIC(void) declareFlag(const char* name,
457   const char* description, int value, std::function<void(int const &)> callback);
458 template XBT_PUBLIC(void) declareFlag(const char* name,
459   const char* description, double value, std::function<void(double const &)> callback);
460 template XBT_PUBLIC(void) declareFlag(const char* name,
461   const char* description, bool value, std::function<void(bool const &)> callback);
462 template XBT_PUBLIC(void) declareFlag(const char* name,
463   const char* description, std::string value, std::function<void(std::string const &)> callback);
464
465 }
466 }
467
468 // ***** C bindings *****
469
470 xbt_cfg_t xbt_cfg_new(void)        { return new simgrid::config::Config(); }
471 void xbt_cfg_free(xbt_cfg_t * cfg) { delete *cfg; }
472
473 void xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cfg)
474 {
475   cfg->dump(name, indent);
476 }
477
478 /*----[ Registering stuff ]-----------------------------------------------*/
479
480 void xbt_cfg_register_double(const char *name, double default_value,
481   xbt_cfg_cb_t cb_set, const char *desc)
482 {
483   if (simgrid_config == NULL)
484     simgrid_config = xbt_cfg_new();
485   simgrid_config->registerOption<double>(name, desc, default_value, cb_set);
486 }
487
488 void xbt_cfg_register_int(const char *name, int default_value,xbt_cfg_cb_t cb_set, const char *desc)
489 {
490   if (simgrid_config == NULL)
491     simgrid_config = xbt_cfg_new();
492   simgrid_config->registerOption<int>(name, desc, default_value, cb_set);
493 }
494
495 void xbt_cfg_register_string(const char *name, const char *default_value, xbt_cfg_cb_t cb_set, const char *desc)
496 {
497   if (simgrid_config == NULL)
498     simgrid_config = xbt_cfg_new();
499   simgrid_config->registerOption<std::string>(name, desc,
500     default_value ? default_value : "", cb_set);
501 }
502
503 void xbt_cfg_register_boolean(const char *name, const char*default_value,xbt_cfg_cb_t cb_set, const char *desc)
504 {
505   if (simgrid_config == NULL)
506     simgrid_config = xbt_cfg_new();
507   simgrid_config->registerOption<bool>(name, desc, simgrid::config::parseBool(default_value), cb_set);
508 }
509
510 void xbt_cfg_register_alias(const char *realname, const char *aliasname)
511 {
512   if (simgrid_config == NULL)
513     simgrid_config = xbt_cfg_new();
514   simgrid_config->alias(realname, aliasname);
515 }
516
517 void xbt_cfg_aliases(void) { simgrid_config->showAliases(); }
518 void xbt_cfg_help(void)    { simgrid_config->help(); }
519
520 /*----[ Setting ]---------------------------------------------------------*/
521
522 /** @brief Add values parsed from a string into a config set
523  *
524  * @param options a string containing the content to add to the config set. This is a '\\t',' ' or '\\n' or ','
525  * separated list of variables. Each individual variable is like "[name]:[value]" where [name] is the name of an
526  * already registered variable, and [value] conforms to the data type under which this variable was registered.
527  *
528  * @todo This is a crude manual parser, it should be a proper lexer.
529  */
530 void xbt_cfg_set_parse(const char *options)
531 {
532   if (!options || !strlen(options)) {   /* nothing to do */
533     return;
534   }
535   char *optionlist_cpy = xbt_strdup(options);
536
537   XBT_DEBUG("List to parse and set:'%s'", options);
538   char *option = optionlist_cpy;
539   while (1) {                   /* breaks in the code */
540     if (!option)
541       break;
542     char *name = option;
543     int len = strlen(name);
544     XBT_DEBUG("Still to parse and set: '%s'. len=%d; option-name=%ld", name, len, (long) (option - name));
545
546     /* Pass the value */
547     while (option - name <= (len - 1) && *option != ' ' && *option != '\n' && *option != '\t' && *option != ',') {
548       XBT_DEBUG("Take %c.", *option);
549       option++;
550     }
551     if (option - name == len) {
552       XBT_DEBUG("Boundary=EOL");
553       option = NULL;            /* don't do next iteration */
554     } else {
555       XBT_DEBUG("Boundary on '%c'. len=%d;option-name=%ld", *option, len, (long) (option - name));
556       /* Pass the following blank chars */
557       *(option++) = '\0';
558       while (option - name < (len - 1) && (*option == ' ' || *option == '\n' || *option == '\t')) {
559         /*      fprintf(stderr,"Ignore a blank char.\n"); */
560         option++;
561       }
562       if (option - name == len - 1)
563         option = NULL;          /* don't do next iteration */
564     }
565     XBT_DEBUG("parse now:'%s'; parse later:'%s'", name, option);
566
567     if (name[0] == ' ' || name[0] == '\n' || name[0] == '\t')
568       continue;
569     if (!strlen(name))
570       break;
571
572     char *val = strchr(name, ':');
573     xbt_assert(val, "Option '%s' badly formatted. Should be of the form 'name:value'", name);
574     /* don't free(optionlist_cpy) if the assert fails, 'name' points inside it */
575     *(val++) = '\0';
576
577     if (strncmp(name, "contexts/", strlen("contexts/")) && strncmp(name, "path", strlen("path")))
578       XBT_INFO("Configuration change: Set '%s' to '%s'", name, val);
579
580     try {
581       (*simgrid_config)[name].setStringValue(val);
582     }
583     catch (simgrid::config::missing_key_error& e) {
584       goto on_missing_key;
585     }
586     catch (...) {
587       goto on_exception;
588     }
589   }
590
591   free(optionlist_cpy);
592   return;
593
594 on_missing_key:
595   free(optionlist_cpy);
596   THROWF(not_found_error, 0, "Could not set variables %s", options);
597   return;
598 on_exception:
599   free(optionlist_cpy);
600   THROWF(unknown_error, 0, "Could not set variables %s", options);
601   return;
602 }
603
604 // Horrible mess to translate C++ exceptions to C exceptions:
605 // Exit from the catch blog (and do the correct exceptio cleaning)
606 // before attempting to THROWF.
607 #define TRANSLATE_EXCEPTIONS(...) \
608   catch(simgrid::config::missing_key_error& e) { goto on_exception; } \
609   catch(...) { goto on_missing_key; } \
610   on_missing_key: THROWF(not_found_error, 0, __VA_ARGS__); \
611   on_exception: THROWF(not_found_error, 0, __VA_ARGS__);
612
613 /** @brief Set the value of a variable, using the string representation of that value
614  *
615  * @param key name of the variable to modify
616  * @param value string representation of the value to set
617  */
618
619 void xbt_cfg_set_as_string(const char *key, const char *value)
620 {
621   try {
622     (*simgrid_config)[key].setStringValue(value);
623     return;
624   }
625   TRANSLATE_EXCEPTIONS("Could not set variable %s as string %s", key, value);
626 }
627
628 /** @brief Set an integer value to \a name within \a cfg if it wasn't changed yet
629  *
630  * This is useful to change the default value of a variable while allowing
631  * users to override it with command line arguments
632  */
633 void xbt_cfg_setdefault_int(const char *key, int value)
634 {
635   try {
636     (*simgrid_config)[key].setDefaultValue<int>(value);
637     return;
638   }
639   TRANSLATE_EXCEPTIONS("Could not set variable %s to default integer %i",
640     key, value);
641 }
642
643 /** @brief Set an integer value to \a name within \a cfg if it wasn't changed yet
644  *
645  * This is useful to change the default value of a variable while allowing
646  * users to override it with command line arguments
647  */
648 void xbt_cfg_setdefault_double(const char *key, double value)
649 {
650   try {
651     (*simgrid_config)[key].setDefaultValue<double>(value);
652     return;
653   }
654   TRANSLATE_EXCEPTIONS("Could not set variable %s to default double %f",
655     key, value);
656 }
657
658 /** @brief Set a string value to \a name within \a cfg if it wasn't changed yet
659  *
660  * This is useful to change the default value of a variable while allowing
661  * users to override it with command line arguments
662  */
663 void xbt_cfg_setdefault_string(const char *key, const char *value)
664 {
665   try {
666     (*simgrid_config)[key].setDefaultValue<std::string>(value ? value : "");
667     return;
668   }
669   TRANSLATE_EXCEPTIONS("Could not set variable %s to default string %s",
670     key, value);
671 }
672
673 /** @brief Set an boolean value to \a name within \a cfg if it wasn't changed yet
674  *
675  * This is useful to change the default value of a variable while allowing
676  * users to override it with command line arguments
677  */
678 void xbt_cfg_setdefault_boolean(const char *key, const char *value)
679 {
680   try {
681     (*simgrid_config)[key].setDefaultValue<bool>(simgrid::config::parseBool(value));
682     return;
683   }
684   TRANSLATE_EXCEPTIONS("Could not set variable %s to default boolean %s",
685     key, value);
686 }
687
688 /** @brief Set an integer value to \a name within \a cfg
689  *
690  * @param key the name of the variable
691  * @param value the value of the variable
692  */
693 void xbt_cfg_set_int(const char *key, int value)
694 {
695   try {
696     (*simgrid_config)[key].setValue<int>(value);
697     return;
698   }
699   TRANSLATE_EXCEPTIONS("Could not set variable %s to integer %i",
700     key, value);
701 }
702
703 /** @brief Set or add a double value to \a name within \a cfg
704  *
705  * @param key the name of the variable
706  * @param value the double to set
707  */
708 void xbt_cfg_set_double(const char *key, double value)
709 {
710   try {
711     (*simgrid_config)[key].setValue<double>(value);
712     return;
713   }
714   TRANSLATE_EXCEPTIONS("Could not set variable %s to double %f",
715     key, value);
716 }
717
718 /** @brief Set or add a string value to \a name within \a cfg
719  *
720  * @param key the name of the variable
721  * @param value the value to be added
722  *
723  */
724 void xbt_cfg_set_string(const char *key, const char *value)
725 {
726   try {
727     (*simgrid_config)[key].setValue<std::string>(value ? value : "");
728     return;
729   }
730   TRANSLATE_EXCEPTIONS("Could not set variable %s to string %s",
731     key, value);
732 }
733
734 /** @brief Set or add a boolean value to \a name within \a cfg
735  *
736  * @param key the name of the variable
737  * @param value the value of the variable
738  */
739 void xbt_cfg_set_boolean(const char *key, const char *value)
740 {
741   try {
742     (*simgrid_config)[key].setValue<bool>(simgrid::config::parseBool(value));
743     return;
744   }
745   TRANSLATE_EXCEPTIONS("Could not set variable %s to boolean %s",
746     key, value);
747 }
748
749
750 /* Say if the value is the default value */
751 int xbt_cfg_is_default_value(const char *key)
752 {
753   try {
754     return (*simgrid_config)[key].isDefault() ? 1 : 0;
755   }
756   TRANSLATE_EXCEPTIONS("Could not get variable %s", key);
757 }
758
759 /*----[ Getting ]---------------------------------------------------------*/
760 /** @brief Retrieve an integer value of a variable (get a warning if not uniq)
761  *
762  * @param key the name of the variable
763  *
764  * Returns the first value from the config set under the given name.
765  */
766 int xbt_cfg_get_int(const char *key)
767 {
768   try {
769     return (*simgrid_config)[key].getValue<int>();
770   }
771   TRANSLATE_EXCEPTIONS("Could not get variable %s", key);
772 }
773
774 /** @brief Retrieve a double value of a variable (get a warning if not uniq)
775  *
776  * @param key the name of the variable
777  *
778  * Returns the first value from the config set under the given name.
779  */
780 double xbt_cfg_get_double(const char *key)
781 {
782   try {
783     return (*simgrid_config)[key].getValue<double>();
784   }
785   TRANSLATE_EXCEPTIONS("Could not get variable %s", key);
786 }
787
788 /** @brief Retrieve a string value of a variable (get a warning if not uniq)
789  *
790  * @param key the name of the variable
791  *
792  * Returns the first value from the config set under the given name.
793  * If there is more than one value, it will issue a warning.
794  * Returns NULL if there is no value.
795  *
796  * \warning the returned value is the actual content of the config set
797  */
798 char *xbt_cfg_get_string(const char *key)
799 {
800   try {
801     return (char*) (*simgrid_config)[key].getValue<std::string>().c_str();
802   }
803   TRANSLATE_EXCEPTIONS("Could not get variable %s", key);
804 }
805
806 /** @brief Retrieve a boolean value of a variable (get a warning if not uniq)
807  *
808  * @param key the name of the variable
809  *
810  * Returns the first value from the config set under the given name.
811  * If there is more than one value, it will issue a warning.
812  */
813 int xbt_cfg_get_boolean(const char *key)
814 {
815   try {
816     return (*simgrid_config)[key].getValue<bool>() ? 1 : 0;
817   }
818   TRANSLATE_EXCEPTIONS("Could not get variable %s", key);
819 }
820
821 #ifdef SIMGRID_TEST
822
823 #include <string>
824
825 #include "xbt.h"
826 #include "xbt/ex.h"
827
828 #include <xbt/config.hpp>
829
830 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_cfg);
831
832 XBT_TEST_SUITE("config", "Configuration support");
833
834 XBT_PUBLIC_DATA(xbt_cfg_t) simgrid_config;
835
836 static void make_set()
837 {
838   simgrid_config = NULL;
839   xbt_log_threshold_set(&_XBT_LOGV(xbt_cfg), xbt_log_priority_critical);
840   xbt_cfg_register_int("speed", 0, NULL, "");
841   xbt_cfg_register_string("peername", "", NULL, "");
842   xbt_cfg_register_string("user", "", NULL, "");
843 }                               /* end_of_make_set */
844
845 XBT_TEST_UNIT("memuse", test_config_memuse, "Alloc and free a config set")
846 {
847   auto temp = simgrid_config;
848   make_set();
849   xbt_test_add("Alloc and free a config set");
850   xbt_cfg_set_parse("peername:veloce user:bidule");
851   xbt_cfg_free(&simgrid_config);
852   simgrid_config = temp;
853 }
854
855 XBT_TEST_UNIT("use", test_config_use, "Data retrieving tests")
856 {
857   auto temp = simgrid_config;
858   make_set();
859   xbt_test_add("Get a single value");
860   {
861     /* get_single_value */
862     int ival;
863
864     xbt_cfg_set_parse("peername:toto:42 speed:42");
865     ival = xbt_cfg_get_int("speed");
866     if (ival != 42)
867       xbt_test_fail("Speed value = %d, I expected 42", ival);
868   }
869
870   xbt_test_add("Access to a non-existant entry");
871   {
872     xbt_ex_t e;
873
874     TRY {
875       xbt_cfg_set_parse("color:blue");
876     } CATCH(e) {
877       if (e.category != not_found_error)
878         xbt_test_exception(e);
879       xbt_ex_free(e);
880     }
881   }
882   xbt_cfg_free(&simgrid_config);
883   simgrid_config = temp;
884 }
885
886 XBT_TEST_UNIT("c++flags", test_config_cxx_flags, "C++ flags")
887 {
888   auto temp = simgrid_config;
889   make_set();
890   xbt_test_add("C++ declaration of flags");
891
892   simgrid::config::Flag<int> int_flag("int", "", 0);
893   simgrid::config::Flag<std::string> string_flag("string", "", "foo");
894   simgrid::config::Flag<double> double_flag("double", "", 0.32);
895   simgrid::config::Flag<bool> bool_flag1("bool1", "", false);
896   simgrid::config::Flag<bool> bool_flag2("bool2", "", true);
897
898   xbt_test_add("Parse values");
899   xbt_cfg_set_parse("int:42 string:bar double:8.0 bool1:true bool2:false");
900   xbt_test_assert(int_flag == 42, "Check int flag");
901   xbt_test_assert(string_flag == "bar", "Check string flag");
902   xbt_test_assert(double_flag == 8.0, "Check double flag");
903   xbt_test_assert(bool_flag1, "Check bool1 flag");
904   xbt_test_assert(!bool_flag2, "Check bool2 flag");
905
906   xbt_cfg_free(&simgrid_config);
907   simgrid_config = temp;
908 }
909
910 #endif                          /* SIMGRID_TEST */