cmdline.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_SYSTEM_CMDLINE_HPP__
#define NEFORCE_CORE_SYSTEM_CMDLINE_HPP__

 
#include "NeForce/core/container/unordered_map.hpp"
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/string/string.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct cmdline_exception final : value_exception {
    explicit cmdline_exception(const char* info = "CmdLine Operation Failed.") noexcept :
    value_exception(info) {}
 
    explicit cmdline_exception(const exception& e) :
    value_exception(e) {}
 
    ~cmdline_exception() override = default;
 
    NEFORCE_NODISCARD const char* type() const noexcept override { return "cmdline_exception"; }
};
 // Exceptions


class NEFORCE_API cmdline {
public:
    struct NEFORCE_API option {
        string long_name;            
        char short_name = 0;         
        string description;          
        bool requires_value = false; 
        bool allow_multiple = false; 
        string default_value;        
 
        vector<string> values; 
 
        option() = default;

        option(string lname, char sname, string desc, bool req_val, bool allow_multi, string def_val);
    };

    enum class conflict_behavior {
        error,   
        warning, 
        ignore   
    };

    struct option_dependency {
        string present;  
        string required; 
    };

    struct option_conflict {
        string option_a; 
        string option_b; 
    };

    using validator = function<string(const string& name, const string& value)>;
 
private:
    string program_name_;                        
    vector<option> options_;                     
    unordered_map<string, size_t> options_long_; 
    unordered_map<char, size_t> options_short_;  
    vector<string> positional_;                  
 
    vector<option_dependency> dependencies_;                        
    vector<option_conflict> conflicts_;                             
    conflict_behavior conflict_behavior_{conflict_behavior::error}; 
    vector<validator> validators_;                                  

    option* find_option_long(const string& name);

    option* find_option_short(char name);

    void parse_long_option(const string& arg, const vector<string>& args, size_t& index);

    void parse_short_options(const string& arg, const vector<string>& args, size_t& index);

    void validate_values();

    void validate_constraints();
 
public:
    void add_option(const string& long_name, char short_name, const string& description, bool requires_value = false,
                    bool allow_multiple = false, const string& default_value = "");

    void parse_os_args();

    void parse(int argc, const char* argv[]);

    void parse(const vector<string>& args);

    NEFORCE_NODISCARD string get(const string& long_name, size_t index = 0) const;

    NEFORCE_NODISCARD bool has(const string& name) const;

    NEFORCE_NODISCARD size_t count(const string& name) const;

    NEFORCE_NODISCARD const vector<string>& positional_args() const noexcept { return positional_; }

    NEFORCE_NODISCARD const string& program_name() const noexcept { return program_name_; }

    void print_help() const;

    NEFORCE_NODISCARD static vector<string> get_os_argv();

    void add_dependency(const string& present, const string& required);

    void add_conflict(const string& option_a, const string& option_b);

    void set_conflict_behavior(conflict_behavior behavior) noexcept { conflict_behavior_ = behavior; }

    void load_config(const string& config_path, const string& section = "");

    void add_validator(validator v);

    void add_range_validator(string long_name, int64_t min_val, int64_t max_val);

    void add_regex_validator(string long_name, const string& pattern);
};
 // CommandLine
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_SYSTEM_CMDLINE_HPP__