goptions.h

Go to the documentation of this file.

#ifndef GOPTIONS_H
#define GOPTIONS_H 1
 
#include "goption.h"
#include "gswitch.h"
 
// c++
#include <string>
#include <fstream>
#include <iostream>
#include <map>
#include <vector>
 
class GOptions {
public:
    GOptions() { return; }
 
    GOptions(string name) : option_verbosity_name(name) { addOptionTitle(name); }
 
    GOptions(int argc, char *argv[], const GOptions &user_defined_options = GOptions());
 
    void defineSwitch(const string &name, const string &description);
 
    void defineOption(const GVariable &gvar, const string &help);
 
    void defineOption(const string &name, const string &description, const std::vector<GVariable> &gvars,
                      const string &help);
 
    int getScalarInt(const string &tag) const;
 
    float getScalarFloat(const string &tag) const;
 
    double getScalarDouble(const string &tag) const;
 
    string getScalarString(const string &tag) const;
 
    bool getSwitch(const string &tag) const;
 
    inline const YAML::Node getOptionNode(const 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;
    }
 
    YAML::Node getOptionMapInNode(string option_name, string map_key) const;
 
    int getVerbosityFor(const string &tag) const;
 
    int getDebugFor(const string &tag) const;
 
    const std::vector<GOption> &getOptions() const { return goptions; }
 
    const std::map<string, GSwitch> &getSwitches() const { return switches; }
 
    inline void addGOptions(const GOptions &goptions_to_add) {
        for (auto gopt : goptions_to_add.getOptions()) {
            goptions.push_back(gopt);
        }
        for (auto sw : goptions_to_add.getSwitches()) {
            switches.insert(sw);
        }
        for(auto &gvar : goptions_to_add.option_verbosity_names) {
            option_verbosity_names.push_back(gvar);
        }
    }
 
    string option_verbosity_name = UNINITIALIZEDSTRINGQUANTITY;
    vector <GVariable> option_verbosity_names;
    inline void addOptionTitle(string name) {
        string option_verbosity_name_desc = name + " verbosity level or debug switch";
        option_verbosity_names.push_back( GVariable(name, 0, option_verbosity_name_desc) ) ;
    }
 
    template<typename T>
    T get_variable_in_option(const YAML::Node &node, const string &variable_name, const T &default_value);
 
    std::vector<string> getYamlFiles() const { return yaml_files; }
 
    bool doesOptionExist(const string &tag) const;
 
private:
    std::vector<GOption> goptions;           
    std::map<string, GSwitch> switches;   
    std::ofstream *yamlConf;                 
    string executableName;              
    std::vector<string> yaml_files;     
 
    vector<string> findYamls(int argc, char *argv[]);
 
    void setOptionsValuesFromYamlFile(const string &yaml);
 
    void setOptionValuesFromCommandLineArgument(const string &optionName, const string &possibleYamlNode);
 
    std::vector<GOption>::iterator getOptionIterator(const string &name);
 
    std::vector<GOption>::const_iterator getOptionIterator(const string &name) const;
 
    void printOptionOrSwitchHelp(const string &tag) const;
 
    void printHelp() const;
 
    void printWebHelp() const;
 
    void saveOptions() const;
 
    void print_version();
};
 
GOptions &operator+=(GOptions &original, const GOptions &optionsToAdd);
 
#endif