Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Remove spurious XBT_PUBLIC
[simgrid.git] / include / xbt / config.hpp
1 /* Copyright (c) 2016. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #ifndef _XBT_CONFIG_HPP_
8 #define _XBT_CONFIG_HPP_
9
10 #include <cstdlib>
11
12 #include <functional>
13 #include <stdexcept>
14 #include <string>
15 #include <type_traits>
16 #include <utility>
17
18 #include <xbt/base.h>
19 #include <xbt/config.h>
20
21 namespace simgrid {
22 namespace config {
23
24 XBT_PUBLIC(bool) parseBool(const char* value);
25 XBT_PUBLIC(double) parseDouble(const char* value);
26 XBT_PUBLIC(long int) parseLong(const char* value);
27
28 template<class T> struct parse_option {
29   static inline T parse(const char* value)
30   {
31     return T(value);
32   }
33 };
34
35 template<> struct parse_option<std::string> {
36   static inline std::string parse(const char* value)
37   {
38     return std::string(value);
39   }
40 };
41
42 template<>
43 struct parse_option<double> {
44   static inline double parse(const char* value)
45   {
46     return parseDouble(value);
47   }
48 };
49
50 template<>
51 struct parse_option<int> {
52   static inline double parse(const char* value)
53   {
54     return parseLong(value);
55   }
56 };
57
58 template<>
59 struct parse_option<bool> {
60   static inline bool parse(const char* value)
61   {
62     return parseBool(value);
63   }
64 };
65
66 template<class T> inline
67 T parse(const char* value)
68 {
69   return parse_option<T>::parse(value);
70 }
71
72 template<class T> inline
73 std::string to_string(T&& value)
74 {
75   return std::to_string(std::forward<T>(value));
76 }
77 inline std::string const& to_string(std::string& value)
78 {
79   return value;
80 }
81 inline std::string const& to_string(std::string const& value)
82 {
83   return value;
84 }
85 inline std::string to_string(std::string&& value)
86 {
87   return std::move(value);
88 }
89
90 // Register:
91
92 /** Register a configuration flag
93  *
94  *  @param name        name of the option
95  *  @param description Description of the option
96  *  @param callback    called with the option value
97  */
98 XBT_PUBLIC(void) declareFlag(const char* name, const char* description,
99   std::function<void(const char* value)> callback);
100
101 template<class T, class F>
102 void declareFlag(const char* name, const char* description, F callback)
103 {
104   declareFlag(name, description, [callback](const char* value) {
105     callback(parse<T>(value));
106   });
107 }
108
109 /** Bind a variable to configuration flag
110  *
111  *  @param value Bound variable
112  *  @param name  Flag name
113  *  @param description Option description
114  */
115 template<class T>
116 void bindFlag(T& value, const char* name, const char* description)
117 {
118   using namespace std;
119   declareFlag(name, description, [&value](const char* val) {
120     value = simgrid::config::parse<T>(val);
121   });
122   xbt_cfg_setdefault_string(name, simgrid::config::to_string(value).c_str());
123 }
124
125 /** Bind a variable to configuration flag
126  *
127  *  <pre><code>
128  *  static int x;
129  *  simgrid::config::bindFlag(a, "x", [](const char* value) {
130  *    return simgrid::config::parse(value);
131  *  }
132  *  </pre><code>
133  */
134 // F is a parser, F : const char* -> T
135 template<class T, class F>
136 typename std::enable_if<std::is_same<
137   T,
138   typename std::remove_cv< decltype(
139     std::declval<F>()(std::declval<const char*>())
140   ) >::type
141 >::value, void>::type
142 bindFlag(T& value, const char* name, const char* description,
143   F callback)
144 {
145   declareFlag(name, description, [&value,callback](const char* val) {
146     value = callback(val);
147   });
148   xbt_cfg_setdefault_string(name, to_string(value).c_str());
149 }
150
151 /** Bind a variable to configuration flag
152  *
153  *  <pre><code>
154  *  static int x;
155  *  simgrid::config::bindFlag(a, "x", [](int x) {
156  *    if (x < x_min || x => x_max)
157  *      throw std::range_error("must be in [x_min, x_max)")
158  *  });
159  *  </pre><code>
160  */
161 // F is a checker, F : T& -> ()
162 template<class T, class F>
163 typename std::enable_if<std::is_same<
164   void,
165   decltype( std::declval<F>()(std::declval<const T&>()) )
166 >::value, void>::type
167 bindFlag(T& value, const char* name, const char* description,
168   F callback)
169 {
170   declareFlag(name, description, [&value,callback](const char* val) {
171     T res = parse<T>(val);
172     callback(res);
173     value = std::move(res);
174   });
175   xbt_cfg_setdefault_string(name, to_string(value).c_str());
176 }
177
178 /** Bind a variable to configuration flag
179  *
180  *  <pre><code>
181  *  static int x;
182  *  simgrid::config::bindFlag(a, "x", [](int x) { return return x > 0; });
183  *  </pre><code>
184  */
185 // F is a predicate, F : T const& -> bool
186 template<class T, class F>
187 typename std::enable_if<std::is_same<
188   bool,
189   decltype( std::declval<F>()(std::declval<const T&>()) )
190 >::value, void>::type
191 bindFlag(T& value, const char* name, const char* description,
192   F callback)
193 {
194   declareFlag(name, description, [&value,callback](const char* val) {
195     T res = parse<T>(val);
196     if (!callback(res))
197       throw std::range_error("invalid value");
198     value = std::move(res);
199   });
200   xbt_cfg_setdefault_string(name, to_string(value).c_str());
201 }
202
203 /** A variable bound to a CLI option
204  *
205  *  <pre><code>
206  *  static simgrid::config::flag<int> answer("answer", "Expected answer", 42);
207  *  static simgrid::config::flag<std::string> name("name", "Ford Prefect", "John Doe");
208  *  static simgrid::config::flag<double> gamma("gamma", "Gamma factor", 1.987);
209  *  </code></pre>
210  */
211 template<class T>
212 class Flag {
213   T value_;
214 public:
215
216   /** Constructor
217    *
218    *  @param name  Flag name
219    *  @param desc  Flag description
220    *  @param value Flag initial/default value
221    */
222   Flag(const char* name, const char* desc, T value) : value_(value)
223   {
224     simgrid::config::bindFlag(value_, name, desc);
225   }
226
227   template<class F>
228   Flag(const char* name, const char* desc, T value, F callback) : value_(value)
229   {
230     simgrid::config::bindFlag(value_, name, desc, std::move(callback));
231   }
232
233   // No copy:
234   Flag(Flag const&) = delete;
235   Flag& operator=(Flag const&) = delete;
236
237   // Get the underlying value:
238   T& get() { return value_; }
239   T const& get() const { return value_; }
240
241   // Implicit conversion to the underlying type:
242   operator T&() { return value_; }
243   operator T const&() const{ return value_; }
244
245   // Basic interop with T:
246   Flag& operator=(T const& that) { value_ = that; return *this; }
247   Flag& operator=(T && that)     { value_ = that; return *this; }
248   bool operator==(T const& that) const { return value_ == that; }
249   bool operator!=(T const& that) const { return value_ != that; }
250   bool operator<(T const& that) const { return value_ < that; }
251   bool operator>(T const& that) const { return value_ > that; }
252   bool operator<=(T const& that) const { return value_ <= that; }
253   bool operator>=(T const& that) const { return value_ >= that; }
254 };
255
256 }
257 }
258
259 #endif