7 #include "gutilities.h"
31 executableName = gutilities::getFileFromPath(argv[0]);
32 executableCallingDir = gutilities::getDirFromPath(argv[0]);
36 addGOptions(user_defined_options);
39 defineSwitch(
"gui",
"use Graphical User Interface");
40 defineSwitch(
"i",
"use interactive batch mode");
42 GVariable(
"conf_yaml",
"saved_configuration",
"the prefix for filename that store the used options"),
43 "The default value appends \"_saved_configuration\" to the executable name.");
46 defineOption(
GVariable(
"tt", 500,
"tests timeout (ms)"),
47 "Timeout in milliseconds for the code tests that have GUI. ");
53 {
"release", gversion,
"release version number"},
54 {
"release_date", grelease_date,
"release date"},
55 {
"Reference", greference,
"article reference"},
56 {
"Homepage", gweb,
"homepage"},
57 {
"Author", gauthor,
"author"}
59 defineOption(
GVERSION_STRING,
"version information",
version,
"Version information. Not settable by user.");
61 string help =
"Levels: \n \n";
62 help +=
" - 0: (default) shush\n";
63 help +=
" - 1: normal information\n";
64 help +=
" - 2: detailed information\n \n";
65 help +=
"Example: -verbosity.general=1 \n \n";
66 help +=
"This option can be repeated.\n \n";
67 defineOption(
"verbosity",
"Sets the log verbosity for various classes", option_verbosity_names, help);
70 help =
"Debug information Types: \n \n";
71 help +=
" - false: (default): do not print debug information\n";
72 help +=
" - true: print debug information\n\n";
73 help +=
"Example: -debug.general=true \n \n";
74 help +=
"This option can be repeated.\n \n";
75 defineOption(
"debug",
"Sets the debug level for various classes", option_verbosity_names, help);
78 for (
int i = 1; i < argc; i++) {
79 if (strcmp(argv[i],
"-h") == 0 || strcmp(argv[i],
"--h") == 0 ||
80 strcmp(argv[i],
"-help") == 0 || strcmp(argv[i],
"--help") == 0) {
82 }
else if (strcmp(argv[i],
"-hweb") == 0) {
84 }
else if (strcmp(argv[i],
"-v") == 0 || strcmp(argv[i],
"--v") == 0 ||
85 strcmp(argv[i],
"-version") == 0 || strcmp(argv[i],
"--version") == 0) {
88 }
else if (strcmp(argv[i],
"help") == 0) {
89 printOptionOrSwitchHelp(argv[i + 1]);
95 yaml_files = findYamls(argc, argv);
96 for (
auto &yaml_file: yaml_files) {
97 cout <<
" Parsing " << yaml_file << endl;
98 setOptionsValuesFromYamlFile(yaml_file);
102 for (
int i = 1; i < argc; i++) {
103 string candidate = argv[i];
104 if (candidate.empty())
continue;
105 if (find(yaml_files.begin(), yaml_files.end(), candidate) != yaml_files.end())
continue;
106 if (candidate[0] ==
'-') {
107 string argStr = candidate.substr(1);
108 size_t eqPos = argStr.find(
'=');
109 if (eqPos != string::npos) {
110 string keyPart = argStr.substr(0, eqPos);
111 string valuePart = argStr.substr(eqPos + 1);
112 size_t dotPos = keyPart.find(
'.');
113 if (dotPos != string::npos) {
115 string mainOption = keyPart.substr(0, dotPos);
116 string subOption = keyPart.substr(dotPos + 1);
117 if (doesOptionExist(mainOption)) {
118 auto it = getOptionIterator(mainOption);
119 it->set_sub_option_value(subOption, valuePart);
121 cerr <<
"The option " << mainOption <<
" is not known to this system." << endl;
126 if (doesOptionExist(keyPart)) {
127 setOptionValuesFromCommandLineArgument(keyPart, valuePart);
129 cerr <<
"The option " << keyPart <<
" is not known to this system." << endl;
135 const string& possibleSwitch = argStr;
136 if (switches.find(possibleSwitch) != switches.end()) {
137 switches[possibleSwitch].turnOn();
139 cerr <<
"The switch " << possibleSwitch <<
" is not known to this system." << endl;
144 cerr <<
"The command-line argument \"" << candidate <<
"\" is not valid." << endl;
153 string yamlConf_filename = executableName +
"." + getScalarString(
"conf_yaml") +
".yaml";
154 cout <<
" Saving options to " << yamlConf_filename << endl << endl;
155 yamlConf =
new std::ofstream(yamlConf_filename);
166 if (switches.find(name) == switches.end()) {
167 switches[name] =
GSwitch(description);
169 std::cerr << FATALERRORL <<
"The " << YELLOWHHL << name << RSTHHR
170 <<
" switch is already present." << std::endl;
182 if (doesOptionExist(gvar.
name)) {
183 std::cerr << FATALERRORL <<
"The " << YELLOWHHL << gvar.
name << RSTHHR
184 <<
" option is already present." << std::endl;
199 void GOptions::defineOption(
const std::string &name,
const std::string &description,
const std::vector <GVariable> &g_vars,
200 const std::string &help) {
201 if (doesOptionExist(name)) {
202 std::cerr << FATALERRORL <<
"The " << YELLOWHHL << name << RSTHHR
203 <<
" option is already present." << std::endl;
206 goptions.emplace_back(name, description, g_vars, help);
217 auto it = getOptionIterator(tag);
219 cerr << FATALERRORL <<
"The option " << YELLOWHHL << tag << RSTHHR
220 <<
" was not found." << endl;
223 return it->value.begin()->second.as<
int>();
233 auto it = getOptionIterator(tag);
235 cerr << FATALERRORL <<
"The option " << YELLOWHHL << tag << RSTHHR
236 <<
" was not found." << endl;
239 return it->value.begin()->second.as<
double>();
249 auto it = getOptionIterator(tag);
251 cerr << FATALERRORL <<
"The option " << YELLOWHHL << tag << RSTHHR
252 <<
" was not found." << endl;
255 return it->value.begin()->second.as<
string>();
263 void GOptions::printOptionOrSwitchHelp(
const std::string &tag)
const {
264 auto switchIt = switches.find(tag);
265 if (switchIt != switches.end()) {
266 cout << KGRN <<
"-" << tag << RST <<
": " << switchIt->second.getDescription() << endl << endl;
267 cout << TPOINTITEM <<
"Default value is " << (switchIt->second.getStatus() ?
"on" :
"off") << endl << endl;
270 for (
const auto &goption:
goptions) {
271 if (goption.name == tag) {
272 goption.printHelp(
true);
276 cerr << FATALERRORL <<
"The " << YELLOWHHL << tag << RSTHHR
277 <<
" option is not known to this system." << endl;
288 vector <string> GOptions::findYamls(
int argc,
char *argv[]) {
289 vector <string> yaml_files;
290 for (
int i = 1; i < argc; i++) {
291 string arg = argv[i];
292 size_t pos = arg.find(
".yaml");
293 if (pos != string::npos) yaml_files.push_back(arg);
294 pos = arg.find(
".yml");
295 if (pos != string::npos) yaml_files.push_back(arg);
305 [&tag](
const auto& option) {
306 return option.name == tag;
315 void GOptions::setOptionsValuesFromYamlFile(
const std::string &yaml) {
318 config = YAML::LoadFile(yaml);
319 }
catch (YAML::ParserException &e) {
320 cerr << FATALERRORL <<
"Error parsing " << YELLOWHHL << yaml << RSTHHR
321 <<
" yaml file." << endl;
322 cerr << e.what() << endl;
323 cerr <<
"Try validating the yaml file with an online yaml validator, e.g., https://www.yamllint.com" << endl;
327 for (
auto it = config.begin(); it != config.end(); ++it) {
328 auto option_name = it->first.as<std::string>();
329 auto option_it = getOptionIterator(option_name);
331 if (switches.find(option_name) == switches.end()) {
332 cerr << FATALERRORL <<
"The option or switch " << YELLOWHHL << option_name << RSTHHR
333 <<
" is not known to this system." << endl;
336 switches[option_name].turnOn();
339 YAML::NodeType::value type = it->second.Type();
341 case YAML::NodeType::Scalar:
342 option_it->set_scalar_value(it->second.as<std::string>());
344 case YAML::NodeType::Sequence:
345 option_it->set_value(it->second);
347 case YAML::NodeType::Map:
348 option_it->set_value(it->second);
363 void GOptions::setOptionValuesFromCommandLineArgument(
const std::string &optionName,
const std::string &possibleYamlNode) {
364 YAML::Node node = YAML::Load(possibleYamlNode);
365 auto option_it = getOptionIterator(optionName);
366 if (node.Type() == YAML::NodeType::Scalar) {
367 option_it->set_scalar_value(possibleYamlNode);
369 option_it->set_value(node);
379 std::vector<GOption>::iterator GOptions::getOptionIterator(
const std::string &name) {
381 [&name](
GOption &option) { return option.name == name; });
391 std::vector<GOption>::const_iterator GOptions::getOptionIterator(
const std::string &name)
const {
393 [&name](
const GOption &option) { return option.name == name; });
403 auto it = switches.find(tag);
404 if (it != switches.end()) {
405 return it->second.getStatus();
407 std::cerr << FATALERRORL <<
"The switch " << YELLOWHHL << tag << RSTHHR
408 <<
" was not found." << std::endl;
421 auto sequence_node = getOptionNode(option_name);
422 for (
auto seq_item : sequence_node) {
423 for (
auto map_item = seq_item.begin(); map_item != seq_item.end(); ++map_item) {
424 if (map_item->first.as<
string>() == map_key) {
425 return map_item->second;
429 cerr << FATALERRORL <<
"The key " << YELLOWHHL << map_key << RSTHHR
430 <<
" was not found in " << YELLOWHHL << option_name << RSTHHR << endl;
445 if (node[variable_name]) {
446 return node[variable_name].as<T>();
448 return default_value;
452 template int GOptions::get_variable_in_option<int>(
const YAML::Node &node,
const std::string &variable_name,
const int &default_value);
453 template double GOptions::get_variable_in_option<double>(
const YAML::Node &node,
const std::string &variable_name,
const double &default_value);
454 template string GOptions::get_variable_in_option<string>(
const YAML::Node &node,
const std::string &variable_name,
const string &default_value);
455 template bool GOptions::get_variable_in_option<bool>(
const YAML::Node &node,
const std::string &variable_name,
const bool &default_value);
464 YAML::Node verbosity_node = getOptionNode(
"verbosity");
465 for (
auto v : verbosity_node) {
466 if (v.begin()->first.as<
string>() == tag) {
467 return v.begin()->second.as<
int>();
472 std::cerr << KRED <<
" Invalid verbosity or debug requested: " << tag << RST << std::endl;
485 YAML::Node debug_node = getOptionNode(
"debug");
486 for (
auto d : debug_node) {
487 if (d.begin()->first.as<
string>() == tag) {
488 YAML::Node valNode = d.begin()->second;
489 if (valNode.IsScalar()) {
490 auto s = valNode.as<
string>();
491 if (s ==
"true")
return 1;
492 if (s ==
"false")
return 0;
495 return valNode.as<
int>();
496 }
catch (
const YAML::BadConversion &) {
497 std::cerr <<
"Invalid debug value for " << tag << std::endl;
503 std::cerr << KRED <<
" Invalid verbosity or debug requested: " << tag << RST << std::endl;
509 void GOptions::printHelp()
const {
512 cout << KGRN << KBOLD <<
" " << executableName << RST <<
" [options] [yaml files]" << endl << endl;
513 cout <<
" Switches: " << endl << endl;
514 for (
auto &s : switches) {
515 string help =
"-" + s.first + RST +
" ";
516 cout << KGRN <<
" " << left;
517 cout.width(fill_width);
519 cout <<
": " << s.second.getDescription() << endl;
522 cout <<
" Options: " << endl << endl;
524 option.printHelp(
false);
527 cout << endl <<
" Help / Search / Introspection: " << endl << endl;
528 vector<string> helps = {
529 string(
"-h, --h, -help, --help") + RST,
530 string(
"print this help and exit"),
531 string(
"-hweb") + RST,
532 string(
"print this help in web format and exit"),
533 string(
"-v, --v, -version, --version") + RST,
534 string(
"print the version and exit\n"),
535 string(
"help <value>") + RST,
536 string(
"print detailed help for option <value> and exit"),
537 string(
"search <value>") + RST,
538 string(
"list all options containing <value> in the description and exit\n")
540 unsigned half_help = helps.size() / 2;
541 for (
unsigned i = 0; i < half_help; i++) {
542 cout << KGRN <<
" " << left;
543 cout.width(fill_width);
544 cout << helps[i * 2] <<
": " << helps[i * 2 + 1] << endl;
547 cout <<
" Note: command line options overwrite YAML file(s)." << endl << endl;
556 void GOptions::printWebHelp()
const {
563 void GOptions::saveOptions()
const {
564 for (
auto &s : switches) {
565 string status = s.second.getStatus() ?
"true" :
"false";
566 *yamlConf << s.first +
": " + status <<
"," << endl;
568 for (
const auto &option :
goptions) {
569 option.saveOption(yamlConf);
577 void GOptions::print_version() {
578 string asterisks =
"**************************************************************";
579 cout << endl << asterisks << endl;
580 cout <<
" " << KGRN << KBOLD << executableName << RST <<
" version: " << KGRN << gversion << RST;
581 cout <<
", executed from: " << KGRN << executableCallingDir << RST << endl;
582 cout <<
" Released on: " << KGRN << grelease_date << RST << endl;
583 cout <<
" GEMC Reference: " << KGRN << greference << RST << endl;
584 cout <<
" GEMC Homepage: " << KGRN << gweb << RST << endl;
585 cout <<
" Author: " << KGRN << gauthor << RST << endl << endl;
586 cout << asterisks << endl << endl;
Represents a configurable option with a name, value(s), description, and help text.
The GOptions class manages command-line options and switches.
std::string getScalarString(const std::string &tag) const
Retrieves the value of a scalar string option.
bool getSwitch(const std::string &tag) const
Retrieves the status of a switch.
void defineSwitch(const std::string &name, const std::string &description)
Defines and adds a command–line switch.
GOptions()
Default constructor.
void defineOption(const GVariable &gvar, const std::string &help)
Defines and adds a scalar option.
YAML::Node getOptionMapInNode(const std::string &option_name, const std::string &map_key) const
Retrieves a map option’s value from within a YAML node.
T get_variable_in_option(const YAML::Node &node, const std::string &variable_name, const T &default_value)
Retrieves a variable from a YAML node within an option.
double getScalarDouble(const std::string &tag) const
Retrieves the value of a scalar double option.
void addGOptions(const GOptions &goptions_to_add)
Adds options from another GOptions object.
bool doesOptionExist(const std::string &tag) const
Checks if the specified option exists.
int getScalarInt(const std::string &tag) const
Retrieves the value of a scalar integer option.
int getDebugFor(const std::string &tag) const
Retrieves the debug level for the specified tag.
int getVerbosityFor(const std::string &tag) const
Retrieves the verbosity level for the specified tag.
Represents a switch with a description and a status.
#define EC__BAD_CONVERSION
#define EC__NOOPTIONFOUND
#define EC__YAML_PARSING_ERROR
#define EC__DEFINED_SWITCHALREADYPRESENT
#define EC__DEFINED_OPTION_ALREADY_PRESENT
GOptions & operator+=(GOptions &gopts, const GOptions &goptions_to_add)
Overloaded operator to add options and switches from one GOptions object to another.
Encapsulates a variable with a name, value, and description.
std::string name
The name of the variable.