198 lines
7.3 KiB
C++
198 lines
7.3 KiB
C++
#pragma once
|
|
|
|
/**
|
|
* Provides a simple direct 1-level only config file logic
|
|
* by Humans for All
|
|
*
|
|
* This builds on the GroupKV class.
|
|
*
|
|
* ## File format
|
|
*
|
|
* It can consist of multiple config groups.
|
|
* * the group name needs to start at the begining of the line.
|
|
* Each group can inturn contain multiple config fields (key:value pairs) wrt that group.
|
|
* * the group fields need to have 1 or more space at the begining of line.
|
|
*
|
|
* ## Supported data types
|
|
*
|
|
* The fields can have values belonging to ane one of the below types
|
|
* * strings - enclosed in double quotes
|
|
* this is also the fallback catch all type, but dont rely on this behaviour.
|
|
* * int - using decimal number system
|
|
* * float - needs to have a decimal point and or e/E
|
|
* if decimal point is used, there should be atleast one decimal number on its either side
|
|
* * bool - either true or false
|
|
*
|
|
* It tries to provide a crude expanded form of array wrt any of the above supported types.
|
|
* For this one needs to define keys using the pattern TheKeyName-0, TheKeyName-1, ....
|
|
*
|
|
*/
|
|
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <fstream>
|
|
#include <regex>
|
|
#include <variant>
|
|
#include <sstream>
|
|
#include <cuchar>
|
|
|
|
#include "groupkv.hpp"
|
|
#include "datautils_string.hpp"
|
|
|
|
|
|
|
|
class SimpCfg : public GroupKV {
|
|
|
|
private:
|
|
std::regex rInt {R"(^[-+]?\d+$)"};
|
|
std::regex rFloat {R"(^[-+]?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?$)"};
|
|
|
|
public:
|
|
|
|
SimpCfg(GroupKVMapMapVariant defaultMap) : GroupKV(defaultMap) {}
|
|
|
|
|
|
void set_string(const std::string &group, const MultiPart &keyParts, const std::string &value) {
|
|
set_value(group, keyParts, value, __func__);
|
|
}
|
|
|
|
void set_bool(const std::string &group, const MultiPart &keyParts, bool value) {
|
|
set_value(group, keyParts, value, __func__);
|
|
}
|
|
|
|
void set_bool(const std::string &group, const MultiPart &keyParts, const std::string &value) {
|
|
std::string sValue = str_tolower(value);
|
|
bool bValue = sValue == "true" ? true : false;
|
|
//LDBUG_LN("DBUG:%s:%s:%s:%d", __func__, value.c_str(), sValue.c_str(), bValue);
|
|
set_bool(group, keyParts, bValue);
|
|
}
|
|
|
|
void set_int32(const std::string &group, const MultiPart &keyParts, int32_t value) {
|
|
set_value(group, keyParts, value, __func__);
|
|
}
|
|
|
|
void set_int32(const std::string &group, const MultiPart &keyParts, std::string &value) {
|
|
auto ivalue = strtol(value.c_str(), nullptr, 0);
|
|
set_int32(group, keyParts, ivalue);
|
|
}
|
|
|
|
void set_int64(const std::string &group, const MultiPart &keyParts, int64_t value) {
|
|
set_value(group, keyParts, value, __func__);
|
|
}
|
|
|
|
void set_int64(const std::string &group, const MultiPart &keyParts, std::string &value) {
|
|
auto ivalue = strtoll(value.c_str(), nullptr, 0);
|
|
set_int64(group, keyParts, ivalue);
|
|
}
|
|
|
|
void set_double(const std::string &group, const MultiPart &keyParts, double value) {
|
|
set_value(group, keyParts, value, __func__);
|
|
}
|
|
|
|
void set_double(const std::string &group, const MultiPart &keyParts, std::string &value) {
|
|
auto dvalue = strtod(value.c_str(), nullptr);
|
|
set_double(group, keyParts, dvalue);
|
|
}
|
|
|
|
|
|
std::string get_string(const std::string &group, const MultiPart &keyParts, const std::string &defaultValue) {
|
|
return get_value(group, keyParts, defaultValue, __func__);
|
|
}
|
|
|
|
bool get_bool(const std::string &group, const MultiPart &keyParts, bool defaultValue) {
|
|
return get_value(group, keyParts, defaultValue, __func__);
|
|
}
|
|
|
|
int32_t get_int32(const std::string &group, const MultiPart &keyParts, int32_t defaultValue) {
|
|
return get_value(group, keyParts, defaultValue, __func__);
|
|
}
|
|
|
|
int64_t get_int64(const std::string &group, const MultiPart &keyParts, int64_t defaultValue) {
|
|
return get_value(group, keyParts, defaultValue, __func__);
|
|
}
|
|
|
|
double get_double(const std::string &group, const MultiPart &keyParts, double defaultValue) {
|
|
return get_value(group, keyParts, defaultValue, __func__);
|
|
}
|
|
|
|
|
|
static void locale_prepare(std::string &sSavedLocale) {
|
|
sSavedLocale = std::setlocale(LC_ALL, nullptr);
|
|
auto sUpdatedLocale = std::setlocale(LC_ALL, "en_US.UTF-8");
|
|
LDBUG_LN("DBUG:%s:Locale:Prev:%s:Cur:%s", __func__, sSavedLocale.c_str(), sUpdatedLocale);
|
|
}
|
|
|
|
static void locale_restore(const std::string &sSavedLocale) {
|
|
auto sCurLocale = std::setlocale(LC_ALL, sSavedLocale.c_str());
|
|
LDBUG_LN("DBUG:%s:Locale:Requested:%s:Got:%s", __func__, sSavedLocale.c_str(), sCurLocale);
|
|
}
|
|
|
|
void load(const std::string &fname) {
|
|
std::ifstream f {fname};
|
|
if (!f) {
|
|
LERRR_LN("ERRR:SC:%s:%s:failed to load...", __func__, fname.c_str());
|
|
throw std::runtime_error { "ERRR:SimpCfg:File not found" };
|
|
} else {
|
|
LDBUG_LN("DBUG:SC:%s:%s", __func__, fname.c_str());
|
|
}
|
|
std::string group;
|
|
int iLine = 0;
|
|
while(!f.eof()) {
|
|
iLine += 1;
|
|
std::string curL;
|
|
getline(f, curL);
|
|
if (curL.empty()) {
|
|
continue;
|
|
}
|
|
if (curL[0] == '#') {
|
|
continue;
|
|
}
|
|
bool bGroup = !isspace(curL[0]);
|
|
curL = str_trim(curL);
|
|
if (bGroup) {
|
|
curL = str_trim_single(curL, {"\""});
|
|
group = curL;
|
|
LDBUG_LN("DBUG:SC:%s:group:%s", __func__, group.c_str());
|
|
continue;
|
|
}
|
|
auto dPos = curL.find(':');
|
|
if (dPos == std::string::npos) {
|
|
LERRR_LN("ERRR:SC:%s:%d:invalid key value line:%s", __func__, iLine, curL.c_str());
|
|
throw std::runtime_error { "ERRR:SimpCfg:Invalid key value line" };
|
|
}
|
|
auto dEnd = curL.length() - dPos;
|
|
if ((dPos == 0) || (dEnd < 2)) {
|
|
LERRR_LN("ERRR:SC:%s:%d:invalid key value line:%s", __func__, iLine, curL.c_str());
|
|
throw std::runtime_error { "ERRR:SimpCfg:Invalid key value line" };
|
|
}
|
|
std::string key = curL.substr(0, dPos);
|
|
key = str_trim(key);
|
|
key = str_trim_single(key, {"\""});
|
|
std::string value = curL.substr(dPos+1);
|
|
value = str_trim(value);
|
|
value = str_trim(value, {","});
|
|
std::string vtype = "bool";
|
|
auto valueLower = str_tolower(value);
|
|
if ((valueLower.compare("true") == 0) || (valueLower == "false")) {
|
|
set_bool(group, {key}, value);
|
|
} else if (std::regex_match(value, rInt)) {
|
|
vtype = "int";
|
|
set_int64(group, {key}, value);
|
|
} else if (std::regex_match(value, rFloat)) {
|
|
vtype = "float";
|
|
set_double(group, {key}, value);
|
|
} else {
|
|
vtype = "string";
|
|
if (!value.empty() && (value.front() != '"')) {
|
|
LWARN_LN("WARN:SC:%s:%d:%s:k:%s:v:%s:is this string?", __func__, iLine, group.c_str(), key.c_str(), value.c_str());
|
|
}
|
|
value = str_trim_single(value, {"\""});
|
|
set_string(group, {key}, value);
|
|
}
|
|
//LDBUG_LN("DBUG:SC:%s:%d:kv:%s:%s:%s:%s", __func__, iLine, group.c_str(), key.c_str(), vtype.c_str(), value.c_str());
|
|
}
|
|
}
|
|
|
|
};
|