src/library/settingvar.cpp

   1 #include "settingvar.hpp"
   2 #include "register-queue.hpp"
   3
   4 namespace
   5 {
   6         typedef register_queue<setting_var_group, setting_var_base> regqueue_t;
   7 }
   8
   9 setting_var_listener::~setting_var_listener() throw()
  10 {
  11 }
  12
  13 setting_var_group::setting_var_group() throw(std::bad_alloc)
  14 {
  15         regqueue_t::do_ready(*this, true);
  16 }
  17
  18 setting_var_group::~setting_var_group() throw()
  19 {
  20         regqueue_t::do_ready(*this, false);
  21 }
  22
  23 std::set<std::string> setting_var_group::get_settings_set() throw(std::bad_alloc)
  24 {
  25         umutex_class(lock);
  26         std::set<std::string> x;
  27         for(auto i : settings)
  28                 x.insert(i.first);
  29         return x;
  30 }
  31
  32 setting_var_base& setting_var_group::operator[](const std::string& name)
  33 {
  34         umutex_class(lock);
  35         if(!settings.count(name))
  36                 throw std::runtime_error("No such setting");
  37         return *settings[name];
  38 }
  39
  40 void setting_var_group::fire_listener(setting_var_base& var) throw()
  41 {
  42         std::set<setting_var_listener*> l;
  43         {
  44                 umutex_class h(lock);
  45                 for(auto i : listeners)
  46                         l.insert(i);
  47         }
  48         for(auto i : l)
  49                 try {
  50                         i->on_setting_change(*this, var);
  51                 } catch(...) {
  52                 }
  53 }
  54
  55 void setting_var_group::add_listener(struct setting_var_listener& listener) throw(std::bad_alloc)
  56 {
  57         umutex_class(lock);
  58         listeners.insert(&listener);
  59 }
  60
  61 void setting_var_group::remove_listener(struct setting_var_listener& listener) throw(std::bad_alloc)
  62 {
  63         umutex_class(lock);
  64         listeners.erase(&listener);
  65 }
  66
  67 void setting_var_group::do_register(const std::string& name, setting_var_base& _setting) throw(std::bad_alloc)
  68 {
  69         umutex_class h(lock);
  70         settings[name] = &_setting;
  71 }
  72
  73 void setting_var_group::do_unregister(const std::string& name) throw(std::bad_alloc)
  74 {
  75         umutex_class h(lock);
  76         settings.erase(name);
  77 }
  78
  79 setting_var_base::setting_var_base(setting_var_group& _group, const std::string& _iname, const std::string& _hname)
  80         throw(std::bad_alloc)
  81         : group(_group), iname(_iname), hname(_hname)
  82 {
  83         regqueue_t::do_register(group, iname, *this);
  84 }
  85
  86 setting_var_base::~setting_var_base() throw()
  87 {
  88         regqueue_t::do_unregister(group, iname);
  89 }
  90
  91 setting_var_cache::setting_var_cache(setting_var_group& _grp)
  92         : grp(_grp)
  93 {
  94 }
  95
  96 std::map<std::string, std::string> setting_var_cache::get_all()
  97 {
  98         std::map<std::string, std::string> x;
  99         auto s = grp.get_settings_set();
 100         for(auto i : s)
 101                 x[i] = grp[i].str();
 102         for(auto i : badcache)
 103                 x[i.first] = i.second;
 104         return x;
 105 }
 106
 107 std::set<std::string> setting_var_cache::get_keys()
 108 {
 109         return grp.get_settings_set();
 110 }
 111
 112 void setting_var_cache::set(const std::string& name, const std::string& value, bool allow_invalid)
 113         throw(std::bad_alloc, std::runtime_error)
 114 {
 115         try {
 116                 grp[name].str(value);
 117                 umutex_class h(lock);
 118                 badcache.erase(name);
 119         } catch(std::bad_alloc& e) {
 120                 throw;
 121         } catch(std::exception& e) {
 122                 if(allow_invalid) {
 123                         umutex_class h(lock);
 124                         badcache[name] = value;
 125                 } else
 126                         throw;
 127         }
 128 }
 129
 130 std::string setting_var_cache::get(const std::string& name) throw(std::bad_alloc, std::runtime_error)
 131 {
 132         return grp[name].str();
 133 }
 134
 135 const setting_var_description& setting_var_cache::get_description(const std::string& name) throw(std::bad_alloc,
 136         std::runtime_error)
 137 {
 138         return grp[name].get_description();
 139 }
 140
 141
 142 const char* setting_yes_no::enable = "yes";
 143 const char* setting_yes_no::disable = "no";