settings.cpp

Go to the documentation of this file.

#include "utils/settings.hpp"
#include "utils/file.hpp"
#include "utils/logger.hpp"
 
shared_ptr<json> galaxis::utils::read_json_file(std::string path) {
  auto fileContentRawSPtr = read_file_to_string(path);
  
  auto filecontentSPtr = std::make_shared<json>();
  *filecontentSPtr = nlohmann::json::parse(*fileContentRawSPtr);
 
  return filecontentSPtr;
}
 
shared_ptr<json> galaxis::utils::read_system_settings(std::string key) {
  std::string systemSettingsPath = "settings/runtime_system.json";
 
  auto fileContentRawSPtr = read_file_to_string(systemSettingsPath);
 
  auto filecontentSPtr = std::make_shared<json>();
  *filecontentSPtr = nlohmann::json::parse(*fileContentRawSPtr)[key];
  return filecontentSPtr;
}
 
shared_ptr<std::string> galaxis::utils::read_file_to_string(std::string path) {
  // open file and append to string 
  std::ifstream file;
  file.open(path);
  std::shared_ptr<std::string> fileContent = std::make_shared<std::string>();
 
  if(file.is_open()) {
    std::string line;
 
    while(getline(file, line)) {
      (*fileContent) += line;
    }
 
    file.close();
  }
  else {
    log_debug("Failed to load file: ", path);
    throw std::runtime_error("Failed to load file.");
  }
 
  return fileContent;
}
 
// using namespace galaxis::utils;
// // ############### SETTINGS CLASS #####################
// Settings::Settings() {}
// Settings::~Settings() {}
 
// void Settings::load(std::shared_ptr<json> settingsJson) {
//   if(loadLock == true) {
//     log_warning("[utils/settings.hpp | Settings] Settings already loaded. Cannot load them again!");
//     return;
//   }
 
//   booleanParamMap.clear();
//   integerParamMap.clear();
//   doubleParamMap.clear();
//   stringParamMap.clear();
 
//   for (json::iterator paramIt = settingsJson->begin(); paramIt != settingsJson->end(); ++paramIt) {
//     try {
//       if(itParam.value().is_boolean()) {
//         booleanParamMap.insert(std::make_pair(paramIt.key(), paramIt.value()))
//       }
//       else if(itParam.value().is_number()) {
//         if(itParam.value().is_number_integer()) {
//           integerParamMap.insert(std::make_pair(paramIt.key(), paramIt.value()))
//         }
//         else if(itParam.value().is_number_float()) {
//           doubleParamMap.insert(std::make_pair(paramIt.key(), paramIt.value()))
//         }
//       }
//       else if (itParam.value().is_string()) {
//         stringParamMap.insert(std::make_pair(paramIt.key(), paramIt.value()))
//       }
//       else {
//         log_warning("[utils/settings.hpp | Settings] Parameter Type not implemented!");
//       }
//     }
//     catch (std::exception &e) {
//       log_warning("[utils/settings.hpp | Settings] Parameter Type not implemented!");
//     }
//   }
 
//   loadLock = true;
// }
 
// ParameterType Settings::getType(std::string key) {
//   if(booleanParamMap.find(key) != booleanParamMap.end()) {
//     return BOOLEAN;
//   }
//   if(integerParamMap.find(key) != integerParamMap.end()) {
//     return INTEGER;
//   }
//   if(doubleParamMap.find(key) != doubleParamMap.end()) {
//     return DOUBLE;
//   }
//   if(stringParamMap.find(key) != stringParamMap.end()) {
//     return STRING;
//   }
//   return NOTEXIST;
// }
 
// bool Settings::getParamBool(std::string key) {
//   if(booleanParamMap.find(key) != booleanParamMap.end()) {
//     return booleanParamMap[key];
//   }
//   else {
//     log_warning("[utils/settings.hpp | Settings] Bool Parameter not found: ", key);
//     return false;
//   }
// }
 
// double Settings::getParamInteger(std::string key) {
//   if(integerParamMap.find(key) != integerParamMap.end()) {
//     return integerParamMap[key];
//   }
//   else {
//     log_warning("[utils/settings.hpp | Settings] Integer Parameter not found: ", key);
//     return false;
//   }
// }
 
// double Settings::getParamDouble(std::string key) {
//   if(doubleParamMap.find(key) != doubleParamMap.end()) {
//     return doubleParamMap[key];
//   }
//   else {
//     log_warning("[utils/settings.hpp | Settings] Double Parameter not found: ", key);
//     return false;
//   }
// }
 
// std::string Settings::getParamString(std::string key) {
//   if(stringParamMap.find(key) != stringParamMap.end()) {
//     return stringParamMap[key];
//   }
//   else {
//     log_warning("[utils/settings.hpp | Settings] String Parameter not found: ", key);
//     return "";
//   }
// }