include/library/settingvar.hpp

   1 #ifndef _library__settingvar__hpp__included__
   2 #define _library__settingvar__hpp__included__
   3
   4 #include <string>
   5 #include <map>
   6 #include <set>
   7 #include "threadtypes.hpp"
   8 #include "string.hpp"
   9 #include <string>
  10
  11 class setting_var_base;
  12 class setting_var_group;
  13 class setting_var_description;
  14
  15 /**
  16  * A settings listener.
  17  */
  18 struct setting_var_listener
  19 {
  20 /**
  21  * Destructor.
  22  */
  23         virtual ~setting_var_listener() throw();
  24 /**
  25  * Listen for setting changing value.
  26  */
  27         virtual void on_setting_change(setting_var_group& group, const setting_var_base& val) = 0;
  28 };
  29
  30 /**
  31  * Group of setting variables.
  32  */
  33 class setting_var_group
  34 {
  35 public:
  36 /**
  37  * Constructor.
  38  */
  39         setting_var_group() throw(std::bad_alloc);
  40 /**
  41  * Destructor.
  42  */
  43         ~setting_var_group() throw();
  44 /**
  45  * Get all settings.
  46  */
  47         std::set<std::string> get_settings_set() throw(std::bad_alloc);
  48 /**
  49  * Get setting.
  50  */
  51         setting_var_base& operator[](const std::string& name);
  52 /**
  53  * Add a listener.
  54  */
  55         void add_listener(struct setting_var_listener& listener) throw(std::bad_alloc);
  56 /**
  57  * Remove a listener.
  58  */
  59         void remove_listener(struct setting_var_listener& listener) throw(std::bad_alloc);
  60 /**
  61  * Register a setting.
  62  */
  63         void do_register(const std::string& name, setting_var_base& _setting) throw(std::bad_alloc);
  64 /**
  65  * Unregister a setting.
  66  */
  67         void do_unregister(const std::string& name) throw(std::bad_alloc);
  68 /**
  69  * Fire listener.
  70  */
  71         void fire_listener(setting_var_base& var) throw();
  72 private:
  73         std::map<std::string, class setting_var_base*> settings;
  74         std::set<struct setting_var_listener*> listeners;
  75         mutex_class lock;
  76 };
  77
  78 /**
  79  * Write-trough value cache.
  80  */
  81 class setting_var_cache
  82 {
  83 public:
  84 /**
  85  * Constructor.
  86  */
  87         setting_var_cache(setting_var_group& grp);
  88 /**
  89  * Enumerate contents.
  90  *
  91  * Note: This reads cached values in perference to actual values.
  92  */
  93         std::map<std::string, std::string> get_all();
  94 /**
  95  * Enumerate valid keys.
  96  *
  97  * Returns: The set of actually valid keys.
  98  */
  99         std::set<std::string> get_keys();
 100 /**
 101  * Set a value.
 102  *
 103  * Parameter name: Name of the setting.
 104  * Parameter value: New value for the setting.
 105  * Parameter allow_invalid: Cache value if invalid, instead of throwing.
 106  * Throws std::runtime_error: Failed to set the setting and invalid values not allowed.
 107  *
 108  * Note: If setting has cached value and setting it succeeds, the cached value is cleared.
 109  */
 110         void set(const std::string& name, const std::string& value, bool allow_invalid = false) throw(std::bad_alloc,
 111                 std::runtime_error);
 112 /**
 113  * Get a value.
 114  *
 115  * Parameter name: Name of the setting.
 116  * Return: Actual value of the setting.
 117  * Throws std::runtime_error: Setting doesn't exist.
 118  */
 119         std::string get(const std::string& name) throw(std::bad_alloc, std::runtime_error);
 120 /**
 121  * Get descriptor for.
 122  */
 123         const setting_var_description& get_description(const std::string& name) throw(std::bad_alloc,
 124                 std::runtime_error);
 125 private:
 126         setting_var_group& grp;
 127         mutex_class lock;
 128         std::map<std::string, std::string> badcache;
 129 };
 130
 131 /**
 132  * Enumeration.
 133  */
 134 struct setting_enumeration
 135 {
 136         setting_enumeration(std::initializer_list<const char*> v)
 137         {
 138                 unsigned x = 0;
 139                 for(auto i : v) {
 140                         values[bound = x++] = i;
 141                 }
 142         }
 143         std::string get(unsigned val) { return values.count(val) ? values[val] : ""; }
 144         unsigned max_val() { return bound; }
 145 private:
 146         std::map<unsigned, std::string> values;
 147         unsigned bound;
 148 };
 149
 150 /**
 151  * Description of setting.
 152  */
 153 struct setting_var_description
 154 {
 155         enum _type
 156         {
 157                 T_BOOLEAN,
 158                 T_NUMERIC,
 159                 T_STRING,
 160                 T_PATH,
 161                 T_ENUMERATION
 162         };
 163         _type type;
 164         int64_t min_val;
 165         int64_t max_val;
 166         setting_enumeration* enumeration;
 167 };
 168
 169 /**
 170  * Get the description.
 171  */
 172 template<class T> static class setting_var_description& setting_var_description_get(T dummy);
 173
 174 /**
 175  * Setting variable.
 176  */
 177 class setting_var_base
 178 {
 179 public:
 180 /**
 181  * Constructor.
 182  */
 183         setting_var_base(setting_var_group& group, const std::string& iname, const std::string& hname)
 184                 throw(std::bad_alloc);
 185 /**
 186  * Destructor.
 187  */
 188         virtual ~setting_var_base() throw();
 189 /**
 190  * Set setting.
 191  */
 192         virtual void str(const std::string& val) throw(std::runtime_error, std::bad_alloc) = 0;
 193 /**
 194  * Get setting.
 195  */
 196         virtual std::string str() const throw(std::runtime_error, std::bad_alloc) = 0;
 197 /**
 198  * Get setting name.
 199  */
 200         const std::string& get_iname() const throw() { return iname; }
 201         const std::string& get_hname() const throw() { return hname; }
 202 /**
 203  * Get setting description.
 204  */
 205         virtual const setting_var_description& get_description() const throw() = 0;
 206 protected:
 207         setting_var_base(const setting_var_base&);
 208         setting_var_base& operator=(const setting_var_base&);
 209         setting_var_group& group;
 210         std::string iname;
 211         std::string hname;
 212         mutable mutex_class lock;
 213 };
 214
 215 /**
 216  * Setting variable.
 217  */
 218 template<class model> class setting_var : public setting_var_base
 219 {
 220         typedef typename model::valtype_t valtype_t;
 221         setting_var(const setting_var<model>&);
 222         setting_var<model>& operator=(const setting_var<model>&);
 223 public:
 224 /**
 225  * Constructor.
 226  */
 227         setting_var(setting_var_group& group, const std::string& iname, const std::string& hname,
 228                 valtype_t defaultvalue)
 229                 : setting_var_base(group, iname, hname)
 230         {
 231                 value = defaultvalue;
 232         }
 233 /**
 234  * Destructor.
 235  */
 236         virtual ~setting_var() throw()
 237         {
 238         }
 239 /**
 240  * Set setting.
 241  */
 242         void str(const std::string& val) throw(std::runtime_error, std::bad_alloc)
 243         {
 244                 {
 245                         umutex_class h(lock);
 246                         value = model::read(val);
 247                 }
 248                 group.fire_listener(*this);
 249         }
 250 /**
 251  * Get setting.
 252  */
 253         std::string str() const throw(std::runtime_error, std::bad_alloc)
 254         {
 255                 umutex_class h(lock);
 256                 return model::write(value);
 257         }
 258 /**
 259  * Set setting.
 260  */
 261         void set(valtype_t _value) throw(std::runtime_error, std::bad_alloc)
 262         {
 263                 {
 264                         umutex_class h(lock);
 265                         if(!model::valid(value))
 266                                 throw std::runtime_error("Invalid value");
 267                         value = _value;
 268                 }
 269                 group.fire_listener(*this);
 270         }
 271 /**
 272  * Get setting.
 273  */
 274         valtype_t get() throw(std::bad_alloc)
 275         {
 276                 umutex_class h(lock);
 277                 return model::transform(value);
 278         }
 279 /**
 280  * Get setting.
 281  */
 282         operator valtype_t()
 283         {
 284                 return get();
 285         }
 286 /**
 287  * Get setting description.
 288  */
 289         const setting_var_description& get_description() const throw()
 290         {
 291                 return setting_var_description_get(dummy);
 292         }
 293 private:
 294         valtype_t value;
 295         model dummy;
 296 };
 297
 298 /**
 299  * Yes-no.
 300  */
 301 struct setting_yes_no
 302 {
 303         static const char* enable;
 304         static const char* disable;
 305 };
 306
 307 /**
 308  * Model: Boolean.
 309  */
 310 template<typename values> struct setting_var_model_bool
 311 {
 312         typedef bool valtype_t;
 313         static bool valid(bool val) { return true; /* Any boolean is valid boolean. */ }
 314         static bool read(const std::string& val)
 315         {
 316                 int x = string_to_bool(val);
 317                 if(x < 0)
 318                         throw std::runtime_error("Invalid boolean value");
 319                 return (x != 0);
 320         }
 321         static std::string write(bool val)
 322         {
 323                 return val ? values::enable : values::disable;
 324         }
 325         static bool transform(bool val) { return val; }
 326 };
 327
 328 template<typename values> setting_var_description& setting_var_description_get(
 329         setting_var_model_bool<values> X)
 330 {
 331         static setting_var_description x;
 332         static bool init = false;
 333         if(!init) {
 334                 x.type = setting_var_description::T_BOOLEAN;
 335                 init = true;
 336         }
 337         return x;
 338 }
 339
 340 /**
 341  * Model: Integer.
 342  */
 343 template<int32_t minimum, int32_t maximum> struct setting_var_model_int
 344 {
 345         typedef int32_t valtype_t;
 346         static bool valid(int32_t val) { return (val >= minimum && val <= maximum); }
 347         static int32_t read(const std::string& val)
 348         {
 349                 int x = parse_value<int32_t>(val);
 350                 if(x < minimum || x > maximum)
 351                         (stringfmt() << "Value out of range (" << minimum << " to " << maximum << ")").throwex();
 352                 return x;
 353         }
 354         static std::string write(int32_t val)
 355         {
 356                 return (stringfmt() << val).str();
 357         }
 358         static int transform(int val) { return val; }
 359 };
 360
 361 template<int32_t m, int32_t M> setting_var_description& setting_var_description_get(setting_var_model_int<m, M> X)
 362 {
 363         static setting_var_description x;
 364         static bool init = false;
 365         if(!init) {
 366                 x.type = setting_var_description::T_NUMERIC;
 367                 x.min_val = m;
 368                 x.max_val = M;
 369                 init = true;
 370         }
 371         return x;
 372 }
 373
 374 /**
 375  * Model: Path.
 376  */
 377 struct setting_var_model_path
 378 {
 379         typedef std::string valtype_t;
 380         static bool valid(std::string val) { return true; /* Any boolean is valid boolean. */ }
 381         static std::string read(const std::string& val)
 382         {
 383                 return val;
 384         }
 385         static std::string write(std::string val)
 386         {
 387                 return val;
 388         }
 389         static std::string transform(std::string val)
 390         {
 391                 return (val != "") ? val : ".";
 392         }
 393 };
 394
 395 template<> setting_var_description& setting_var_description_get(setting_var_model_path X)
 396 {
 397         static setting_var_description x;
 398         static bool init = false;
 399         if(!init) {
 400                 x.type = setting_var_description::T_PATH;
 401                 init = true;
 402         }
 403         return x;
 404 }
 405
 406 /**
 407  * Model: Enumerated.
 408  */
 409 template<setting_enumeration* e> struct setting_var_model_enumerated
 410 {
 411         typedef unsigned valtype_t;
 412         static bool valid(unsigned val) { return (val <= e->max_val()); }
 413         static unsigned read(const std::string& val)
 414         {
 415                 for(unsigned i = 0; i <= e->max_val(); i++)
 416                         if(val == e->get(i))
 417                                 return i;
 418                 unsigned x = parse_value<unsigned>(val);
 419                 if(x > e->max_val())
 420                         (stringfmt() << "Value out of range (0  to " << e->max_val() << ")").throwex();
 421                 return x;
 422         }
 423         static std::string write(unsigned val)
 424         {
 425                 return e->get(val);
 426         }
 427         static int transform(int val) { return val; }
 428 };
 429
 430 template<setting_enumeration* e> setting_var_description& setting_var_description_get(
 431         setting_var_model_enumerated<e> X)
 432 {
 433         static setting_var_description x;
 434         static bool init = false;
 435         if(!init) {
 436                 x.type = setting_var_description::T_ENUMERATION;
 437                 x.enumeration = e;
 438                 init = true;
 439         }
 440         return x;
 441 }
 442
 443
 444 #endif