Fancy argparser: argparse.h Source File

Searching...
No Matches
 
#pragma once
 
// define your own macro ARGPARSE_NAMESPACE_NAME
// if you doesn't like default namespace "argparse"
#ifndef ARGPARSE_NAMESPACE_NAME
#define ARGPARSE_NAMESPACE_NAME argparse
#endif
 
#include <string>
#include <sstream>
#include <vector>
#include <tuple>
#include <map>
#include <algorithm>
#include <stdexcept>
#include <limits>
#include <initializer_list>
 
#if __cplusplus > 201402L || _MSVC_LANG > 201402L
#include <any>
#endif
namespace ARGPARSE_NAMESPACE_NAME
{
    namespace 
    {
        const size_t kSizeTypeEnd = static_cast<size_t>(-1);
        const size_t kHelpWidth = 80;
        const size_t kHelpNameWidthPercent = 30;
 
        bool isNumber(const std::string& inStr)
        {
            const bool hasNegSign = inStr.at(0) == '-';
            size_t dotPos = 0, expPos = 0;
            size_t startPos = static_cast<size_t>(hasNegSign);
            for (size_t curPos = startPos; curPos < inStr.size(); ++curPos)
            {
                const char curChar = inStr.at(curPos);
                if (curChar >= '0' && curChar <= '9')
                {
                    continue;
                }
                else if (curChar == '.'
                    && !dotPos && curPos != startPos && curPos != inStr.size() - 1)
                {
                    dotPos = curPos;
                }
                else if ((curChar == 'e' || curChar == 'E')
                    && !expPos && curPos != startPos && curPos != inStr.size() - 1)
                {
                    expPos = curPos;
                    if (!dotPos)
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
            return true;
        }
 
        size_t getStringStreamLength(std::stringstream& showDesc)
        {
            showDesc.seekp(0, std::ios::end);
            return showDesc.tellp();
        }
    }
 
    enum class ArgTypeCast : int
    {
        e_String,
        e_int,
        e_longlong,
        e_double,
        e_bool
    };
    const int kAnyArgCount = -1;
    const int kFromOneToInfiniteArgCount = -2;
 
 
    class ArgumentParser;
    class ArgumentsObject;
    class Argument
    {
        Argument(const std::string& positionalName = "",
            const std::string& shortName = "",
            const std::string& longName = "",
            const int argsCount = 1,
            ArgTypeCast argType = ArgTypeCast::e_String,
            const bool required = true,
            const std::string& help = "")
            : m_required(required)
            , m_nargs(argsCount)
            , m_type(argType)
            , m_positionalName(positionalName)
            , m_shortName(shortName)
            , m_longName(longName)
            , m_help(help)
        {}
    public:
        static Argument CreateNamedArgument(const std::string& shortName = "",
            const std::string& longName = "",
            const int argsCount = 1,
            ArgTypeCast argType = ArgTypeCast::e_String,
            const bool required = true,
            const std::string& help = "")
        {
            return Argument("", shortName, longName, argsCount, argType, required, help);
        }
        static Argument CreatePositionalArgument(const std::string& positionalName = "",
            const int argsCount = 1,
            ArgTypeCast argType = ArgTypeCast::e_String,
            const bool required = true,
            const std::string& help = "")
        {
            return Argument(positionalName, "", "", argsCount, argType, required, help);
        }
        bool m_required = true;
        Argument& SetRequired(bool required)
        {
            m_required = required;
            return *this;
        }
        int m_nargs = 1;
        Argument& SetNumberOfArguments(int amount)
        {
            m_nargs = amount;
            return *this;
        }
        Argument& SetAnyNumberOfArgumentsButAtLeastOne()
        {
            m_nargs = kFromOneToInfiniteArgCount;
            return *this;
        }
        Argument& SetAnyNumberOfArguments()
        {
            m_nargs = kAnyArgCount;
            return *this;
        }
        Argument& SetArgumentIsFlag()
        {
            m_nargs = 0;
            return *this;
        }
        ArgTypeCast m_type = ArgTypeCast::e_String;
        Argument& SetType(ArgTypeCast argType)
        {
            m_type = argType;
            return *this;
        }
        std::string m_positionalName = "";
        Argument& SetPositionalName(const std::string& name)
        {
            m_positionalName = name;
            return *this;
        }
        std::string m_shortName = "";
        Argument& SetShortName(const std::string& name)
        {
            m_shortName = name;
            return *this;
        }
        
        std::string m_longName = "";
        Argument& SetLongName(const std::string& name)
        {
            m_longName = name;
            return *this;
        }
        std::string m_help = "";
        Argument& SetHelp(const std::string& help)
        {
            m_help = help;
            return *this;
        }
        
        std::vector<std::string> m_choicesString = {};
        Argument& SetChoices(const std::vector<std::string>& choices)
        {
            if (m_type != ArgTypeCast::e_String)
            {
                throw std::runtime_error("wrong type");
            }
            m_choicesString = choices;
            return *this;
        }
        Argument& SetChoices(std::initializer_list<const char*> choices)
        {
            return SetChoices(std::vector<std::string>(choices.begin(), choices.end()));
        }
        std::vector<int> m_choicesInt = {};
        Argument& SetChoices(const std::vector<int>& choices)
        {
            if (m_type != ArgTypeCast::e_int)
            {
                throw std::runtime_error("wrong type");
            }
            m_choicesInt = choices;
            return *this;
        }
        std::vector<long long> m_choicesLongLong = {};
        Argument& SetChoices(const std::vector<long long>& choices)
        {
            if (m_type != ArgTypeCast::e_longlong)
            {
                throw std::runtime_error("wrong type");
            }
            m_choicesLongLong = choices;
            return *this;
        }
        std::vector<double> m_choicesDouble = {};
        Argument& SetChoices(const std::vector<double>& choices)
        {
            if (m_type != ArgTypeCast::e_double)
            {
                throw std::runtime_error("wrong type");
            }
            m_choicesDouble = choices;
            return *this;
        }
        Argument& SetDefault(bool defaultArg)
        {
            if (m_type != ArgTypeCast::e_bool)
            {
                throw std::runtime_error("wrong type");
            }
            m_defaultBool.push_back(defaultArg);
            m_hasDefault = true;
            return *this;
        }
        Argument& SetDefault(int defaultArg)
        {
            if (m_type != ArgTypeCast::e_int)
            {
                throw std::runtime_error("wrong type");
            }
            m_defaultInt.push_back(defaultArg);
            m_hasDefault = true;
            return *this;
        }
        Argument& SetDefault(long long defaultArg)
        {
            if (m_type != ArgTypeCast::e_longlong)
            {
                throw std::runtime_error("wrong type");
            }
            m_defaultLongLong.push_back(defaultArg);
            m_hasDefault = true;
            return *this;
        }
        Argument& SetDefault(double defaultArg)
        {
            if (m_type != ArgTypeCast::e_double)
            {
                throw std::runtime_error("wrong type");
            }
            m_defaultDouble.push_back(defaultArg);
            m_hasDefault = true;
            return *this;
        }
        Argument& SetDefault(std::string defaultArg)
        {
            if (m_type != ArgTypeCast::e_String)
            {
                throw std::runtime_error("wrong type");
            }
            m_defaultString.push_back(defaultArg);
            m_hasDefault = true;
            return *this;
        }
        Argument& SetDefault(const std::vector<bool>& defaultArg)
        {
            if (m_type != ArgTypeCast::e_bool)
            {
                throw std::runtime_error("wrong type");
            }
            m_defaultBool = defaultArg;
            m_hasDefault = true;
            return *this;
        }
        Argument& SetDefault(const std::vector<int>& defaultArg)
        {
            if (m_type != ArgTypeCast::e_int)
            {
                throw std::runtime_error("wrong type");
            }
            m_defaultInt = defaultArg;
            m_hasDefault = true;
            return *this;
        }
        Argument& SetDefault(const std::vector<long long>& defaultArg)
        {
            if (m_type != ArgTypeCast::e_longlong)
            {
                throw std::runtime_error("wrong type");
            }
            m_defaultLongLong = defaultArg;
            m_hasDefault = true;
            return *this;
        }
        Argument& SetDefault(const std::vector<double>& defaultArg)
        {
            if (m_type != ArgTypeCast::e_double)
            {
                throw std::runtime_error("wrong type");
            }
            m_defaultDouble = defaultArg;
            m_hasDefault = true;
            return *this;
        }
        Argument& SetDefault(const std::vector<std::string>& defaultArg)
        {
            if (m_type != ArgTypeCast::e_String)
            {
                throw std::runtime_error("wrong type");
            }
            m_defaultString = defaultArg;
            m_hasDefault = true;
            return *this;
        }
 
        bool HasDefault() const
        {
            return m_hasDefault;
        }
 
    private:
        bool                     m_hasDefault = false;
        std::vector<bool>        m_defaultBool = {};
        std::vector<int>         m_defaultInt = {};
        std::vector<long long>   m_defaultLongLong = {};
        std::vector<double>      m_defaultDouble = {};
        std::vector<std::string> m_defaultString = {};
 
        friend ArgumentsObject;
    };
    inline Argument CreateNamedArgument(const std::string& shortName = "",
        const std::string& longName = "",
        const int argsCount = 1,
        ArgTypeCast argType = ArgTypeCast::e_String,
        const bool required = true,
        const std::string& help = "")
    {
        return Argument::CreateNamedArgument(shortName, longName, argsCount, argType, required, help);
    }
    inline Argument CreatePositionalArgument(const std::string& positionalName = "",
        const int argsCount = 1,
        ArgTypeCast argType = ArgTypeCast::e_String,
        const bool required = true,
        const std::string& help = "")
    {
        return Argument::CreatePositionalArgument(positionalName, argsCount, argType, required, help);
    }
    struct NamedArgSpec
    {
        std::string shortName = "";
        std::string longName = "";
        int nargs = 1;
        ArgTypeCast type = ArgTypeCast::e_String;
        bool required = true;
        std::string help = "";
    };
    inline Argument CreateNamedArgument(const NamedArgSpec& spec)
    {
        return Argument::CreateNamedArgument(spec.shortName, spec.longName,
            spec.nargs, spec.type, spec.required, spec.help);
    }
    struct PositionalArgSpec
    {
        std::string name = "";
        int nargs = 1;
        ArgTypeCast type = ArgTypeCast::e_String;
        bool required = true;
        std::string help = "";
    };
    inline Argument CreatePositionalArgument(const PositionalArgSpec& spec)
    {
        return Argument::CreatePositionalArgument(spec.name, spec.nargs,
            spec.type, spec.required, spec.help);
    }
    class ArgumentParsed
    {
    public:
        bool GetArgumentExists()
        {
            return m_exists;
        }
        size_t GetArgumentCount()
        {
            return m_count;
        }
        bool GetAsBool() const
        {
            ThrowIfEmpty(m_bool.empty(), "GetAsBool");
            return m_bool.front();
        }
        int GetAsInt() const
        {
            ThrowIfEmpty(m_int.empty(), "GetAsInt");
            return m_int.front();
        }
        long long GetAsLongLong() const
        {
            ThrowIfEmpty(m_longLong.empty(), "GetAsLongLong");
            return m_longLong.front();
        }
 
        double GetAsDouble() const
        {
            ThrowIfEmpty(m_double.empty(), "GetAsDouble");
            return m_double.front();
        }
 
        std::string GetAsString() const
        {
            ThrowIfEmpty(m_string.empty(), "GetAsString");
            return m_string.front();
        }
        std::vector<bool> GetAsVecBool() const
        {
            return m_bool;
        }
        std::vector<int> GetAsVecInt() const
        {
            return m_int;
        }
        std::vector<long long> GetAsVecLongLong() const
        {
            return m_longLong;
        }
        std::vector<double> GetAsVecDouble() const
        {
            return m_double;
        }
        std::vector<std::string> GetAsVecString() const
        {
            return m_string;
        }
 
#if __cplusplus > 201402L || _MSVC_LANG > 201402L
        std::any Get()
        {
            switch (m_type)
            {
            case ArgTypeCast::e_String:
                if (m_count == 1)
                {
                    return m_string.front();
                }
                return m_string;
                break;
            case ArgTypeCast::e_int:
                if (m_count == 1)
                {
                    return m_int.front();
                }
                return m_int;
                break;
            case ArgTypeCast::e_longlong:
                if (m_count == 1)
                {
                    return m_longLong.front();
                }
                return m_longLong;
                break;
            case ArgTypeCast::e_double:
                if (m_count == 1)
                {
                    return m_double.front();
                }
                return m_double;
                break;
            case ArgTypeCast::e_bool:
            default:
                if (m_count == 1)
                {
                    return m_bool.front();
                }
                return m_bool;
                break;
            }
        }
 
#endif // __cplusplus >= 
 
 
    protected:
 
        ArgumentParsed() {}
        static void ThrowIfEmpty(bool empty, const char* getter)
        {
            if (empty)
            {
                throw std::out_of_range(std::string("ArgumentParsed::") + getter
                    + "() called on an argument that holds no value");
            }
        }
        bool        m_exists{ false };
        ArgTypeCast m_type{ ArgTypeCast::e_String };
        size_t      m_count{ 0 };
        std::vector<bool>        m_bool = {};
        std::vector<int>         m_int = {};
        std::vector<long long>   m_longLong = {};
        std::vector<double>      m_double = {};
        std::vector<std::string> m_string = {};
 
        friend ArgumentsObject;
    };
    class ArgumentsObject
    {
    public:
        bool IsArgValid() const
        {
            return m_isValid;
        }
        const std::string& GetErrorString()
        {
            return m_error;
        }
        size_t ParsedArgsCount() const
        {
            return m_parsed.size();
        }
        ArgumentParsed GetArg(const std::string& name)
        {
            ArgumentParsed arg = ArgumentParsed();
            arg.m_exists = false;
            arg.m_count = 0;
 
            const auto position = m_names.find(name);
            if (position == m_names.end())
            {
                return arg;
            }
 
            const auto argument = m_parsed.find(position->second);
            if (argument == m_parsed.end())
            {
                return arg;
            }
 
            return argument->second;
        }
 
    private:
        ArgumentsObject() {}
 
        void SetValid()
        {
            m_isValid = true;
        }
 
        void SetErrorString(const std::string& error)
        {
            m_parsed.clear();
            m_error = error;
        }
        void ParseDefault(const Argument& argObj, const size_t position)
        {
            ArgumentParsed arg = ArgumentParsed();
            arg.m_exists = true;
            arg.m_type = argObj.m_type;
 
            if (argObj.m_type == ArgTypeCast::e_String)
            {
                arg.m_string = argObj.m_defaultString;
                arg.m_count = argObj.m_defaultString.size();
            }
            else if (argObj.m_type == ArgTypeCast::e_bool)
            {
                arg.m_bool = argObj.m_defaultBool;
                arg.m_count = argObj.m_defaultBool.size();
            }
            else if (argObj.m_type == ArgTypeCast::e_double)
            {
                arg.m_double = argObj.m_defaultDouble;
                arg.m_count = argObj.m_defaultDouble.size();
            }
            else if (argObj.m_type == ArgTypeCast::e_longlong)
            {
                arg.m_longLong = argObj.m_defaultLongLong;
                arg.m_count = argObj.m_defaultLongLong.size();
            }
            else if (argObj.m_type == ArgTypeCast::e_int)
            {
                arg.m_int = argObj.m_defaultInt;
                arg.m_count = argObj.m_defaultInt.size();
            }
 
            m_parsed.emplace(position, arg);
            if (!argObj.m_shortName.empty())
            {
                m_names[argObj.m_shortName] = position;
            }
            if (!argObj.m_longName.empty())
            {
                m_names[argObj.m_longName] = position;
            }
            if (!argObj.m_positionalName.empty())
            {
                m_names[argObj.m_positionalName] = position;
            }
        }
        void CreateParsingStub(const Argument& argObj, const size_t position)
        {
            const auto argument = m_parsed.find(position);
            if (argument == m_parsed.end())
            {
                ArgumentParsed arg = ArgumentParsed();
                arg.m_exists = true;
                arg.m_count = 0;
                arg.m_type = argObj.m_type;
                m_parsed.emplace(position, arg);
                if (!argObj.m_shortName.empty())
                {
                    m_names[argObj.m_shortName] = position;
                }
                if (!argObj.m_longName.empty())
                {
                    m_names[argObj.m_longName] = position;
                }
                if (!argObj.m_positionalName.empty())
                {
                    m_names[argObj.m_positionalName] = position;
                }
            }
        }
        bool Parse(const Argument& argObj, const size_t position, const std::string& token)
        {
            const auto argument = m_parsed.find(position);
            if (argument == m_parsed.end())
            {
                ArgumentParsed arg = ArgumentParsed();
                arg.m_exists = true;
                arg.m_count = 0;
                arg.m_type = argObj.m_type;
                m_parsed.emplace(position, arg);
                if (!argObj.m_shortName.empty())
                {
                    m_names[argObj.m_shortName] = position;
                }
                if (!argObj.m_longName.empty())
                {
                    m_names[argObj.m_longName] = position;
                }
                if (!argObj.m_positionalName.empty())
                {
                    m_names[argObj.m_positionalName] = position;
                }
                return true;
            }
 
            if (argument->second.m_type == ArgTypeCast::e_String)
            {
                if (argObj.m_nargs != 0)
                {
                    if (argObj.m_choicesString.size())
                    {
                        auto it = std::find_if(argObj.m_choicesString.begin(), argObj.m_choicesString.end(),
                            [&token](const std::string& str) -> bool
                            {
                                return token == str;
                            });
                        if (it == argObj.m_choicesString.end())
                        {
                            return InvalidateArgsOutOfChoice(argObj, token);
                        }
                    }
                    argument->second.m_string.push_back(token);
                }
                else
                {
                    return InvalidateArgsTooMany(argObj);
                }
            }
            else if (argument->second.m_type == ArgTypeCast::e_bool)
            {
                if (argObj.m_nargs != 0)
                {
                    if (token == "True" || token == "TRUE" || token == "true")
                    {
                        argument->second.m_bool.push_back(true);
                    }
                    else if (token == "False" || token == "FALSE" || token == "false")
                    {
                        argument->second.m_bool.push_back(false);
                    }
                    else
                    {
                        return InvalidateArgsCannotParse(argObj, token);
                    }
                }
                else
                {
                    return InvalidateArgsTooMany(argObj);
                }
            }
            else if (argument->second.m_type == ArgTypeCast::e_int)
            {
                if (argObj.m_nargs != 0)
                {
                    if (isNumber(token))
                    {
                        try
                        {
                            argument->second.m_int.push_back(std::stoi(token));
 
                            int value = argument->second.m_int.back();
 
                            if (argObj.m_choicesInt.size())
                            {
                                auto it = std::find_if(argObj.m_choicesInt.begin(), argObj.m_choicesInt.end(),
                                    [value](const int& integerValue) -> bool
                                    {
                                        return value == integerValue;
                                    });
                                if (it == argObj.m_choicesInt.end())
                                {
                                    return InvalidateArgsOutOfChoice(argObj, token);
                                }
                            }
                        }
                        catch (...)
                        {
                            return InvalidateArgsCannotParse(argObj, token);
                        }
                    }
                    else
                    {
                        return InvalidateArgsCannotParse(argObj, token);
                    }
                }
                else
                {
                    return InvalidateArgsTooMany(argObj);
                }
            }
            else if (argument->second.m_type == ArgTypeCast::e_longlong)
            {
                if (argObj.m_nargs != 0)
                {
                    if (isNumber(token))
                    {
                        try
                        {
                            argument->second.m_longLong.push_back(std::stoll(token));
 
                            long long value = argument->second.m_longLong.back();
 
                            if (argObj.m_choicesLongLong.size())
                            {
                                auto it = std::find_if(argObj.m_choicesLongLong.begin(), argObj.m_choicesLongLong.end(),
                                    [value](const long long& longLongVal) -> bool
                                    {
                                        return value == longLongVal;
                                    });
                                if (it == argObj.m_choicesLongLong.end())
                                {
                                    return InvalidateArgsOutOfChoice(argObj, token);
                                }
                            }
                        }
                        catch (...)
                        {
                            return InvalidateArgsCannotParse(argObj, token);
                        }
                    }
                    else
                    {
                        return InvalidateArgsCannotParse(argObj, token);
                    }
                }
                else
                {
                    return InvalidateArgsTooMany(argObj);
                }
            }
            else if (argument->second.m_type == ArgTypeCast::e_double)
            {
                if (argObj.m_nargs != 0)
                {
                    if (isNumber(token))
                    {
                        try
                        {
                            argument->second.m_double.push_back(std::stod(token));
 
                            double value = argument->second.m_double.back();
 
                            if (argObj.m_choicesDouble.size())
                            {
                                auto it = std::find_if(argObj.m_choicesDouble.begin(), argObj.m_choicesDouble.end(),
                                    [value](const double& doubleVal) -> bool
                                    {
                                        return std::numeric_limits<double>::epsilon() >= abs(doubleVal - value);
                                    });
                                if (it == argObj.m_choicesDouble.end())
                                {
                                    return InvalidateArgsOutOfChoice(argObj, token);
                                }
                            }
                        }
                        catch (...)
                        {
                            return InvalidateArgsCannotParse(argObj, token);
                        }
                    }
                    else
                    {
                        return InvalidateArgsCannotParse(argObj, token);
                    }
                }
                else
                {
                    return InvalidateArgsTooMany(argObj);
                }
            }
 
            argument->second.m_count += 1;
            return true;
        }
        bool InvalidateArgsOutOfChoice(const Argument& argObj, const std::string& token)
        {
            const std::string& name = argObj.m_longName.empty() ? (argObj.m_shortName.empty() ? argObj.m_positionalName : argObj.m_shortName) : argObj.m_longName;
 
            SetErrorString("Value '" + token + "' is out of choices for \"" + name + "\"");
 
            return false;
        }
        bool InvalidateArgsTooMany(const Argument& argObj)
        {
            const std::string& name = argObj.m_longName.empty() ? (argObj.m_shortName.empty() ? argObj.m_positionalName : argObj.m_shortName) : argObj.m_longName;
 
            SetErrorString("too many arguments for \"" + name + "\"");
 
            return false;
        }
        bool InvalidateArgsCannotParse(const Argument& argObj, const std::string& token)
        {
            const std::string& name = argObj.m_longName.empty() ? (argObj.m_shortName.empty() ? argObj.m_positionalName : argObj.m_shortName) : argObj.m_longName;
 
            SetErrorString("cannot parse [\"" + token + "\"] for  argument \"" + name + "\"");
 
            return false;
        }
 
        bool m_isValid = false;
        std::string m_error;
        std::map<const size_t, ArgumentParsed>  m_parsed;
        std::map<const std::string, size_t>     m_names;
 
        friend ArgumentParser;
    };
 
    class ArgumentParser
    {
    public:
        ArgumentParser(const std::string& name) noexcept
            : m_name(name)
        {}
        ArgumentParser& SetDescription(const std::string& description) noexcept
        {
            m_description = description;
            return *this;
        }
        ArgumentParser& SetAllowAbbrev(bool allowAbbrev) noexcept
        {
            m_allowAbbrev = allowAbbrev;
            return *this;
        }
        ArgumentParser& SetIgnoreUnknownArgs(bool ignoreUnknownArgs) noexcept
        {
            m_ignoreUnknownArgs = ignoreUnknownArgs;
            return *this;
        }
        ArgumentParser& SetAddHelp(bool addHelp) noexcept
        {
            m_addHelp = addHelp;
            return *this;
        }
 
 
        ArgumentParser& SetEpilogue(const std::string& epilogue) noexcept
        {
            m_epilogue = epilogue;
            return *this;
        }
        ArgumentParser& SetUsage(const std::string& usage) noexcept
        {
            m_usage = usage;
            return *this;
        }
        ArgumentParser& SetPrefixChars(const char charSym) noexcept
        {
            m_prefix = charSym;
            return *this;
        }
        void AddArgument(const Argument& arg)
        {
            if (arg.m_longName.empty() && arg.m_shortName.empty() && arg.m_positionalName.empty())
            {
                throw std::runtime_error("Short,long or positional names of argument are empty.\n"
                    "At least one name should been specified.");
            }
            else if (!(arg.m_longName.empty() || arg.m_shortName.empty()) && !arg.m_positionalName.empty())
            {
                throw std::runtime_error("Positional argument " + arg.m_positionalName + " declared aside with short/long name\n"
                    "Positional argument shouldn't have any short/long name.");
            }
            else if (arg.m_choicesDouble.size() + arg.m_choicesInt.size() + arg.m_choicesLongLong.size() + arg.m_choicesString.size())
            {
                if (arg.m_type == ArgTypeCast::e_bool)
                {
                    throw std::runtime_error("No need to declare choice for bool type");
                }
                else if (arg.m_type == ArgTypeCast::e_int && arg.m_choicesDouble.size() + arg.m_choicesLongLong.size() + arg.m_choicesString.size())
                {
                    throw std::runtime_error("Only int choices should been declared");
                }
                else if (arg.m_type == ArgTypeCast::e_longlong && arg.m_choicesDouble.size() + arg.m_choicesInt.size() + arg.m_choicesString.size())
                {
                    throw std::runtime_error("Only long long choices should been declared");
                }
                else if (arg.m_type == ArgTypeCast::e_double && arg.m_choicesInt.size() + arg.m_choicesLongLong.size() + arg.m_choicesString.size())
                {
                    throw std::runtime_error("Only double choices should been declared");
                }
                else if (arg.m_type == ArgTypeCast::e_String && arg.m_choicesInt.size() + arg.m_choicesLongLong.size() + arg.m_choicesDouble.size())
                {
                    throw std::runtime_error("Only string choices should been declared");
                }
            }
            _addArg(arg);
        }
        ArgumentsObject ParseArgs(const std::vector<std::string>& args)
        {
            std::string _pref{ m_prefix };
            std::string _doublePref{ m_prefix, m_prefix };
 
            for (auto& el : m_knownArgumentNames)
            {
                if (el.second.argNameType == KnownNameType::e_Short)
                {
                    m_knownArgumentNamesInternal[_pref + el.first] = el.second;
                }
                else
                {
                    m_knownArgumentNamesInternal[_doublePref + el.first] = el.second;
                }
            }
 
            if (m_addHelp)
            {
                bool shortHelpAlreadyExists = false, longHelpAlreadyExists = false;
                auto foundArgObject = m_knownArgumentNamesInternal.find(_pref + "h");
                shortHelpAlreadyExists = foundArgObject != m_knownArgumentNamesInternal.end();
                foundArgObject = m_knownArgumentNamesInternal.find(_doublePref + "help");
                longHelpAlreadyExists = foundArgObject != m_knownArgumentNamesInternal.end();
                if (!shortHelpAlreadyExists || !longHelpAlreadyExists)
                {
                    Argument arg = Argument::CreateNamedArgument(shortHelpAlreadyExists ? "" : "h", longHelpAlreadyExists ? "" : "help", 0);
                    arg.SetHelp("Show help!");
                    arg.SetRequired(false);
                    _addArg(arg);
                    if (!shortHelpAlreadyExists)
                    {
                        m_knownArgumentNamesInternal[_pref + arg.m_shortName] = { m_arguments.size()-1, KnownNameType::e_Short };
                    }
                    if (!longHelpAlreadyExists)
                    {
                        m_knownArgumentNamesInternal[_doublePref + arg.m_longName] = { m_arguments.size()-1, KnownNameType::e_Long };
                    }
                }
            }
 
            bool positionalArgsEndFlag = false;
            size_t currentArgumentObjectIndex = kSizeTypeEnd;
            std::vector<std::string> positionalArgs;
            ArgumentsObject argObj;
            for (size_t i =0; i < args.size(); ++i)
            {
                const std::string& el = args[i];
                auto foundArgObject = m_knownArgumentNamesInternal.find(el);
                if (foundArgObject == m_knownArgumentNamesInternal.end() && m_allowAbbrev)
                {
                    // SetAllowAbbrev: accept an unambiguous prefix of a long option,
                    // e.g. "--verb" for "--verbose".
                    bool ambiguous = false;
                    std::string abbrev = ResolveAbbreviation(el, _doublePref, ambiguous);
                    if (ambiguous)
                    {
                        argObj.SetErrorString("Ambiguous option \"" + el
                            + "\" matches more than one argument");
                        return argObj;
                    }
                    if (!abbrev.empty())
                    {
                        foundArgObject = m_knownArgumentNamesInternal.find(abbrev);
                    }
                }
                if (foundArgObject != m_knownArgumentNamesInternal.end())
                {
                    currentArgumentObjectIndex = foundArgObject->second.position;
 
                    Argument& argument = m_arguments[currentArgumentObjectIndex];
                    if (argument.m_nargs == 0)
                    {
                        if (!argObj.Parse(argument, currentArgumentObjectIndex, el))
                        {
                            return argObj;
                        }
                    }
                    else
                    {
                        argObj.CreateParsingStub(argument, currentArgumentObjectIndex);
                    }
 
                    positionalArgsEndFlag = true;
                    continue;
                }
                else if (!positionalArgsEndFlag)
                {
                    if (isNumber(el))
                    {
                        positionalArgs.push_back(el);
                    }
                    else if (el.find(_pref) == 0 || el.find(_doublePref) == 0)
                    {
                        if (!_unknownArgumentHit(argObj, i+1, currentArgumentObjectIndex, positionalArgsEndFlag, el))
                        {
                            return argObj;
                        }
                    }
                    else
                    {
                        positionalArgs.push_back(el);
                    }
                    continue;
                }
                else if (el.find(_pref) == 0 || el.find(_doublePref) == 0)
                {
                    if (!_unknownArgumentHit(argObj, i+1, currentArgumentObjectIndex, positionalArgsEndFlag, el))
                    {
                        return argObj;
                    }
                    continue;
                }
 
                if (currentArgumentObjectIndex != kSizeTypeEnd)
                {
                    Argument& argument = m_arguments[currentArgumentObjectIndex];
 
                    if (!argObj.Parse(argument, currentArgumentObjectIndex, el))
                    {
                        return argObj;
                    }
                }
            }
 
            if (!positionalArgs.empty())
            {
                if (m_positionalArgumentNames.empty())
                {
                    argObj.SetErrorString("Unknown positional argument:" + positionalArgs.front());
                    return argObj;
                }
                size_t minimumRequiredPositionalCount = 0;
                size_t infiniteRequiredPositionalCount = 0;
                size_t optionalPositionalCount = 0;
 
                for (auto& el : m_positionalArgumentNames)
                {
                    if (m_arguments[el.positionInArguments].m_required)
                    {
                        minimumRequiredPositionalCount += m_arguments[el.positionInArguments].m_nargs == kFromOneToInfiniteArgCount ? 1 : m_arguments[el.positionInArguments].m_nargs;
                        infiniteRequiredPositionalCount = m_arguments[el.positionInArguments].m_nargs == kFromOneToInfiniteArgCount;
                    }
                    else
                    {
                        ++optionalPositionalCount;
                    }
                }
                if (minimumRequiredPositionalCount > positionalArgs.size())
                {
                    argObj.SetErrorString("Too few positional arguments: required " + std::to_string(minimumRequiredPositionalCount) + " got " + std::to_string(positionalArgs.size()));
                    return argObj;
                }
 
                size_t totalTokensForRequiredNargs = 1;
                size_t additionalTokensForFirstRequiredNarg = 0;
                size_t howMuchOptionalArgsCanBeParsed = positionalArgs.size() - minimumRequiredPositionalCount;
                if (howMuchOptionalArgsCanBeParsed > optionalPositionalCount)
                {
                    if (infiniteRequiredPositionalCount == 0)
                    {
                        argObj.SetErrorString("Too many positional arguments!");
                        return argObj;
                    }
                    else
                    {
                        totalTokensForRequiredNargs = (howMuchOptionalArgsCanBeParsed - optionalPositionalCount) / infiniteRequiredPositionalCount;
                        additionalTokensForFirstRequiredNarg = (howMuchOptionalArgsCanBeParsed - optionalPositionalCount) % infiniteRequiredPositionalCount;
                    }
                    howMuchOptionalArgsCanBeParsed = optionalPositionalCount;
                }
 
 
                size_t currentTokenPosition = 0;
                size_t optionalParsed = 0;
 
                for (auto& el : m_positionalArgumentNames)
                {
                    Argument& argument = m_arguments[el.positionInArguments];
                    argObj.CreateParsingStub(argument, el.positionInArguments);
 
                    if (m_arguments[el.positionInArguments].m_required)
                    {
 
                        if (m_arguments[el.positionInArguments].m_nargs != kFromOneToInfiniteArgCount)
                        {
                            for (size_t i = 0; i < static_cast<size_t>(m_arguments[el.positionInArguments].m_nargs); ++i)
                            {
                                if (!argObj.Parse(argument, el.positionInArguments, positionalArgs[currentTokenPosition]))
                                {
                                    return argObj;
                                }
                                ++currentTokenPosition;
                            }
                        }
                        else
                        {
                            size_t addtionalArg = 0;
                            if (additionalTokensForFirstRequiredNarg > 0)
                            {
                                ++addtionalArg;
                                --additionalTokensForFirstRequiredNarg;
                            }
                            for (size_t i = 0; i < totalTokensForRequiredNargs + addtionalArg; ++i)
                            {
                                if (!argObj.Parse(argument, el.positionInArguments, positionalArgs[currentTokenPosition]))
                                {
                                    return argObj;
                                }
                                ++currentTokenPosition;
                            }
                        }
                    }
                    else if (optionalParsed <= howMuchOptionalArgsCanBeParsed)
                    {
                        if (!argObj.Parse(argument, el.positionInArguments, positionalArgs[currentTokenPosition]))
                        {
                            return argObj;
                        }
                        ++currentTokenPosition;
                        ++optionalParsed;
                    }
                }
            }
 
            for (size_t i = 0; i < m_arguments.size(); ++i)
            {
                auto el = m_arguments[i];
                const std::string& name = el.m_longName.empty() ? (el.m_shortName.empty() ? el.m_positionalName : el.m_shortName) : el.m_longName;
 
                ArgumentParsed parsedArg = argObj.GetArg(name);
 
                if (parsedArg.GetArgumentExists())
                {
                    if (static_cast<int>(parsedArg.GetArgumentCount()) == el.m_nargs
                        || el.m_nargs == kAnyArgCount
                        || (el.m_nargs == kFromOneToInfiniteArgCount && parsedArg.GetArgumentCount() >= 1))
                    {
                        continue;
                    }
                    else
                    {
                        argObj.SetErrorString("Wrong arguments count for argument with name \"" + name + "\" got = " + std::to_string(parsedArg.GetArgumentCount()));
                        return argObj;
                    }
                }
                else if (el.HasDefault())
                {
                    argObj.ParseDefault(el, i);
                }
                else if (el.m_required)
                {
                    argObj.SetErrorString("Required argument with name \"" + name + "\" does not exist");
                    return argObj;
                }
            }
 
            argObj.SetValid();
            return argObj;
        }
        bool _unknownArgumentHit(ArgumentsObject& argObj, const size_t positionInInput, size_t& currentArgumentObjectIndex, bool& positionalArgsEndFlag, const std::string& el)
        {
            if (m_ignoreUnknownArgs)
            {
                currentArgumentObjectIndex = kSizeTypeEnd;
                positionalArgsEndFlag = true;
                return true;
            }
            std::stringstream ss;
            ss << "Unknown input argument: \"" << el << "\" at position " << positionInInput;
            argObj.SetErrorString(ss.str());
            return false;
        }
        ArgumentsObject ParseArgs(const int argc, char** argv)
        {
 
            std::vector<std::string> args;
            for (int i = 1; i < argc; ++i)
            {
                args.emplace_back(argv[i]);
            }
 
            return ParseArgs(args);
        }
        std::string GetHelp(size_t width = kHelpWidth, size_t nameWidthPercent = kHelpNameWidthPercent)
        {
            width = width < kHelpWidth ? kHelpWidth : width;
            size_t nameWidthInHelp = nameWidthPercent * width / 100;
            width -= nameWidthInHelp;
 
 
            // NOTE: do not initialize the stream with "usage: " -- the first
            // insertion below would overwrite it (the put pointer starts at 0).
            std::stringstream usage;
            if (!m_usage.empty())
            {
                // Caller-provided usage line (SetUsage) overrides the auto-generated one.
                usage << m_usage;
            }
            else
            {
                usage << m_name << " ";
                if (m_positionalArgumentNames.size())
                {
                    for (auto& el : m_positionalArgumentNames)
                    {
                        Argument& arg = m_arguments[el.positionInArguments];
                        MakeUsageForName(arg, usage);
                    }
                }
                for (auto& el : m_arguments)
                {
                    if (el.m_positionalName.empty())
                    {
                        MakeUsageForName(el, usage);
                    }
                }
            }
 
            if (!m_description.empty())
            {
                AddAdditionalDescription(usage, m_description, width+nameWidthInHelp);
            }
 
            if (m_positionalArgumentNames.size())
            {
                usage << "\n\n" << "positional arguments:\n\n";
                for (auto& el : m_positionalArgumentNames)
                {
                    Argument& arg = m_arguments[el.positionInArguments];
                    MakeDescriptionForArg(arg, usage, nameWidthInHelp, width);
                }
            }
 
            if (m_arguments.size() > m_positionalArgumentNames.size())
            {
                usage << "\n\n" << "named arguments:\n\n";
                for (auto& el : m_arguments)
                {
                    if (el.m_positionalName.empty())
                    {
                        MakeDescriptionForArg(el, usage, nameWidthInHelp, width);
                    }
                }
            }
 
            if (!m_epilogue.empty())
            {
                AddAdditionalDescription(usage, m_epilogue, width+nameWidthInHelp);
            }
 
            return TrimTrailingSpacesPerLine(usage.str());
        }
        static std::string TrimTrailingSpacesPerLine(const std::string& text)
        {
            std::string result;
            result.reserve(text.size());
            size_t lineStart = 0;
            while (lineStart <= text.size())
            {
                size_t nl = text.find('\n', lineStart);
                size_t lineEnd = (nl == std::string::npos) ? text.size() : nl;
                size_t last = lineEnd;
                while (last > lineStart && (text[last - 1] == ' ' || text[last - 1] == '\t'))
                {
                    --last;
                }
                result.append(text, lineStart, last - lineStart);
                if (nl == std::string::npos)
                {
                    break;
                }
                result.push_back('\n');
                lineStart = nl + 1;
            }
            return result;
        }
 
    private:
 
        std::string ResolveAbbreviation(
            const std::string& token, const std::string& doublePref, bool& ambiguous)
        {
            ambiguous = false;
            // Only long options (prefixed with the double prefix) can be abbreviated,
            // and the token must be a strict, non-empty prefix.
            if (token.size() <= doublePref.size()
                || token.compare(0, doublePref.size(), doublePref) != 0)
            {
                return std::string();
            }
 
            std::string match;
            for (auto it = m_knownArgumentNamesInternal.begin();
                it != m_knownArgumentNamesInternal.end(); ++it)
            {
                if (it->second.argNameType == KnownNameType::e_Long
                    && it->first.size() > token.size()
                    && it->first.compare(0, token.size(), token) == 0)
                {
                    if (!match.empty())
                    {
                        ambiguous = true;
                        return std::string();
                    }
                    match = it->first;
                }
            }
            return match;
        }
        void _addArg(const Argument& arg)
        {
            size_t currentSize = m_arguments.size();
            if (!arg.m_shortName.empty())
            {
                if (m_knownArgumentNames.find(arg.m_shortName) == m_knownArgumentNames.end())
                {
                    m_knownArgumentNames[arg.m_shortName] = { currentSize, KnownNameType::e_Short };
                }
                else
                {
                    throw std::runtime_error("Short name \"" + arg.m_shortName + "\" already exists");
                }
            }
            if (!arg.m_longName.empty())
            {
                if (m_knownArgumentNames.find(arg.m_longName) == m_knownArgumentNames.end())
                {
                    m_knownArgumentNames[arg.m_longName] = { currentSize, KnownNameType::e_Long };
                }
                else
                {
                    throw std::runtime_error("Long name \"" + arg.m_longName + "\" already exists");
                }
            }
            if (!arg.m_positionalName.empty())
            {
                auto it = std::find_if(m_positionalArgumentNames.begin(), m_positionalArgumentNames.end(), [&arg](PositionalNamesStruct& posarg)->bool {return posarg.argName == arg.m_positionalName; });
                if (it == m_positionalArgumentNames.end())
                {
                    m_positionalArgumentNames.emplace_back(m_arguments.size(), arg.m_positionalName);
                }
                else if (arg.m_required && (arg.m_nargs == 0 || arg.m_nargs == kAnyArgCount))
                {
                    throw std::runtime_error("Required positional argument with name \"" + arg.m_positionalName + "\" cannot be with zero count");
                }
                else if (!arg.m_required && arg.m_nargs != 1)
                {
                    throw std::runtime_error("Non required positional argument with name \"" + arg.m_positionalName + "\" should be with count 1");
                }
                else
                {
                    throw std::runtime_error("Positional name \"" + arg.m_positionalName + "\" already exists");
                }
            }
 
            m_arguments.emplace_back(arg);
        }
        void MakeUsageForName(Argument& arg, std::stringstream& usage)
        {
            if (!arg.m_required)
            {
                usage << "[";
            }
            std::stringstream showName;
            if (arg.m_choicesDouble.size() + arg.m_choicesInt.size() + arg.m_choicesLongLong.size() + arg.m_choicesString.size())
            {
                showName << "{";
                if (arg.m_type == ArgTypeCast::e_String)
                {
                    MakeChoicesToString<std::string>(showName, arg.m_choicesString);
                }
                else if (arg.m_type == ArgTypeCast::e_int)
                {
                    MakeChoicesToString<int>(showName, arg.m_choicesInt);
                }
                else if (arg.m_type == ArgTypeCast::e_double)
                {
                    MakeChoicesToString<double>(showName, arg.m_choicesDouble);
                }
                else if (arg.m_type == ArgTypeCast::e_longlong)
                {
                    MakeChoicesToString<long long>(showName, arg.m_choicesLongLong);
                }
                showName << "}";
            }
            else
            {
                if (!arg.m_positionalName.empty())
                {
                    showName << arg.m_positionalName;
                }
                else if (!arg.m_shortName.empty())
                {
                    showName << arg.m_shortName;
                }
                else
                {
                    showName << arg.m_longName;
                }
            }
            if (!arg.m_positionalName.empty())
            {
                usage << showName.str();
            }
            if (!arg.m_shortName.empty())
            {
                usage << m_prefix << arg.m_shortName;
            }
 
            if (!arg.m_longName.empty())
            {
                if (!arg.m_shortName.empty())
                {
                    usage << ",";
                }
                usage << m_prefix << m_prefix << arg.m_longName;
            }
 
            if (arg.m_nargs == kAnyArgCount)
            {
                usage << " [" << showName.str() << "[" << showName.str() << " ...]]";
            }
            else if (arg.m_nargs == kFromOneToInfiniteArgCount)
            {
                usage << " [" << showName.str() << " ...]";
            }
            else if (arg.m_nargs != 0)
            {
                usage << " [";
                usage << showName.str();
                for (size_t i = 1; i < static_cast<size_t>(arg.m_nargs); ++i)
                {
                    usage << " " << showName.str();
                }
                usage << "]";
            }
            if (!arg.m_required)
            {
                usage << "]";
            }
            // Always separate tokens with exactly one trailing space. This also
            // keeps flags (nargs == 0) from gluing onto the next token.
            usage << " ";
        }
        void MakeDescriptionForArg(Argument& arg, std::stringstream& description, size_t nameLen, size_t descLen)
        {
            std::stringstream showName;
            std::stringstream showDesc;
            if (!arg.m_positionalName.empty())
            {
                if (arg.m_choicesDouble.size() + arg.m_choicesInt.size() + arg.m_choicesLongLong.size() + arg.m_choicesString.size())
                {
                    showName << "{";
                    if (arg.m_type == ArgTypeCast::e_String)
                    {
                        MakeChoicesToString<std::string>(showName, arg.m_choicesString);
                    }
                    else if (arg.m_type == ArgTypeCast::e_int)
                    {
                        MakeChoicesToString<int>(showName, arg.m_choicesInt);
                    }
                    else if (arg.m_type == ArgTypeCast::e_double)
                    {
                        MakeChoicesToString<double>(showName, arg.m_choicesDouble);
                    }
                    else if (arg.m_type == ArgTypeCast::e_longlong)
                    {
                        MakeChoicesToString<long long>(showName, arg.m_choicesLongLong);
                    }
                    showName << "}";
                }
                else
                {
                    showName << arg.m_positionalName;
                }
            }
            else if (!arg.m_shortName.empty())
            {
                showName << m_prefix << arg.m_shortName;
                if (!arg.m_longName.empty())
                {
                    showName << "," << m_prefix << m_prefix << arg.m_longName;
                }
            }
            else
            {
                // Long name only: no short name, so no leading comma.
                showName << m_prefix << m_prefix << arg.m_longName;
            }
 
            showDesc << arg.m_help;
            if (arg.m_nargs)
            {
                showDesc << (arg.m_help.empty() ? "" : " ") << "Type: " << m_enumToString[arg.m_type] << ". ";
            }
 
            if ((!arg.m_shortName.empty() || !arg.m_longName.empty())
                && (arg.m_choicesDouble.size() + arg.m_choicesInt.size() + arg.m_choicesLongLong.size() + arg.m_choicesString.size()))
            {
                showDesc << " Choices:";
                if (arg.m_type == ArgTypeCast::e_String)
                {
                    MakeChoicesToString<std::string>(showDesc, arg.m_choicesString);
                }
                else if (arg.m_type == ArgTypeCast::e_int)
                {
                    MakeChoicesToString<int>(showDesc, arg.m_choicesInt);
                }
                else if (arg.m_type == ArgTypeCast::e_double)
                {
                    MakeChoicesToString<double>(showDesc, arg.m_choicesDouble);
                }
                else if (arg.m_type == ArgTypeCast::e_longlong)
                {
                    MakeChoicesToString<long long>(showDesc, arg.m_choicesLongLong);
                }
                showDesc << ". ";
            }
 
            showDesc << (arg.m_nargs ? "Args count: " : "");
            switch (arg.m_nargs)
            {
            case kAnyArgCount:
                showDesc << "any. ";
                break;
            case kFromOneToInfiniteArgCount:
                showDesc << " at least one. ";
                break;
            case 0:
                break;
            default:
                showDesc << arg.m_nargs << " ";
                break;
            }
            description << showName.str();
            size_t currentLen = getStringStreamLength(showName);
 
            size_t spaceFillerSize = nameLen - currentLen;
            if (currentLen >= nameLen - 1)
            {
                description << "\n";
                spaceFillerSize = nameLen;
            }
 
            // generate space after names printed
            std::string filler(spaceFillerSize, ' ');
            description << filler;
 
            // generate space for new line of description
            currentLen = 0;
 
            filler = std::string(nameLen, ' ');
 
            for (std::string s; showDesc >> s; )
            {
                if (currentLen > descLen)
                {
                    currentLen = 0;
                    description << "\n" << filler;
                }
                description << s << " ";
                currentLen += s.size() + 1;
            }
 
            description << "\n";
        }
 
        void AddAdditionalDescription(std::stringstream& description, const std::string& additionalDesc, size_t descLen)
        {
            description << "\n";
            size_t currentLen = 0;
            std::stringstream buffer{ additionalDesc };
            for (std::string s; buffer >> s; )
            {
                if (currentLen > descLen)
                {
                    currentLen = 0;
                    description << "\n";
                }
                description << s << " ";
                currentLen += s.size() + 1;
            }
        }
 
        template<typename T>
        void MakeChoicesToString(std::stringstream& outSstream, std::vector<T>& choices)
        {
            outSstream << choices.front();
            for (size_t i = 1; i < choices.size(); ++i)
            {
                outSstream << ", " << choices[i];
            }
        }
 
    private:
        enum class KnownNameType :int
        {
            e_Short,
            e_Long
        };
        struct KnownNamesStruct
        {
            size_t position;
            KnownNameType argNameType;
        };
 
        struct PositionalNamesStruct
        {
            PositionalNamesStruct(const size_t position, const std::string& name)
                :positionInArguments(position)
                , argName(name)
            {}
            size_t positionInArguments;
            std::string argName;
        };
 
    private:
        bool        m_allowAbbrev = true;
        bool        m_addHelp = true;
        bool        m_ignoreUnknownArgs = false;
        char        m_prefix = '-';
        std::string m_name;
        std::string m_description{ "" };
        std::string m_epilogue{ "" };
        std::string m_usage{ "" };
        std::vector<Argument> m_arguments;
        std::vector<PositionalNamesStruct>      m_positionalArgumentNames;
        std::map<std::string, KnownNamesStruct> m_knownArgumentNames;
        std::map<std::string, KnownNamesStruct> m_knownArgumentNamesInternal;
 
        std::map<const ArgTypeCast, const std::string> m_enumToString
        {
            {ArgTypeCast::e_String,     "STRING" },
            {ArgTypeCast::e_int,        "INT" },
            {ArgTypeCast::e_longlong,   "LONG_LONG"},
            {ArgTypeCast::e_double,     "DOUBLE"},
            {ArgTypeCast::e_bool,       "BOOL"}
        };
    };
}