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 <optional>
#include <utility>
#include <vector>

class GOptions
{
public:
    GOptions() {
    };

    explicit GOptions(std::string 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 getRequiredScalarInt(const std::string& tag) const;
    [[nodiscard]] std::optional<int> getOptionalScalarInt(const std::string& tag) const;
 

    [[nodiscard]] double getRequiredScalarDouble(const std::string& tag) const;
    [[nodiscard]] std::optional<double> getOptionalScalarDouble(const std::string& tag) const;

    [[nodiscard]] std::string getRequiredScalarString(const std::string& tag) const;

    [[nodiscard]] std::optional<std::string> getOptionalScalarString(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(goptions::EC__NOOPTIONFOUND);
        }
        const auto& option_value = getOptionIterator(tag)->value;
        if (!option_value || option_value.size() == 0) { return YAML::Node{}; }
        return option_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::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);

    template <typename T>
    T get_required_variable_in_option(const YAML::Node& node, const std::string& variable_name);

    template <typename T>
    std::optional<T> get_optional_variable_in_option(const YAML::Node& node, const std::string& variable_name);

    [[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);