tim::argparse::argument_parser Struct Reference

#include "timemory/utility/argparse.hpp"

Collaboration diagram for tim::argparse::argument_parser:

Classes
struct	arg_result
struct	argument

Public Types
using	this_type = argument_parser
using	result_type = arg_result
using	bool_func_t = std::function< bool(this_type &)>
using	action_func_t = std::function< void(this_type &)>
using	action_pair_t = std::pair< bool_func_t, action_func_t >
using	error_func_t = std::function< void(this_type &, arg_result &)>
using	known_args_t = std::tuple< arg_result, int, char ** >
using	strvec_t = std::vector< std::string >
using	strset_t = std::set< std::string >

Public Member Functions
	argument_parser (std::string desc)
argument &	add_argument ()
argument &	add_argument (const std::initializer_list< std::string > &_names, const std::string &desc, bool req=false)
argument &	add_argument (const std::vector< std::string > &_names, const std::string &desc, bool req=false)
argument &	add_positional_argument (const std::string &_name)
template<typename Tp >
arg_result	get (size_t _idx, Tp &_value)
template<typename Tp >
arg_result	get (const std::string &_name, Tp &_value)
template<typename BoolFuncT , typename ActionFuncT >
this_type &	add_action (BoolFuncT &&_b, ActionFuncT &_act)
template<typename ActionFuncT >
this_type &	add_action (const std::string &_name, ActionFuncT &_act)
void	print_help (const std::string &_extra="")
known_args_t	parse_known_args (int argc, char **argv, const std::string &_delim="--", int verbose_level=0)
	Basic variant of parse_known_args which does not replace argc/argv and does not provide an array of strings that it processed. More...
arg_result	parse_known_args (int *argc, char ***argv, const std::string &_delim="--", int verbose_level=0)
	This variant calls parse_known_args and replaces argc and argv with the argv[0] + anything after delimiter (if the delimiter is provided). If the delimiter does not exist, argc and argv are unchanged. More...
arg_result	parse_known_args (int *argc, char ***argv, strvec_t &_args, const std::string &_delim="--", int verbose_level=0)
known_args_t	parse_known_args (int argc, char **argv, strvec_t &_args, const std::string &_delim="--", int verbose_level=0)
	Parses all options until argv[argc-1] or delimiter is found. Returns a tuple containing an argument error object (operator bool will return true if there was an error) and the new argc and argv after the known arguments have been processed. This is slightly different from the Python argparse.ArgumentParser.parse_known_args: if the delimiter is not found, it will not remove the arguments that it recognizes. To distinguish this parsers options from user arguments, use the syntax: More...
template<typename... Args>
arg_result	parse_args (Args &&... args)
arg_result	parse (int argc, char **argv, int verbose_level=0)
arg_result	parse (const std::vector< std::string > &_args, int verbose_level=0)
	This is the primary function for parsing the command line arguments. This is where the map of the options is built and the loop over the arguments is performed. More...
argument &	enable_help ()
	Add a help command. More...
bool	exists (const std::string &name) const
	Returns whether or not an option was found in the arguments. Only useful after a call to parse or parse_known_args. More...
template<typename T >
T	get (const std::string &name)
	Get the value(s) associated with an argument. If option, it should be used in conjunction with exists(name). Only useful after a call to parse or parse_known_args. More...
int64_t	get_count (const std::string &name)
int64_t	get_positional_count () const
template<typename ErrorFuncT >
void	on_error (ErrorFuncT &&_func)
void	set_help_width (int _v)

Static Public Member Functions
static int64_t	get_count (argument &a)

Detailed Description

Definition at line 323 of file argparse.hpp.

Member Typedef Documentation

action_func_t

using tim::argparse::argument_parser::action_func_t = std::function<void(this_type&)>

Definition at line 330 of file argparse.hpp.

action_pair_t

using tim::argparse::argument_parser::action_pair_t = std::pair<bool_func_t, action_func_t>

Definition at line 331 of file argparse.hpp.

bool_func_t

using tim::argparse::argument_parser::bool_func_t = std::function<bool(this_type&)>

Definition at line 329 of file argparse.hpp.

error_func_t

using tim::argparse::argument_parser::error_func_t = std::function<void(this_type&, arg_result&)>

Definition at line 332 of file argparse.hpp.

known_args_t

using tim::argparse::argument_parser::known_args_t = std::tuple<arg_result, int, char**>

Definition at line 333 of file argparse.hpp.

result_type

using tim::argparse::argument_parser::result_type = arg_result

Definition at line 328 of file argparse.hpp.

strset_t

using tim::argparse::argument_parser::strset_t = std::set<std::string>

Definition at line 335 of file argparse.hpp.

strvec_t

using tim::argparse::argument_parser::strvec_t = std::vector<std::string>

Definition at line 334 of file argparse.hpp.

this_type

using tim::argparse::argument_parser::this_type = argument_parser

Definition at line 327 of file argparse.hpp.

Constructor & Destructor Documentation

argument_parser()

tim::argparse::argument_parser::argument_parser ( std::string  desc )

inline

Definition at line 630 of file argparse.hpp.

    : m_desc(std::move(desc))
    {}

Member Function Documentation

add_action() [1/2]

template<typename BoolFuncT , typename ActionFuncT >

this_type & tim::argparse::argument_parser::add_action ( BoolFuncT &&  _b, ActionFuncT &  _act  )

inline

Definition at line 731 of file argparse.hpp.

    {
        m_actions.push_back(
            { std::forward<BoolFuncT>(_b), std::forward<ActionFuncT>(_act) });
        return *this;
    }

add_action() [2/2]

template<typename ActionFuncT >

this_type & tim::argparse::argument_parser::add_action ( const std::string &  _name, ActionFuncT &  _act  )

inline

Definition at line 741 of file argparse.hpp.

    {
        auto _b = [=](this_type& p) { return p.exists(_name); };
        m_actions.push_back({ _b, std::forward<ActionFuncT>(_act) });
        return *this;
    }

References exists().

add_argument() [1/3]

argument & tim::argparse::argument_parser::add_argument ( )

inline

Definition at line 636 of file argparse.hpp.

    {
        m_arguments.push_back({});
        m_arguments.back().m_index = static_cast<int>(m_arguments.size()) - 1;
        return m_arguments.back();
    }

Referenced by tim::tsettings< Tp, Vp >::add_argument(), add_argument(), enable_help(), and tim::for().

add_argument() [2/3]

argument & tim::argparse::argument_parser::add_argument ( const std::initializer_list< std::string > &  _names, const std::string &  desc, bool  req = false  )

inline

Definition at line 645 of file argparse.hpp.

    {
        return add_argument().names(_names).description(desc).required(req);
    }

References add_argument(), tim::argparse::argument_parser::argument::description(), tim::argparse::argument_parser::argument::names(), and tim::argparse::argument_parser::argument::required().

add_argument() [3/3]

argument & tim::argparse::argument_parser::add_argument ( const std::vector< std::string > &  _names, const std::string &  desc, bool  req = false  )

inline

Definition at line 653 of file argparse.hpp.

    {
        return add_argument().names(_names).description(desc).required(req);
    }

References add_argument(), tim::argparse::argument_parser::argument::description(), tim::argparse::argument_parser::argument::names(), and tim::argparse::argument_parser::argument::required().

add_positional_argument()

argument & tim::argparse::argument_parser::add_positional_argument ( const std::string &  _name )

inline

Definition at line 661 of file argparse.hpp.

    {
        m_positional_arguments.push_back({});
        auto& _entry = m_positional_arguments.back();
        _entry.name(_name);
        _entry.count(1);
        _entry.m_index = m_positional_arguments.size();
        return _entry;
    }

enable_help()

argument & tim::argparse::argument_parser::enable_help ( )

inline

Add a help command.

Definition at line 871 of file argparse.hpp.

    {
        m_help_enabled = true;
        return add_argument()
            .names({ "-h", "-?", "--help" })
            .description("Shows this page")
            .count(0);
    }

References add_argument(), tim::description(), and tim::argparse::argument_parser::argument::names().

exists()

bool tim::argparse::argument_parser::exists ( const std::string &  name ) const

inline

Returns whether or not an option was found in the arguments. Only useful after a call to parse or parse_known_args.

int main(int argc, char** argv)
{
    argument_parser p{ argv[0] };
    p.add_argument()
        .names({ "-h", "--help"})
        .description("Help message")
        .count(0);
 
    auto ec = p.parse(argc, argv);
    if(ec)
    {
        std::cerr << "Error: " << ec << std::endl;
        exit(EXIT_FAILURE);
    }
 
    if(p.exists("help"))
    {
        p.print_help();
        exit(EXIT_FAILURE);
    }
 
    // ...
}

Definition at line 912 of file argparse.hpp.

    {
        std::string n = helpers::ltrim(
            name, [](int c) -> bool { return c != static_cast<int>('-'); });
        auto itr = m_name_map.find(n);
        if(itr != m_name_map.end())
            return m_arguments[static_cast<size_t>(itr->second)].m_found;
        return false;
    }

Referenced by add_action(), and parse_known_args().

get() [1/3]

template<typename Tp >

arg_result tim::argparse::argument_parser::get ( const std::string &  _name, Tp &  _value  )

inline

Definition at line 689 of file argparse.hpp.

    {
        // loop over parsed positional args
        for(size_t i = 0; i < m_positional_values.size(); ++i)
        {
            if(i >= m_positional_arguments.size())
                break;
 
            // loop over added positional args
            auto& itr = m_positional_arguments.at(i);
            for(auto& nitr : itr.m_names)
            {
                if(nitr == _name)
                    return get(i, _value);
            }
        }
 
        // not found, check if required
        for(auto& itr : m_positional_arguments)
        {
            for(auto& nitr : itr.m_names)
            {
                if(nitr == _name)
                {
                    if(itr.m_default &&
                       itr.m_default_tidx == std::type_index{ typeid(decay_t<Tp>) })
                        _value = (*static_cast<Tp*>(itr.m_default));
                    else if(itr.m_required)
                        return arg_result{
                            _name + " not parsed from the command line (required)"
                        };
                    return arg_result{};
                }
            }
        }
 
        return arg_result{ _name + " is not a named positional argument" };
    }

References get().

get() [2/3]

template<typename T >

T tim::argparse::argument_parser::get ( const std::string &  name )

inline

Get the value(s) associated with an argument. If option, it should be used in conjunction with exists(name). Only useful after a call to parse or parse_known_args.

Template Parameters

T	Data type to convert the argument into

Parameters

[in]

name

An identifier of the option

int main(int argc, char** argv)
{
    argument_parser p{ argv[0] };
    p.add_argument()
        .names({ "-n", "--iterations"})
        .description("Number of iterations")
        .count(1);
 
    // ... etc.
 
    auto nitr = p.get<size_t>("iteration");
 
    // ... etc.
}

Definition at line 950 of file argparse.hpp.

    {
        auto itr = m_name_map.find(name);
        if(itr != m_name_map.end())
            return m_arguments[static_cast<size_t>(itr->second)].get<T>();
        return T{};
    }

get() [3/3]

template<typename Tp >

arg_result tim::argparse::argument_parser::get ( size_t  _idx, Tp &  _value  )

inline

Definition at line 674 of file argparse.hpp.

    {
        if(m_positional_values.find(_idx) == m_positional_values.end())
            return arg_result{ "Positional value not found at index " +
                               std::to_string(_idx) };
        if(_idx >= m_positional_arguments.size())
            return arg_result{ "No positional argument was specified for index " +
                               std::to_string(_idx) };
        _value = m_positional_arguments.at(_idx).get<Tp>();
        return arg_result{};
    }

Referenced by tim::description(), get(), tim::component::network_stats::get_interfaces(), and tim::settings::parse().

get_count() [1/2]

static int64_t tim::argparse::argument_parser::get_count ( argument &  a )

inlinestatic

Definition at line 974 of file argparse.hpp.

{ return a.m_values.size(); }

get_count() [2/2]

int64_t tim::argparse::argument_parser::get_count ( const std::string &  name )

inline

Definition at line 960 of file argparse.hpp.

    {
        auto itr = m_name_map.find(name);
        if(itr != m_name_map.end())
            return m_arguments[static_cast<size_t>(itr->second)].size();
        return 0;
    }

get_positional_count()

int64_t tim::argparse::argument_parser::get_positional_count ( ) const

inline

Definition at line 970 of file argparse.hpp.

{ return m_positional_values.size(); }

on_error()

template<typename ErrorFuncT >

void tim::argparse::argument_parser::on_error ( ErrorFuncT &&  _func )

inline

Definition at line 979 of file argparse.hpp.

    {
        on_error_sfinae(std::forward<ErrorFuncT>(_func), 0);
    }

parse() [1/2]

arg_result tim::argparse::argument_parser::parse	(	const std::vector< std::string > &	args,
		int	verb = 0
	)

This is the primary function for parsing the command line arguments. This is where the map of the options is built and the loop over the arguments is performed.

Parameters

[in]	args	Array of strings (i.e. command-line arguments)
[in]	verb	Verbosity

Definition at line 375 of file argparse.cpp.

{
    if(verbose_level > 0)
    {
        std::cerr << "[argparse::parse]> parsing '";
        for(const auto& itr : _args)
            std::cerr << itr << " ";
        std::cerr << "'" << '\n';
    }
 
    for(auto& a : m_arguments)
        a.m_callback(a.m_default);
    for(auto& a : m_positional_arguments)
        a.m_callback(a.m_default);
 
    using argmap_t = std::map<std::string, argument*>;
 
    argmap_t   m_arg_map = {};
    arg_result err;
    int        argc = _args.size();
    // the set of options which use a single leading dash but are longer than
    // one character, e.g. -LS ...
    std::set<std::string> long_short_opts;
    if(_args.size() > 1)
    {
        auto is_leading_dash = [](int c) -> bool { return c != static_cast<int>('-'); };
        // build name map
        for(auto& a : m_arguments)
        {
            for(auto& n : a.m_names)
            {
                auto        nleading_dash = helpers::lcount(n, is_leading_dash);
                std::string name          = helpers::ltrim(n, is_leading_dash);
                if(name.empty())
                    continue;
                if(m_name_map.find(name) != m_name_map.end())
                    return arg_result("Duplicate of argument name: " + n);
                m_name_map[name] = a.m_index;
                m_arg_map[name]  = &a;
                if(nleading_dash == 1 && name.length() > 1)
                    long_short_opts.insert(name);
            }
            if(a.m_position >= 0 || a.m_position == argument::Position::LastArgument)
                m_positional_map.at(a.m_position) = a.m_index;
        }
 
        m_bin = _args.at(0);
 
        // parse
        std::string current_arg;
        size_t      arg_len;
        for(int argv_index = 1; argv_index < argc; ++argv_index)
        {
            current_arg = _args.at(argv_index);
            arg_len     = current_arg.length();
            if(arg_len == 0)
                continue;
            if(argv_index == argc - 1 &&
               m_positional_map.find(argument::Position::LastArgument) !=
                   m_positional_map.end())
            {
                err          = end_argument();
                arg_result b = err;
                err          = add_value(current_arg, argument::Position::LastArgument);
                if(b)
                    return b;
                // return (m_error_func(*this, b), b);
                if(err)
                    return (m_error_func(*this, err), err);
                continue;
            }
 
            // count number of leading dashes
            auto nleading_dash = helpers::lcount(current_arg, is_leading_dash);
            // ignores the case if the arg is just a '-'
            // look for -a (short) or --arg (long) args
            bool is_arg = (nleading_dash > 0 && arg_len > 1 && arg_len != nleading_dash)
                              ? true
                              : false;
 
            if(is_arg && !helpers::is_numeric(current_arg))
            {
                err = end_argument();
                if(err)
                    return (m_error_func(*this, err), err);
 
                auto name   = current_arg.substr(nleading_dash);
                auto islong = (nleading_dash > 1 || long_short_opts.count(name) > 0);
                err         = begin_argument(name, islong, argv_index);
                if(err)
                    return (m_error_func(*this, err), err);
            }
            else if(current_arg.length() > 0)
            {
                // argument value
                err = add_value(current_arg, argv_index);
                if(err)
                    return (m_error_func(*this, err), err);
            }
        }
    }
 
    // return the help
    if(m_help_enabled && exists("help"))
        return arg_result("help requested");
 
    err = end_argument();
    if(err)
        return (m_error_func(*this, err), err);
 
    // check requirements
    for(auto& a : m_arguments)
    {
        if(a.m_required && !a.m_found)
        {
            return arg_result("Required argument not found: " + a.m_names.at(0));
        }
        if(a.m_position >= 0 && argc >= a.m_position && !a.m_found)
        {
            return arg_result("argument " + a.m_names.at(0) + " expected in position " +
                              std::to_string(a.m_position));
        }
    }
 
    // check requirements
    for(auto& a : m_positional_arguments)
    {
        if(a.m_required && !a.m_found)
            return arg_result("Required argument not found: " + a.m_names.at(0));
    }
 
    // check all the counts have been satisfied
    for(auto& a : m_arguments)
    {
        if(a.m_found && a.m_default == nullptr)
        {
            auto cnt_err = check_count(a);
            if(cnt_err)
                return cnt_err;
        }
    }
 
    // execute the global actions
    for(auto& itr : m_actions)
    {
        if(itr.first(*this))
            itr.second(*this);
    }
 
    // execute the argument-specific actions
    for(auto& itr : m_arg_map)
    {
        if(exists(itr.first))
            itr.second->execute_actions(*this);
    }
 
    return arg_result{};
}

References tim::_args.

parse() [2/2]

arg_result tim::argparse::argument_parser::parse ( int  argc, char **  argv, int  verbose_level = 0  )

inline

Definition at line 847 of file argparse.hpp.

    {
        std::vector<std::string> _args;
        _args.reserve(argc);
        for(int i = 0; i < argc; ++i)
            _args.emplace_back((const char*) argv[i]);
        return parse(_args, verbose_level);
    }

References tim::_args, tim::argv, and parse().

Referenced by parse(), parse_args(), and parse_known_args().

parse_args()

template<typename... Args>

arg_result tim::argparse::argument_parser::parse_args ( Args &&...  args )

inline

Definition at line 840 of file argparse.hpp.

    {
        return parse(std::forward<Args>(args)...);
    }

References parse().

parse_known_args() [1/4]

arg_result tim::argparse::argument_parser::parse_known_args ( int *  argc, char ***  argv, const std::string &  delim = "--", int  verb = 0  )

inline

This variant calls parse_known_args and replaces argc and argv with the argv[0] + anything after delimiter (if the delimiter is provided). If the delimiter does not exist, argc and argv are unchanged.

Parameters

[in,out]	argc	Pointer to number of arguments (i.e. # of command-line args)
[in,out]	argv	Pointer to array of strings (i.e. command-line)
[in]	delim	Delimiter which separates this argparser's opts from user's arguments
[in]	verb	verbosity

Definition at line 774 of file argparse.hpp.

    {
        strvec_t args{};
        return parse_known_args(argc, argv, args, _delim, verbose_level);
    }

References tim::argv, and parse_known_args().

parse_known_args() [2/4]

TIMEMORY_UTILITY_INLINE argument_parser::arg_result tim::argparse::argument_parser::parse_known_args	(	int *	argc,
		char ***	argv,
		strvec_t &	_args,
		const std::string &	_delim = "--",
		int	verbose_level = 0
	)

Definition at line 269 of file argparse.cpp.

{
    // check for help flag
    auto help_check = [&](int _argc, char** _argv) {
        strset_t help_args = { "-h", "--help", "-?" };
        auto     _help_req = (exists("help") ||
                          (_argc > 1 && help_args.find(_argv[1]) != help_args.end()));
        if(_help_req && !exists("help"))
        {
            for(auto hitr : help_args)
            {
                auto hstr = hitr.substr(hitr.find_first_not_of('-'));
                auto itr  = m_name_map.find(hstr);
                if(itr != m_name_map.end())
                    m_arguments[static_cast<size_t>(itr->second)].m_found = true;
            }
        }
        return _help_req;
    };
 
    // check for a dash in th command line
    bool _pdash = false;
    for(int i = 1; i < *argc; ++i)
    {
        if((*argv)[i] == std::string("--"))
            _pdash = true;
    }
 
    // parse the known args and get the remaining argc/argv
    auto _pargs = parse_known_args(*argc, *argv, _args, _delim, verbose_level);
    auto _perrc = std::get<0>(_pargs);
    auto _pargc = std::get<1>(_pargs);
    auto _pargv = std::get<2>(_pargs);
 
    // check if help was requested before the dash (if dash exists)
    if(help_check((_pdash) ? 0 : _pargc, _pargv))
        return arg_result{ "help requested" };
 
    // assign the argc and argv
    *argc = _pargc;
    *argv = _pargv;
 
    return _perrc;
}

References tim::_args, tim::argv, exists(), and parse_known_args().

parse_known_args() [3/4]

arg_result tim::argparse::argument_parser::parse_known_args ( int  argc, char **  argv, const std::string &  delim = "--", int  verb = 0  )

inline

Basic variant of parse_known_args which does not replace argc/argv and does not provide an array of strings that it processed.

Parameters

[in,out]	argc	Number of arguments (i.e. # of command-line args)
[in,out]	argv	Array of strings (i.e. command-line)
[in]	delim	Delimiter which separates this argparser's opts from user's arguments
[in]	verb	verbosity

Definition at line 765 of file argparse.hpp.

    {
        strvec_t _args{};
        return parse_known_args(argc, argv, _args, _delim, verbose_level);
    }

References tim::_args, tim::argv, and parse_known_args().

Referenced by parse_known_args().

parse_known_args() [4/4]

arg_result tim::argparse::argument_parser::parse_known_args	(	int	argc,
		char **	argv,
		strvec_t &	args,
		const std::string &	delim = "--",
		int	verb = 0
	)

Parses all options until argv[argc-1] or delimiter is found. Returns a tuple containing an argument error object (operator bool will return true if there was an error) and the new argc and argv after the known arguments have been processed. This is slightly different from the Python argparse.ArgumentParser.parse_known_args: if the delimiter is not found, it will not remove the arguments that it recognizes. To distinguish this parsers options from user arguments, use the syntax:

Parameters

[in,out]	argc	Number of arguments (i.e. # of command-line args)
[in,out]	argv	Array of strings (i.e. command-line)
[in,out]	args	Array of strings processed by this parser
[in]	delim	Delimiter which separates this argparser's opts from user's arguments
[in]	verb	verbosity

./<CMD> <PARSER_OPTIONS> – <USER_ARGS>

And std::get<1>(...) on the return value will be the new argc. and std::get<2>(...) on the return value will be the new argv. Other valid usages:

./<CMD> –help (will report this parser's help message) ./<CMD> – –help (will report the applications help message, if supported) ./<CMD> <USER_ARGS> ./<CMD> <PARSER_OPTIONS> ./<CMD> <PARSER_OPTIONS> <USER_ARGS> (intermixed)

will not remove any of the known options. In other words, this will remove all arguments after <CMD> until the first "--" if reached and everything after the "--" will be placed in argv[1:]

Definition at line 316 of file argparse.cpp.

{
    int    _cmdc = argc;  // the argc after known args removed
    char** _cmdv = argv;  // the argv after known args removed
    // _cmdv and argv are same pointer unless delimiter is found
 
    if(argc > 0)
    {
        m_bin = std::string((const char*) argv[0]);
        _args.push_back(std::string((const char*) argv[0]));
    }
 
    for(int i = 1; i < argc; ++i)
    {
        std::string _arg = argv[i];
        if(_arg == _delim)
        {
            _cmdc        = argc - i;
            _cmdv        = new char*[_cmdc + 1];
            _cmdv[_cmdc] = nullptr;
            _cmdv[0]     = helpers::strdup(argv[0]);
            int k        = 1;
            for(int j = i + 1; j < argc; ++j, ++k)
                _cmdv[k] = helpers::strdup(argv[j]);
            break;
        }
        else
        {
            _args.push_back(std::string((const char*) argv[i]));
        }
    }
 
    auto cmd_string = [](int _ac, char** _av) {
        std::stringstream ss;
        for(int i = 0; i < _ac; ++i)
            ss << _av[i] << " ";
        return ss.str();
    };
 
    if((_cmdc > 0 && verbose_level > 0) || verbose_level > 1)
        std::cerr << "\n";
 
    if(verbose_level > 1)
    {
        std::cerr << "[original]> " << cmd_string(argc, argv) << std::endl;
        std::cerr << "[cfg-args]> ";
        for(auto& itr : _args)
            std::cerr << itr << " ";
        std::cerr << std::endl;
    }
 
    if(_cmdc > 0 && verbose_level > 0)
        std::cerr << "[command]>  " << cmd_string(_cmdc, _cmdv) << "\n\n";
 
    return known_args_t{ parse(_args, verbose_level), _cmdc, _cmdv };
}

References tim::_args, tim::argv, parse(), and strdup().

print_help()

TIMEMORY_UTILITY_INLINE void tim::argparse::argument_parser::print_help

(

const std::string &

_extra = ""

)

Definition at line 109 of file argparse.cpp.

{
    std::stringstream _usage;
    if(!m_desc.empty())
        _usage << "[" << m_desc << "] ";
    _usage << "Usage: " << m_bin;
 
    std::cerr << _usage.str();
 
    std::stringstream _sshort_desc;
    auto              _indent = _usage.str().length() + 2;
    size_t            _ncnt   = 0;
    for(auto& a : m_arguments)
    {
        std::string name = a.m_names.at(0);
        if(name.empty() || name.find_first_of('-') > name.find_first_not_of(" -"))
            continue;
        // select the first long option
        for(size_t n = 1; n < a.m_names.size(); ++n)
        {
            if(name.find("--") == 0)
                break;
            else if(a.m_names.at(n).find("--") == 0)
            {
                name = a.m_names.at(n);
                break;
            }
        }
        if(name.length() > 0)
        {
            if(_ncnt++ > 0)
                _sshort_desc << "\n " << std::setw(_indent) << " " << name;
            else
                _sshort_desc << " " << name;
 
            _sshort_desc << " (";
            if(a.m_count != argument::Count::ANY)
                _sshort_desc << "count: " << a.m_count;
            else if(a.m_min_count != argument::Count::ANY)
                _sshort_desc << "min: " << a.m_min_count;
            else if(a.m_max_count != argument::Count::ANY)
                _sshort_desc << "max: " << a.m_max_count;
            else
                _sshort_desc << "count: unlimited";
            if(!a.m_dtype.empty())
                _sshort_desc << ", dtype: " << a.m_dtype;
            else if(a.m_count == 0 ||
                    (a.m_count == argument::Count::ANY && a.m_max_count == 1))
                _sshort_desc << ", dtype: bool" << a.m_dtype;
            _sshort_desc << ")";
        }
    }
 
    std::string _short_desc;
    if(!_sshort_desc.str().empty())
    {
        _short_desc.append("[" + _sshort_desc.str());
        std::stringstream _tmp;
        _tmp << "\n" << std::setw(_indent) << "]";
        _short_desc.append(_tmp.str());
    }
 
    if(m_positional_arguments.empty())
    {
        std::cerr << " " << _short_desc << " " << _extra << std::endl;
    }
    else
    {
        std::cerr << " " << _short_desc;
        if(!_short_desc.empty())
            std::cerr << "\n" << std::setw(_indent - 2) << " ";
        for(auto& itr : m_positional_arguments)
        {
            std::cerr << " " << helpers::ltrim(itr.m_names.at(0), [](int c) -> bool {
                return c != static_cast<int>('-');
            });
        }
 
        int current = 0;
        for(auto& v : m_positional_map)
        {
            if(v.first != argument::Position::LastArgument)
            {
                for(; current < v.first; ++current)
                    std::cerr << " [" << current << "]";
                std::cerr << " ["
                          << helpers::ltrim(
                                 m_arguments[static_cast<size_t>(v.second)].m_names.at(0),
                                 [](int c) -> bool { return c != static_cast<int>('-'); })
                          << "]";
            }
            else
            {
                std::cerr << " ... ["
                          << helpers::ltrim(
                                 m_arguments[static_cast<size_t>(v.second)].m_names.at(0),
                                 [](int c) -> bool { return c != static_cast<int>('-'); })
                          << "]";
            }
        }
        std::cerr << " " << _extra << std::endl;
    }
 
    std::cerr << "\nOptions:" << std::endl;
    for(auto& a : m_arguments)
    {
        std::string name = a.m_names.at(0);
        for(size_t n = 1; n < a.m_names.size(); ++n)
            name.append(", " + a.m_names[n]);
        std::stringstream ss;
        ss << name;
        if(a.m_choices.size() > 0)
        {
            ss << " [";
            auto itr = a.m_choices.begin();
            ss << " " << *itr++;
            for(; itr != a.m_choices.end(); ++itr)
                ss << " | " << *itr;
            ss << " ] ";
        }
        std::stringstream prefix;
        prefix << "    " << std::setw(m_width) << std::left << ss.str();
        std::cerr << std::left << prefix.str();
 
        auto desc = a.m_desc;
        if(ss.str().length() >= static_cast<size_t>(m_width))
            desc = std::string("\n%{NEWLINE}%") + desc;
 
        {
            // replace %{INDENT}% with indentation
            const std::string indent_key = "%{INDENT}%";
            const auto        npos       = std::string::npos;
            auto              pos        = npos;
            std::stringstream indent;
            indent << std::setw(prefix.str().length()) << "";
            while((pos = desc.find(indent_key)) != npos)
                desc = desc.replace(pos, indent_key.length(), indent.str());
        }
 
        {
            // replace %{NEWLINE}% with indentation
            const std::string indent_key = "%{NEWLINE}%";
            const auto        npos       = std::string::npos;
            auto              pos        = npos;
            std::stringstream indent;
            indent << std::setw(m_width + 5) << "";
            while((pos = desc.find(indent_key)) != npos)
                desc = desc.replace(pos, indent_key.length(), indent.str());
        }
 
        std::cerr << " " << std::setw(m_width) << desc;
 
        if(a.m_required)
            std::cerr << " (Required)";
        std::cerr << std::endl;
    }
    std::cerr << '\n';
}

Referenced by tim::on_error().

set_help_width()

void tim::argparse::argument_parser::set_help_width ( int  _v )

inline

Definition at line 986 of file argparse.hpp.

{ m_width = _v; }

---

The documentation for this struct was generated from the following files:

• timemory/utility/argparse.hpp
• timemory/utility/argparse.cpp