cmdlineparser.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <variant>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/stringlist.h>
#include <promeki/string.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/logger.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class CmdLineParser {
        public:
                using OptionCallback = Function<int()>;
 
                using OptionBoolCallback = Function<int(bool)>;
 
                using OptionStringCallback = Function<int(const String &)>;
 
                using OptionIntCallback = Function<int(int)>;
 
                using OptionDoubleCallback = 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;
                        if (argc > 1) args.reserve(static_cast<size_t>(argc - 1));
                        for (int i = 1; i < argc; ++i) {
                                const char *a = argv[i] ? argv[i] : "";
                                size_t      len = 0;
                                while (a[len]) ++len;
                                args.pushToBack(String::fromUtf8(a, len));
                        }
                        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
 
#endif // PROMEKI_ENABLE_CORE