goption.h

Go to the documentation of this file.

 
#pragma once
 
// goption
#include "goptionsConventions.h"
 
// c++
#include <map>
#include <fstream>
#include <optional>
#include <vector>
#include <string>
#include <algorithm>
 
// yaml-cpp
#include "yaml-cpp/yaml.h"
 

struct GVariable
{
    std::string name; 
    YAML::Node  defaultValue; 
    bool        required{}; 
    std::string description; 

    GVariable(std::string n, std::string val, std::string d)
        : name(std::move(n)), defaultValue(std::move(val)), description(std::move(d)) {
    }

    GVariable(std::string n, double val, std::string d)
        : name(std::move(n)), defaultValue(val), description(std::move(d)) {
    }

    GVariable(std::string n, const char* val, std::string d)
        : name(std::move(n)), defaultValue(val), description(std::move(d)) {
    }

    GVariable(std::string n, int val, std::string d)
        : name(std::move(n)), defaultValue(val), description(std::move(d)) {
    }

    GVariable(std::string n, bool val, std::string d)
        : name(std::move(n)), defaultValue(val), description(std::move(d)) {
    }

    GVariable(std::string n, std::nullopt_t, std::string d)
        : name(std::move(n)), defaultValue(YAML::NodeType::Null), description(std::move(d)) {
    }

    GVariable(std::string n, goptions::RequiredValue, std::string d)
        : name(std::move(n)), defaultValue(YAML::NodeType::Null), required(true), description(std::move(d)) {
    }
};

class GOption
{
public:
    GOption(GVariable dv, std::string h) : name(dv.name), description(dv.description), help(h) {
        defaultValue[name] = dv.defaultValue;
        value        = defaultValue;
    }

    GOption(std::string n, std::string desc, std::vector<GVariable> dv, std::string h)
        : name(n), description(desc), help(h) {
        YAML::Node nodes;
        for (const auto& v : dv) {
            YAML::Node this_node;
            this_node[v.name] = v.defaultValue;
            nodes.push_back(this_node);
            gvar_descs.push_back(v.description);
            gvar_required.push_back(v.required);
            if (v.required) {
                isCumulative = true;
                mandatory_keys.push_back(v.name);
            }
        }
        defaultValue[n] = nodes;
        if (!isCumulative) { value = defaultValue; }
    }

    void set_sub_option_value(const std::string& subkey, const std::string& subvalue);
 
private:
    bool              isCumulative = false; 
    const std::string name;                 
    const std::string description;          
    const std::string help;                 
 
    YAML::Node               value;          
    YAML::Node               defaultValue;   
    std::vector<std::string> gvar_descs;     
    std::vector<bool>        gvar_required;  
    std::vector<std::string> mandatory_keys; 

    void saveOption(std::ofstream* yamlConf) const;

    void printHelp(bool detailed) const;

    std::string detailedHelp() const;

    void set_scalar_value(const std::string& v);

    void set_value(const YAML::Node& v);

    bool does_the_option_set_all_necessary_values(const YAML::Node& v);
 
    friend class GOptions; 
};