goptions.h

Go to the documentation of this file.

 
#pragma once
 
#include "goption.h"
#include "gswitch.h"
 
// gemc
#include <gemc/guts/gutsConventions.h>
 
 
// c++
#include <string>
#include <fstream>
#include <iostream>
#include <map>
#include <utility>
#include <vector>
 
class GOptions
{
public:
    GOptions() {
    };
 
    explicit GOptions(std::string name) : option_verbosity_name(name) { addOptionTitle(std::move(name)); }
 
    GOptions(int argc, char* argv[], const GOptions& user_defined_options = GOptions());
 
 
    ~GOptions() {
        if (yamlConf != nullptr) {
            if (yamlConf->is_open()) { yamlConf->close(); }
            delete yamlConf;
            yamlConf = nullptr;
        }
    }
 
    void defineSwitch(const std::string& name, const std::string& description, bool default_status = false);
 
    void defineOption(const GVariable& gvar, const std::string& help);
 
    void defineOption(const std::string& name, const std::string& description, const std::vector<GVariable>& gvars,
                      const std::string& help);
 
    [[nodiscard]] int getScalarInt(const std::string& tag) const;
 
 
    [[nodiscard]] double getScalarDouble(const std::string& tag) const;
 
    [[nodiscard]] std::string getScalarString(const std::string& tag) const;
 
    [[nodiscard]] bool getSwitch(const std::string& tag) const;
 
    [[nodiscard]] inline YAML::Node getOptionNode(const std::string& tag) const {
        if (!doesOptionExist(tag)) {
            std::cerr << "Option " << tag << " does not exist. Exiting." << std::endl;
            exit(EC__NOOPTIONFOUND);
        }
        return getOptionIterator(tag)->value.begin()->second;
    }
 
    [[nodiscard]] YAML::Node getOptionMapInNode(const std::string& option_name, const std::string& map_key) const;
 
    void setOptionValueFromString(const std::string& optionName, const std::string& possibleYamlNode);
 
    [[nodiscard]] int getVerbosityFor(const std::string& tag) const;
 
    [[nodiscard]] int getDebugFor(const std::string& tag) const;
 
    [[nodiscard]] const std::vector<GOption>& getOptions() const { return goptions; }
 
    [[nodiscard]] const std::map<std::string, GSwitch>& getSwitches() const { return switches; }
 
    inline void addGOptions(const GOptions& src) {
        // 1.  Options – check by option name
        for (const auto& opt : src.getOptions()) {
            auto already = std::find_if(
                goptions.begin(), goptions.end(),
                [&opt](const GOption& o) { return o.name == opt.name; });
 
            if (already == goptions.end())
                goptions.push_back(opt); // add only if absent
        }
 
        // 2.  Switches – std::map::insert does the uniqueness check for us
        for (const auto& sw : src.getSwitches()) {
            switches.insert(sw); // ignored if key already exists
        }
 
        // 3.  Verbosity/debug variable names – store each only once
        for (const auto& v : src.option_verbosity_names) {
            auto same = std::find_if(
                option_verbosity_names.begin(), option_verbosity_names.end(),
                [&v](const GVariable& existing) { return existing.name == v.name; });
 
            if (same == option_verbosity_names.end())
                option_verbosity_names.push_back(v);
        }
    }
 
    std::string option_verbosity_name{UNINITIALIZEDSTRINGQUANTITY};
 
    std::vector<GVariable> option_verbosity_names;
 
    inline void addOptionTitle(const std::string& name) {
        std::string option_verbosity_name_desc = name + " verbosity level or debug switch";
        option_verbosity_names.emplace_back(name, 0, option_verbosity_name_desc);
    }
 
    template <typename T>
    T get_variable_in_option(const YAML::Node& node, const std::string& variable_name, const T& default_value);
 
    [[nodiscard]] std::vector<std::string> getYamlFiles() const { return yaml_files; }
 
    [[nodiscard]] bool doesOptionExist(const std::string& tag) const;
 
private:
    std::vector<GOption> goptions; 
    std::map<std::string, GSwitch> switches; 
    std::ofstream* yamlConf{}; 
    std::string executableName; 
    std::string executableCallingDir;
    std::string              installDir; 
    std::vector<std::string> yaml_files; 
 
    std::vector<std::string> findYamls(int argc, char* argv[]);
    void setOptionsValuesFromYamlFile(const std::string& yaml);
    void setOptionValuesFromCommandLineArgument(const std::string& optionName, const std::string& possibleYamlNode);
    std::vector<GOption>::iterator getOptionIterator(const std::string& name);
    [[nodiscard]] std::vector<GOption>::const_iterator getOptionIterator(const std::string& name) const;
    void printOptionOrSwitchHelp(const std::string& tag) const;
    void printSearch(const std::string& tag) const;
    void printHelp() const;
    void printWebHelp() const;
    void saveOptions() const;
    void print_version();
};
 
GOptions& operator+=(GOptions& original, const GOptions& optionsToAdd);