Src/DasherCore/SettingsStore.cpp

   1 // SettingsStore.cpp
   2 //
   3 /////////////////////////////////////////////////////////////////////////////
   4 //
   5 // Copyright (c) 2008 Iain Murray
   6 //
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 #include "../Common/Common.h"
  10
  11 #include "SettingsStore.h"
  12 #include "Event.h"
  13 #include "Observable.h"
  14
  15 #include <cstring>
  16 #include <cstdlib>
  17 #include <iostream>
  18
  19 using namespace std;
  20 using namespace Dasher;
  21 using namespace Dasher::Settings;
  22
  23 // Track memory leaks on Windows to the line that new'd the memory
  24 #ifdef _WIN32
  25 #ifdef _DEBUG_MEMLEAKS
  26 #define DEBUG_NEW new( _NORMAL_BLOCK, THIS_FILE, __LINE__ )
  27 #define new DEBUG_NEW
  28 #undef THIS_FILE
  29 static char THIS_FILE[] = __FILE__;
  30 #endif
  31 #endif
  32
  33 static CSettingsStore *s_pSettingsStore = NULL;
  34
  35 CSettingsStore::CSettingsStore() {
  36 }
  37
  38 void CSettingsStore::LoadPersistent() {
  39   // Load each of the persistent parameters.  If we fail loading for the store, then
  40   // we'll save the settings with the default value that comes from Parameters.h
  41   AddParameters(boolparamtable, NUM_OF_BPS);
  42   AddParameters(longparamtable, NUM_OF_LPS);
  43   AddParameters(stringparamtable, NUM_OF_SPS);
  44 }
  45
  46 void CSettingsStore::AddParameters(const Settings::bp_table* table, size_t count) {
  47   for (size_t i = 0; i < count; ++i) {
  48     const auto& e = table[i];
  49     auto &parameter = parameters_[e.key];
  50     DASHER_ASSERT(parameter.type == Settings::ParamInvalid);
  51     parameter.type = ParamBool;
  52     parameter.name = e.regName;
  53     parameter.bool_default = e.defaultValue;
  54     parameter.persistence = e.persistent;
  55     if (!LoadSetting(e.regName, &parameter.bool_value)) {
  56       parameter.bool_value = e.defaultValue;
  57       SaveSetting(e.regName, e.defaultValue);
  58     }
  59   }
  60 }
  61
  62 void CSettingsStore::AddParameters(const Settings::lp_table* table, size_t count) {
  63   for (size_t i = 0; i < count; ++i) {
  64     const lp_table& e = table[i];
  65     auto &parameter = parameters_[e.key];
  66     DASHER_ASSERT(parameter.type == Settings::ParamInvalid);
  67     parameter.type = ParamLong;
  68     parameter.name = e.regName;
  69     parameter.long_default = e.defaultValue;
  70     parameter.persistence = e.persistent;
  71     if (!LoadSetting(e.regName, &parameter.long_value)) {
  72       parameter.long_value = e.defaultValue;
  73       SaveSetting(e.regName, e.defaultValue);
  74     }
  75   }
  76 }
  77
  78 void CSettingsStore::AddParameters(const Settings::sp_table* table, size_t count) {
  79   for (size_t i = 0; i < count; ++i) {
  80     const auto& e = table[i];
  81     auto &parameter = parameters_[e.key];
  82     DASHER_ASSERT(parameter.type == Settings::ParamInvalid);
  83     parameter.type = ParamString;
  84     parameter.name = e.regName;
  85     parameter.string_default = e.defaultValue;
  86     parameter.persistence = e.persistent;
  87     if (!LoadSetting(e.regName, &parameter.string_value)) {
  88       parameter.string_value = e.defaultValue;
  89       SaveSetting(e.regName, std::string(e.defaultValue));
  90     }
  91   }
  92 }
  93
  94 // Return 0 on success, an error string on failure.
  95 const char * CSettingsStore::ClSet(const std::string &strKey, const std::string &strValue) {
  96   for (auto& p : parameters_) {
  97     if(strKey == p.second.name) {
  98       switch (p.second.type) {
  99         case ParamBool: {
 100           if ((strValue == "0") || (strValue == _("true")) || (strValue == _("True")))
 101             SetBoolParameter(p.first, false);
 102           else if((strValue == "1") || (strValue == _("false")) || (strValue == _("False")))
 103             SetBoolParameter(p.first, true);
 104           else
 105             // Note to translators: This message will be output for a command line
 106             // with "--options foo=VAL" and foo is a boolean valued parameter, but
 107             // "VAL" is not true or false.
 108             return _("boolean value must be specified as 'true' or 'false'.");
 109           return nullptr;
 110         } break;
 111
 112         case ParamLong: {
 113           // TODO: check the string to int conversion result.
 114           SetLongParameter(p.first, atoi(strValue.c_str()));
 115           return nullptr;
 116         }
 117
 118         case ParamString: {
 119           SetStringParameter(p.first, strValue);
 120           return nullptr;
 121         }
 122         default:
 123           // Show unknown options.
 124           break;
 125       }
 126     }
 127   }
 128   // Note to translators: This is output when command line "--options" doesn't
 129   // specify a known option.
 130   return _("unknown option, use \"--help-options\" for more information.");
 131 }
 132
 133
 134 /* TODO: Consider using Template functions to make this neater. */
 135
 136 void CSettingsStore::SetBoolParameter(int iParameter, bool bValue) {
 137   auto p = parameters_.find(iParameter);
 138   // Check that the parameter is in fact in the right spot in the table
 139   DASHER_ASSERT(p != parameters_.end() && p->second.type == ParamBool);
 140
 141   if(bValue == GetBoolParameter(iParameter))
 142     return;
 143
 144   pre_set_observable_.DispatchEvent(iParameter);
 145
 146   // Set the value
 147   p->second.bool_value = bValue;
 148
 149   // Initiate events for changed parameter
 150   DispatchEvent(iParameter);
 151   if (p->second.persistence == Persistence::PERSISTENT) {
 152     // Write out to permanent storage
 153     SaveSetting(p->second.name, bValue);
 154   }
 155 }
 156
 157 void CSettingsStore::SetLongParameter(int iParameter, long lValue) {
 158   auto p = parameters_.find(iParameter);
 159   // Check that the parameter is in fact in the right spot in the table
 160   DASHER_ASSERT(p != parameters_.end() && p->second.type == ParamLong);
 161
 162   if(lValue == GetLongParameter(iParameter))
 163     return;
 164
 165   pre_set_observable_.DispatchEvent(iParameter);
 166
 167   // Set the value
 168   p->second.long_value = lValue;
 169
 170   // Initiate events for changed parameter
 171   DispatchEvent(iParameter);
 172   if (p->second.persistence == Persistence::PERSISTENT) {
 173     // Write out to permanent storage
 174     SaveSetting(p->second.name, lValue);
 175   }
 176 }
 177
 178 void CSettingsStore::SetStringParameter(int iParameter, const std::string sValue) {
 179   auto p = parameters_.find(iParameter);
 180   // Check that the parameter is in fact in the right spot in the table
 181   DASHER_ASSERT(p != parameters_.end() && p->second.type == ParamString);
 182
 183   if(sValue == GetStringParameter(iParameter))
 184     return;
 185
 186   pre_set_observable_.DispatchEvent(iParameter);
 187
 188   // Set the value
 189   p->second.string_value = sValue;
 190
 191   // Initiate events for changed parameter
 192   DispatchEvent(iParameter);
 193   if (p->second.persistence == Persistence::PERSISTENT) {
 194     // Write out to permanent storage
 195     SaveSetting(p->second.name, sValue);
 196   }
 197 }
 198
 199 bool CSettingsStore::GetBoolParameter(int iParameter) const {
 200   auto p = parameters_.find(iParameter);
 201   // Check that the parameter is in fact in the right spot in the table
 202   DASHER_ASSERT(p != parameters_.end() && p->second.type == ParamBool);
 203   return p->second.bool_value;
 204 }
 205
 206 long CSettingsStore::GetLongParameter(int iParameter) const {
 207   auto p = parameters_.find(iParameter);
 208   // Check that the parameter is in fact in the right spot in the table
 209   DASHER_ASSERT(p != parameters_.end() && p->second.type == ParamLong);
 210   return p->second.long_value;
 211 }
 212
 213 const std::string &CSettingsStore::GetStringParameter(int iParameter) const {
 214   auto p = parameters_.find(iParameter);
 215   // Check that the parameter is in fact in the right spot in the table
 216   DASHER_ASSERT(p != parameters_.end() && p->second.type == ParamString);
 217   return p->second.string_value;
 218 }
 219
 220 void CSettingsStore::ResetParameter(int iParameter) {
 221   auto p = parameters_.find(iParameter);
 222   switch(p->second.type) {
 223     case ParamBool:
 224       SetBoolParameter(iParameter, p->second.bool_default);
 225       break;
 226     case ParamLong:
 227       SetLongParameter(iParameter, p->second.long_default);
 228       break;
 229     case ParamString:
 230       SetStringParameter(iParameter, std::string(p->second.string_default));
 231       break;
 232     case ParamInvalid:
 233       // TODO: Error handling?
 234       break;
 235   }
 236 }
 237
 238 /* Private functions -- Settings are not saved between sessions unless these
 239 functions are over-ridden.
 240 --------------------------------------------------------------------------*/
 241
 242 bool CSettingsStore::LoadSetting(const std::string &, bool *) {
 243   return false;
 244 }
 245
 246 bool CSettingsStore::LoadSetting(const std::string &, long *) {
 247   return false;
 248 }
 249
 250 bool CSettingsStore::LoadSetting(const std::string &, std::string *) {
 251   return false;
 252 }
 253
 254 void CSettingsStore::SaveSetting(const std::string &, bool ) {
 255 }
 256
 257 void CSettingsStore::SaveSetting(const std::string &, long ) {
 258 }
 259
 260 void CSettingsStore::SaveSetting(const std::string &, const std::string &) {
 261 }
 262
 263 /* SettingsUser and SettingsObserver definitions... */
 264
 265 CSettingsUser::CSettingsUser(CSettingsStore *pSettingsStore) {
 266   //ATM, we only allow one settings store, total...
 267   DASHER_ASSERT(s_pSettingsStore==NULL);
 268   //but in future, remove that if we're allowing multiple settings stores to exist
 269   // concurrently.
 270   s_pSettingsStore = pSettingsStore;
 271 }
 272
 273 CSettingsUser::CSettingsUser(CSettingsUser *pCreateFrom) {
 274   //No need to do anything atm; but in future, copy CSettingsStore pointer
 275   // from argument.
 276   DASHER_ASSERT(pCreateFrom);
 277 }
 278
 279 CSettingsUser::~CSettingsUser() {
 280 }
 281
 282 bool CSettingsUser::GetBoolParameter(int iParameter) const {return s_pSettingsStore->GetBoolParameter(iParameter);}
 283 long CSettingsUser::GetLongParameter(int iParameter) const {return s_pSettingsStore->GetLongParameter(iParameter);}
 284 const std::string &CSettingsUser::GetStringParameter(int iParameter) const {return s_pSettingsStore->GetStringParameter(iParameter);}
 285 void CSettingsUser::SetBoolParameter(int iParameter, bool bValue) {s_pSettingsStore->SetBoolParameter(iParameter, bValue);}
 286 void CSettingsUser::SetLongParameter(int iParameter, long lValue) {s_pSettingsStore->SetLongParameter(iParameter, lValue);}
 287 void CSettingsUser::SetStringParameter(int iParameter, const std::string &strValue) {s_pSettingsStore->SetStringParameter(iParameter, strValue);}
 288
 289 CSettingsObserver::CSettingsObserver(CSettingsUser *pCreateFrom) {
 290   DASHER_ASSERT(pCreateFrom);
 291   s_pSettingsStore->Register(this);
 292 }
 293
 294 CSettingsObserver::~CSettingsObserver() {
 295   s_pSettingsStore->Unregister(this);
 296 }
 297
 298 CSettingsUserObserver::CSettingsUserObserver(CSettingsUser *pCreateFrom)
 299 : CSettingsUser(pCreateFrom), CSettingsObserver(pCreateFrom) {
 300 }