Skip to content

Commit

Permalink
refactor ncriticalpathparameters class, all QT dependencies were drop…
Browse files Browse the repository at this point in the history 
…ped out, now we use nlohmann::json to maintain settings in a shema compatible with QLSettingsManager
  • Loading branch information
@w0lek
w0lek committed Nov 24, 2023
1 parent 149cc28 commit af3d5db
Show file tree
Hide file tree
Showing 4 changed files with 237 additions and 106 deletions.
2 changes: 1 addition & 1 deletion src/InteractivePathAnalysis/client/client.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -94,7 +94,7 @@ void Client::sendRequest(QByteArray& requestBytes, const QString& initiator)
void Client::requestPathList(const QString& initiator)
{
QByteArray bytes = RequestCreator::instance().getPathListRequestTelegram(m_parameters->getCriticalPathNum(),
m_parameters->getPathType(),
m_parameters->getPathType().c_str(),
m_parameters->getPathDetailLevel(),
m_parameters->getIsFlatRouting());
sendRequest(bytes, initiator);
Expand Down
244 changes: 182 additions & 62 deletions src/InteractivePathAnalysis/ncriticalpathparameters.cpp
View file
Original file line number Diff line number Diff line change
@@ -1,58 +1,153 @@
#include "ncriticalpathparameters.h"
#include "simplelogger.h"

#include <fstream>
#include <iostream>

#ifndef STANDALONE_APP
#include "../Compiler/QLSettingsManager.h"
#endif

NCriticalPathParameters::NCriticalPathParameters()
{
loadFromFile();
if (std::filesystem::exists(filePath())) {
loadFromFile();
}
validateDefaultValues();
}

void NCriticalPathParameters::validateDefaultValues()
{
bool requireSave = false;

if (std::string value = getDefaultValueString(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_HIGH_LIGHT_MODE); value != DEFAULT_VALUE_PATHLIST_PARAMETER_HIGH_LIGHT_MODE) {
m_json[CATEGORY][SUBCATEGORY_PATHLIST][PARAMETER_HIGH_LIGHT_MODE][KEY_DEFAULT_VALUE] = DEFAULT_VALUE_PATHLIST_PARAMETER_HIGH_LIGHT_MODE;
requireSave = true;
}
if (std::string value = getDefaultValueString(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_TYPE); value != DEFAULT_VALUE_PATHLIST_PARAMETER_TYPE) {
m_json[CATEGORY][SUBCATEGORY_PATHLIST][PARAMETER_TYPE][KEY_DEFAULT_VALUE] = DEFAULT_VALUE_PATHLIST_PARAMETER_TYPE;
requireSave = true;
}
if (std::string value = getDefaultValueString(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_DETAIL_LEVEL); value != DEFAULT_VALUE_PATHLIST_PARAMETER_DETAIL_LEVEL) {
m_json[CATEGORY][SUBCATEGORY_PATHLIST][PARAMETER_DETAIL_LEVEL][KEY_DEFAULT_VALUE] = DEFAULT_VALUE_PATHLIST_PARAMETER_DETAIL_LEVEL;
requireSave = true;
}
if (std::string value = getDefaultValueString(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_MAX_NUM); value != DEFAULT_VALUE_PATHLIST_PARAMETER_MAX_NUM) {
m_json[CATEGORY][SUBCATEGORY_PATHLIST][PARAMETER_MAX_NUM][KEY_DEFAULT_VALUE] = DEFAULT_VALUE_PATHLIST_PARAMETER_MAX_NUM;
requireSave = true;
}
if (std::string value = getDefaultValueString(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_SAVE_SETTINGS); value != DEFAULT_VALUE_PATHLIST_PARAMETER_SAVE_SETTINGS) {
m_json[CATEGORY][SUBCATEGORY_PATHLIST][PARAMETER_SAVE_SETTINGS][KEY_DEFAULT_VALUE] = DEFAULT_VALUE_PATHLIST_PARAMETER_SAVE_SETTINGS;
requireSave = true;
}
#ifdef ENABLE_FILTER_SAVE_SETTINGS_FEATURE
if (std::string value = getDefaultValueString(CATEGORY, SUBCATEGORY_FILTER, PARAMETER_SAVE_SETTINGS); value != DEFAULT_VALUE_FILTER_PARAMETER_SAVE_SETTINGS) {
m_json[CATEGORY][SUBCATEGORY_FILTER][PARAMETER_SAVE_SETTINGS][KEY_DEFAULT_VALUE] = DEFAULT_VALUE_FILTER_PARAMETER_SAVE_SETTINGS;
requireSave = true;
}
#endif
#ifdef STANDALONE_APP
if (std::string value = getDefaultValueString(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_IS_FLAT_ROUTING); value != DEFAULT_VALUE_PATHLIST_PARAMETER_IS_FLAT_ROUTING) {
m_json[CATEGORY][SUBCATEGORY_PATHLIST][PARAMETER_IS_FLAT_ROUTING][KEY_DEFAULT_VALUE] = DEFAULT_VALUE_PATHLIST_PARAMETER_IS_FLAT_ROUTING;
requireSave = true;
}
#endif

if (requireSave) {
saveToFile();
}
}

std::string NCriticalPathParameters::getDefaultValueString(const std::string& category, const std::string& subcategory, const std::string& parameter)
{
return getStringValue(category, subcategory, parameter, /*forceReturnDefaultValue*/true);
}

void NCriticalPathParameters::setHighLightMode(int value)
{
m_parameters.hightLightMode = value;
setIntValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_HIGH_LIGHT_MODE, value);
}

void NCriticalPathParameters::setPathType(const QString& value)
void NCriticalPathParameters::setPathType(const std::string& value)
{
m_parameters.pathType = value;
setStringValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_TYPE, value);
}

void NCriticalPathParameters::setPathDetailLevel(int value)
{
m_parameters.pathDetailLevel = value;
setIntValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_DETAIL_LEVEL, value);
}

void NCriticalPathParameters::setCriticalPathNum(int value)
{
m_parameters.criticalPathNum = value;
setIntValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_MAX_NUM, value);
}

void NCriticalPathParameters::setSavePathListSettings(bool value)
#ifdef STANDALONE_APP
void NCriticalPathParameters::setFlatRouting(bool value)
{
m_parameters.savePathListSettings = value;
setIntValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_IS_FLAT_ROUTING, value);
}
#endif

void NCriticalPathParameters::saveOptionSavePathListSettings()
void NCriticalPathParameters::setSavePathListSettings(bool value)
{
saveIntValue(PATHLIST_SUBCATEGORY, SAVE_SETTINGS_PARAMETER, m_parameters.savePathListSettings);
setIntValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_SAVE_SETTINGS, value);
}

#ifdef ENABLE_FILTER_SAVE_SETTINGS_FEATURE
void NCriticalPathParameters::setSaveFilterSettings(bool value)
{
m_parameters.saveFilterSettings = value;
setIntValue(CATEGORY, SUBCATEGORY_FILTER, PARAMETER_SAVE_SETTINGS, value);
}
#endif

void NCriticalPathParameters::saveOptionSavePathListSettingsExplicitly(bool value)
{
setSavePathListSettings(value);
nlohmann::json json;
if (loadFromFile(json)) {
json[CATEGORY][SUBCATEGORY_PATHLIST][PARAMETER_SAVE_SETTINGS][KEY_USER_VALUE] = std::to_string(int(value));
saveToFile(json);
}
}

int NCriticalPathParameters::getHighLightMode() const
{
return getIntValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_HIGH_LIGHT_MODE);
}

std::string NCriticalPathParameters::getPathType() const
{
return getStringValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_TYPE);
}

int NCriticalPathParameters::getPathDetailLevel() const
{
return getIntValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_DETAIL_LEVEL);
}

int NCriticalPathParameters::getCriticalPathNum() const
{
return getIntValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_MAX_NUM);
}

bool NCriticalPathParameters::getSavePathListSettings() const
{
return getIntValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_SAVE_SETTINGS);
}
#ifdef ENABLE_FILTER_SAVE_SETTINGS_FEATURE
bool NCriticalPathParameters::getSaveFilterSettings() const
{
return m_parameters.saveFilterSettings;
}
#endif

bool NCriticalPathParameters::getIsFlatRouting() const
{
#ifdef STANDALONE_APP
return m_parameters.isFlatRouting;
return getIntValue(CATEGORY, SUBCATEGORY_PATHLIST, PARAMETER_IS_FLAT_ROUTING);
#else
// reload QLSettingsManager() to ensure we account for dynamic changes in the settings/power json:
FOEDAG::QLSettingsManager::reloadJSONSettings();

// check if settings were loaded correctly before proceeding:
Expand All @@ -68,72 +163,97 @@ bool NCriticalPathParameters::getIsFlatRouting() const
#endif
}

void NCriticalPathParameters::saveIntValue(const QString& subcategory, const QString& parameter, int value)
void NCriticalPathParameters::setIntValue(const std::string& category, const std::string& subcategory, const std::string& parameter, int value)
{
#ifdef STANDALONE_APP
m_settings.setValue(QList<QString>{subcategory, parameter}.join("."), value);
#else
assert(false);
#endif
m_json[category][subcategory][parameter][KEY_USER_VALUE] = std::to_string(value);
}

void NCriticalPathParameters::saveStringValue(const QString& subcategory, const QString& parameter, const QString& value)
void NCriticalPathParameters::setStringValue(const std::string& category, const std::string& subcategory, const std::string& parameter, const std::string& value)
{
#ifdef STANDALONE_APP
m_settings.setValue(QList<QString>{subcategory, parameter}.join("."), value);
#else
assert(false);
#endif
m_json[category][subcategory][parameter][KEY_USER_VALUE] = value;
}

int NCriticalPathParameters::loadIntValue(const QString& subcategory, const QString& parameter, int defaultValue) const
int NCriticalPathParameters::getIntValue(const std::string& category, const std::string& subcategory, const std::string& parameter) const
{
#ifdef STANDALONE_APP
if (QVariant value = m_settings.value(QList<QString>{subcategory, parameter}.join(".")); value.isValid()) {
bool ok;
int candidate = value.toInt(&ok);
if (ok) {
return candidate;
}
int result = 0;

std::string resultStr = getStringValue(category, subcategory, parameter);

try {
result = std::atoi(resultStr.c_str());
} catch(...) {
SimpleLogger::instance().error("cannot convert", resultStr.c_str(), "value for", category.c_str(), subcategory.c_str(), parameter.c_str());
}
#else
assert(false);
#endif
return defaultValue;

return result;
}

QString NCriticalPathParameters::loadStringValue(const QString& subcategory, const QString& parameter, const QString& defaultValue) const
std::string NCriticalPathParameters::getStringValue(const std::string& category, const std::string& subcategory, const std::string& parameter, bool forceReturnDefaultValue) const
{
#ifdef STANDALONE_APP
if (QVariant value = m_settings.value(QList<QString>{subcategory, parameter}.join(".")); value.isValid()) {
return value.toString();
std::string result;

const auto& json_ref = m_json;
auto category_it = json_ref.find(category);
if (category_it != json_ref.end()) {
auto subcategory_it = category_it->find(subcategory);
if (subcategory_it != category_it->end()) {
auto parameter_it = subcategory_it->find(parameter);
if (parameter_it != subcategory_it->end()) {
auto value_it = parameter_it->find(KEY_USER_VALUE);
if ((value_it != parameter_it->end()) && !forceReturnDefaultValue) {
result = value_it->get<std::string>();
} else {
auto defaultValue_it = parameter_it->find(KEY_DEFAULT_VALUE);
if (defaultValue_it != parameter_it->end()) {
result = defaultValue_it->get<std::string>();
}
}
}
}
}
#else
assert(false);
#endif
return defaultValue;

return result;
}

void NCriticalPathParameters::saveToFile()
{
saveIntValue(PATHLIST_SUBCATEGORY, HIGH_LIGHT_MODE_PARAMETER, m_parameters.hightLightMode);
saveStringValue(PATHLIST_SUBCATEGORY, TYPE_PARAMETER, m_parameters.pathType);
saveIntValue(PATHLIST_SUBCATEGORY, DETAIL_LEVEL_PARAMETER, m_parameters.pathDetailLevel);
saveIntValue(PATHLIST_SUBCATEGORY, MAX_NUM_PARAMETER, m_parameters.criticalPathNum);
saveIntValue(PATHLIST_SUBCATEGORY, SAVE_SETTINGS_PARAMETER, m_parameters.savePathListSettings);
#ifdef ENABLE_FILTER_SAVE_SETTINGS_FEATURE
saveIntValue(FILTER_SUBCATEGORY, m_parameters.saveFilterSettings);
#endif
saveToFile(m_json);
}

void NCriticalPathParameters::loadFromFile()
void NCriticalPathParameters::saveToFile(const nlohmann::json& json)
{
m_parameters.hightLightMode = loadIntValue(PATHLIST_SUBCATEGORY, HIGH_LIGHT_MODE_PARAMETER, m_defaultParameters.hightLightMode);
m_parameters.pathType = loadStringValue(PATHLIST_SUBCATEGORY, TYPE_PARAMETER, m_defaultParameters.pathType);
m_parameters.pathDetailLevel = loadIntValue(PATHLIST_SUBCATEGORY, DETAIL_LEVEL_PARAMETER, m_defaultParameters.pathDetailLevel);
m_parameters.criticalPathNum = loadIntValue(PATHLIST_SUBCATEGORY, MAX_NUM_PARAMETER, m_defaultParameters.criticalPathNum);
m_parameters.savePathListSettings = loadIntValue(PATHLIST_SUBCATEGORY, SAVE_SETTINGS_PARAMETER, m_defaultParameters.savePathListSettings);
#ifdef ENABLE_FILTER_SAVE_SETTINGS_FEATURE
m_parameters.saveFilterSettings = loadIntValue(FILTER_SUBCATEGORY, SAVE_SETTINGS_PARAMETER, m_defaultParameters.saveFilterSettings);
#endif
std::ofstream file(filePath());
file << std::setw(4) << json << std::endl;
}

bool NCriticalPathParameters::loadFromFile()
{
return loadFromFile(m_json);
}

bool NCriticalPathParameters::loadFromFile(nlohmann::json& json)
{
try {
if (std::filesystem::exists(filePath())) {
nlohmann::json candidate_json;
std::ifstream file(filePath());
file >> candidate_json;

// if we succesfully read json
json.clear();
std::swap(json, candidate_json);
return true;
} else {
SimpleLogger::instance().error("unable to find", filePath().c_str(), "to load");
return false;
}
} catch(...) {
SimpleLogger::instance().error("unable to load", filePath().c_str());
return false;
}
}

std::string NCriticalPathParameters::filePath() const
{
return "ipa.json";
}
Loading

0 comments on commit af3d5db

Please sign in to comment.