Options.h

Go to the documentation of this file.

#ifndef DARWIN_OPTIONS_H
#define DARWIN_OPTIONS_H
 
#include <functional>
#include <vector>
#include <filesystem>
#include <iostream>
#include <optional>
 
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/positional_options.hpp>
#include <boost/property_tree/ptree.hpp>
 
#ifndef DARWIN_GIT_COMMIT
#  define DARWIN_GIT_COMMIT nullptr
#endif
 
#ifndef DARWIN_EXAMPLE
#  define DARWIN_EXAMPLE nullptr
#endif
 
namespace Darwin::Tools {
 
enum {
    none    = 0b000000, 
    config  = 0b000001, 
    split   = 0b000010, 
    fill    = 0b000100, 
    Friend  = 0b001100, 
    syst    = 0b010000, 
    verbose = 0b100000  
}; 
 
class Options {
 
    // internal parsing
    boost::program_options::options_description hidden, 
                                                helper, 
                                                common, 
                                                custom; 
    boost::program_options::positional_options_description pos_hide; 
    boost::property_tree::ptree pt_conf; 
 
    const std::filesystem::path example; 
 
    void parse_helper (int, const char * const []);
 
    void parse_common (int, const char * const []);
 
    void parse_custom (int, const char * const []);
 
    std::filesystem::path config_file; 
 
    // for helper
    const std::string tutorial; 
    std::string synopsis; 
    std::vector<std::string> names, 
                             configpaths; 
 
    static void check_input (const std::filesystem::path& 
                            );
 
    static void check_output (const std::filesystem::path& 
                             );
 
    Options& set (const char *, 
            const boost::program_options::value_semantic *, 
            const char * 
            );
 
    template<typename T 
        > std::function<void(T)> put (const char * configpath 
                                     )
    {
        return [configpath,this](T value) { pt_conf.put<T>(configpath, value); };
    }
 
    std::optional<unsigned> registered; 
 
    inline bool allow_unregistered () const { return bool(registered); }
 
    std::string exec (const std::string& 
                );
 
    enum Stage {
        Input, 
        Output, 
        Arg, 
        Args 
    }; 
 
    Stage stage; 
 
    const int params; 
    const std::string m_commit; 
    int steer; 
    static std::filesystem::path prefix; 
    unsigned j, 
             k; 
 
public:
 
    Options (const std::string&, 
             int = none, 
             const char* commit = DARWIN_GIT_COMMIT, 
             const char* example = DARWIN_EXAMPLE 
             );
 
    Options () = delete;
 
    Options& input  (const char *, 
                    std::filesystem::path *, 
                    const char * 
                    );
 
    Options& inputs (const char *, 
                    std::vector<std::filesystem::path> *, 
                    const char * 
                    );
 
    Options& output (const char *, 
                    std::filesystem::path *, 
                    const char * 
                    );
 
    template<typename T> Options& arg (const char * name, 
                                       const char * configpath, 
                                       const char * desc 
            )
    {
        if (stage > Stage::Arg)
            BOOST_THROW_EXCEPTION(std::runtime_error("Not possible to add another argument at this stage"));
        stage = Stage::Arg;
 
        names.push_back(name);
        configpaths.push_back(configpath);
        const boost::program_options::value_semantic * s =
            boost::program_options::value<T>()->notifier(put<T>(configpath));
        return set(name, s, desc);
    }
 
    Options& args (const char * name, 
                   const char * configpath, 
                   const char * desc 
                   );
 
    const boost::property_tree::ptree& operator() (int, const char * const []);
 
    static std::string parse_env_var (std::string);
 
    static inline const char * parse_env_var (const char * p)
    { return parse_env_var(std::string(p)).c_str(); }
 
    static inline std::filesystem::path parse_env_var (const std::filesystem::path& p)
    { return std::filesystem::path(parse_env_var(p.string())); }
 
    static void parse_config (boost::property_tree::ptree&, 
                                std::string = "" 
                                );
 
    // result of parsing
    static std::string full_cmd; 
 
    auto commit () const { return m_commit; }
 
    inline int steering () const { return steer; }
 
    inline std::pair<unsigned, unsigned> slice () const
    {
        if (!(params & split))
            BOOST_THROW_EXCEPTION(std::invalid_argument("No splitting of the input file."));
        return std::make_pair(j,k);
    }
};
 
} // end of namespace
 
#endif