cmdlineparser.h

Go to the documentation of this file.

 
#pragma once
 
#include <variant>
#include <promeki/core/namespace.h>
#include <promeki/core/stringlist.h>
#include <promeki/core/string.h>
#include <promeki/core/list.h>
#include <promeki/core/map.h>
#include <promeki/core/logger.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class CmdLineParser {
        public:
                using OptionCallback = std::function<int()>;
 
                using OptionBoolCallback = std::function<int(bool)>;
 
                using OptionStringCallback = std::function<int(const String &)>;
 
                using OptionIntCallback = std::function<int(int)>;
 
                using OptionDoubleCallback = std::function<int(double)>;
 
                using OptionCallbackVariant = std::variant<
                        OptionCallback,
                        OptionBoolCallback,
                        OptionStringCallback,
                        OptionIntCallback,
                        OptionDoubleCallback>;
 
                class Option {
                        public:
                                enum ArgType {
                                        ArgNone,        
                                        ArgBool,        
                                        ArgString,      
                                        ArgInt,         
                                        ArgDouble,      
                                        ArgUnknown      
                                };
 
                                char                    shortName = 0;  
                                String                  longName;       
                                String                  desc;           
                                OptionCallbackVariant   callback;       
 
                                Option() = default;
 
                                Option(char sn, const String &ln, const String &d, OptionCallbackVariant cb) :
                                        shortName(sn), longName(ln), desc(d), callback(cb) {}
 
                                ArgType argType() const {
                                        if(std::holds_alternative<OptionCallback>(callback)) return ArgNone;
                                        if(std::holds_alternative<OptionBoolCallback>(callback)) return ArgBool;
                                        if(std::holds_alternative<OptionIntCallback>(callback)) return ArgInt;
                                        if(std::holds_alternative<OptionStringCallback>(callback)) return ArgString;
                                        if(std::holds_alternative<OptionDoubleCallback>(callback)) return ArgDouble;
                                        return ArgUnknown;
                                }
 
                };
 
                void registerOptions(const std::initializer_list<Option> &options) {
                        for(const auto &opt : options) {
                                if(opt.shortName != 0) {
                                        _optionsMap[String(1, opt.shortName)] = opt;
                                }
                                if(!opt.longName.isEmpty()) {
                                        _optionsMap[opt.longName] = opt;
                                }
                                _options.pushToBack(opt);
                        }
                }
 
                CmdLineParser() = default;
 
                void clear() {
                        _optionsMap.clear();
                        _options.clear();
                        _args.clear();
                        return;
                }
 
                int parseMain(int argc, char **argv) {
                        StringList args(argc, (const char **)argv);
                        args.remove(0);
                        return parse(args);
                }
 
                int parse(StringList args);
 
                int argCount() const { return _args.size(); }
 
                const String &arg(int index) const { return _args[index]; }
 
                StringList generateUsage() const;
 
        private:
                Map<String, Option>             _optionsMap;    
                List<Option>                    _options;       
                StringList                      _args;          
 
                static String optionFullName(bool optionName, const Option &option);
};
 
PROMEKI_NAMESPACE_END