src/global/vlp/config.cpp

   1 #include "vlp/config.h"
   2
   3 #include <cstring>
   4
   5 namespace loglan {
   6 namespace vlp {
   7
   8 Config::Config()
   9 {
  10         config_init(&cfg);
  11         file = NULL;
  12 }
  13
  14 Config::~Config()
  15 {
  16         config_destroy(&cfg);
  17         if (file) {
  18                 fclose(file);
  19                 file = NULL;
  20         }
  21 }
  22
  23 bool Config::load(const char * configFilePath)
  24 {
  25         file = fopen(configFilePath, "rt");
  26         if (!file) {
  27                 fprintf(stderr,
  28                         "Error: Cannot load configuration file: %s!\n",
  29                         configFilePath
  30                 );
  31                 return false;
  32         }
  33
  34         if (!config_read(&cfg, file)) {
  35                 fprintf(stderr,
  36                         "%s! In file %s, line %d\n",
  37                         config_error_text(&cfg),
  38                         config_error_file(&cfg),
  39                         config_error_line(&cfg));
  40                 return false;
  41         }
  42
  43         return true;
  44 }
  45
  46 bool Config::save(const char * configFilePath)
  47 {
  48         if(!config_write_file(&cfg, configFilePath)) {
  49                 fprintf(stderr,
  50                         "Error: Cannot save configuration file: %s!\n",
  51                         configFilePath
  52                 );
  53                 return false;
  54         }
  55
  56         return true;
  57 }
  58
  59 int Config::getNodeNumber()
  60 {
  61         config_setting_t *setting = config_lookup(&cfg, "node_number");
  62
  63         if (!setting) {
  64                 fprintf(stderr,
  65                         "%s! In file %s, '%s' was not found.\n",
  66                         "Warning",
  67                         config_error_file(&cfg),
  68                         "node_number"
  69                 );
  70
  71                 throw;
  72         }
  73
  74         return config_setting_get_int(setting);
  75 }
  76 void Config::setNodeNumber(int nodeNumber)
  77 {
  78         config_setting_t *setting;
  79         config_setting_t *root = config_root_setting(&cfg);
  80
  81         setting = config_setting_get_member(root, "node_number");
  82
  83         if(!setting) {
  84                 setting = config_setting_add(
  85                         root,
  86                         "node_number",
  87                         CONFIG_TYPE_INT
  88                 );
  89         }
  90         config_setting_set_int(setting, nodeNumber);
  91 }
  92
  93 std::vector<std::string> Config::getHosts()
  94 {
  95         config_setting_t *setting = config_lookup(&cfg, "host");
  96         std::vector<std::string> hosts;
  97
  98         if (!setting) {
  99                 fprintf(stderr,
 100                         "%s! In file %s, '%s' was not found.\n",
 101                         "Warning",
 102                         "configuration",//config_error_file(&cfg),
 103                         "host"
 104                 );
 105
 106                 return hosts;
 107         }
 108
 109         switch(config_setting_type(setting)) {
 110         /* TODO: Deprecated. Made for back compatibility. */
 111         case CONFIG_TYPE_STRING: {
 112                 std::string host(config_setting_get_string(setting));
 113                 hosts.push_back(host);
 114                 break;
 115         }
 116         case CONFIG_TYPE_ARRAY: {
 117                 int size = config_setting_length(setting);
 118                 std::string host;
 119                 for (int i = 0; i < size; i++) {
 120                         host = config_setting_get_string_elem(setting, i);
 121                         hosts.push_back(host);
 122                 }
 123                 break;
 124         }
 125         default:
 126                 fprintf(stderr,
 127                         "%s! In file %s, bad entry type for %s will not be read.\n",
 128                         "Warning",
 129                         "configuration",//config_error_file(&cfg),
 130                         "host"
 131                 );
 132         }
 133
 134         return hosts;
 135 }
 136
 137 void Config::setHosts(std::vector<std::string> hosts)
 138 {
 139         config_setting_t *root = config_root_setting(&cfg);
 140         config_setting_t *setting = NULL;
 141
 142         setting = config_setting_add(root, "host", CONFIG_TYPE_ARRAY);
 143
 144         for (auto host : hosts) {
 145                 config_setting_set_string(
 146                         config_setting_add(setting, NULL, CONFIG_TYPE_STRING),
 147                         host.c_str()
 148                 );
 149         }
 150 }
 151
 152 ConnectionType Config::getConnectionType()
 153 {
 154         config_setting_t *setting = config_lookup(&cfg, "type");
 155
 156         if (!setting) {
 157                 fprintf(stderr,
 158                         "%s! In file %s, '%s' was not found.\n",
 159                         "Warning",
 160                         "configuration",//config_error_file(&cfg),
 161                         "type"
 162                 );
 163
 164                 throw;
 165         }
 166
 167         /* same as strcmp(..) == 0 */
 168         if (!strcmp(config_setting_get_string(setting), "explicit")) {
 169                 return EXPLICIT;
 170         }
 171
 172         return REGISTER;
 173 }
 174 void Config::setConnectionType(ConnectionType type)
 175 {
 176         config_setting_t *setting;
 177         config_setting_t *root = config_root_setting(&cfg);
 178
 179         setting = config_setting_get_member(root, "type");
 180
 181         if(!setting) {
 182                 setting = config_setting_add(
 183                         root,
 184                         "type",
 185                         CONFIG_TYPE_STRING
 186                 );
 187         }
 188
 189         if (type == EXPLICIT) {
 190                 config_setting_set_string(setting, "explicit");
 191         }
 192         else if (type == REGISTER) {
 193                 config_setting_set_string(setting, "register");
 194         }
 195 }
 196
 197 const char * Config::getProgramDir()
 198 {
 199         config_setting_t *setting = config_lookup(&cfg, "progdir");
 200
 201         if (!setting) {
 202                 fprintf(stderr,
 203                         "%s! In file %s, '%s' was not found.\n",
 204                         "Warning",
 205                         "configuration",//config_error_file(&cfg),
 206                         "progdir"
 207                 );
 208         }
 209
 210         return config_setting_get_string(setting);
 211 }
 212 void Config::setProgramDir(const char * programDir)
 213 {
 214         config_setting_t *setting;
 215         config_setting_t *root = config_root_setting(&cfg);
 216
 217         setting = config_setting_get_member(root, "progdir");
 218
 219         if(!setting) {
 220                 setting = config_setting_add(
 221                         root,
 222                         "progdir",
 223                         CONFIG_TYPE_STRING
 224                 );
 225         }
 226         config_setting_set_string(setting, programDir);
 227 }
 228
 229 }
 230 }