CLI::App Class Reference

Creates a command line program, with very few defaults. More...

#include <CLI11.hpp>

Inheritance diagram for CLI::App:

Collaboration diagram for CLI::App:

Public Member Functions
void	_move_option (Option *opt, App *app)
	function that could be used by subclasses of App to shift options around into subcommands
Basic
	App (std::string app_description="", std::string app_name="")
	Create a new program. Pass in the same arguments as main(), along with a help string.
	App (const App &)=delete
App &	operator= (const App &)=delete
virtual	~App ()=default
	virtual destructor
App *	callback (std::function< void()> app_callback)
App *	final_callback (std::function< void()> app_callback)
App *	parse_complete_callback (std::function< void()> pc_callback)
App *	preparse_callback (std::function< void(std::size_t)> pp_callback)
App *	name (std::string app_name="")
	Set a name for the app (empty will use parser to set the name)
App *	alias (std::string app_name)
	Set an alias for the app.
App *	allow_extras (bool allow=true)
	Remove the error when extras are left over on the command line.
App *	required (bool require=true)
	Remove the error when extras are left over on the command line.
App *	disabled (bool disable=true)
	Disable the subcommand or option group.
App *	disabled_by_default (bool disable=true)
	Set the subcommand to be disabled by default, so on clear(), at the start of each parse it is disabled.
App *	enabled_by_default (bool enable=true)
App *	immediate_callback (bool immediate=true)
	Set the subcommand callback to be executed immediately on subcommand completion.
App *	validate_positionals (bool validate=true)
	Set the subcommand to validate positional arguments before assigning.
App *	allow_config_extras (bool allow=true)
	ignore extras in config files
App *	allow_config_extras (config_extras_mode mode)
	ignore extras in config files
App *	prefix_command (bool allow=true)
	Do not parse anything after the first unrecognized option and return.
App *	ignore_case (bool value=true)
	Ignore case. Subcommands inherit value.
App *	allow_windows_style_options (bool value=true)
App *	positionals_at_end (bool value=true)
	Specify that the positional arguments are only at the end of the sequence.
App *	configurable (bool value=true)
	Specify that the subcommand can be triggered by a config file.
App *	ignore_underscore (bool value=true)
	Ignore underscore. Subcommands inherit value.
App *	formatter (std::shared_ptr< FormatterBase > fmt)
	Set the help formatter.
App *	formatter_fn (std::function< std::string(const App *, std::string, AppFormatMode)> fmt)
	Set the help formatter.
App *	config_formatter (std::shared_ptr< Config > fmt)
	Set the config formatter.
bool	parsed () const
	Check to see if this subcommand was parsed, true only if received on command line.
OptionDefaults *	option_defaults ()
	Get the OptionDefault object, to set option defaults.
Subcommmands
App *	add_subcommand (std::string subcommand_name="", std::string subcommand_description="")
	Add a subcommand. Inherits INHERITABLE and OptionDefaults, and help flag.
App *	add_subcommand (CLI::App_p subcom)
	Add a previously created app as a subcommand.
bool	remove_subcommand (App *subcom)
	Removes a subcommand from the App. Takes a subcommand pointer. Returns true if found and removed.
App *	get_subcommand (const App *subcom) const
App *	get_subcommand (std::string subcom) const
	Check to see if a subcommand is part of this command (text version)
App *	get_subcommand (int index=0) const
	Get a pointer to subcommand by index.
CLI::App_p	get_subcommand_ptr (App *subcom) const
	Check to see if a subcommand is part of this command and get a shared_ptr to it.
CLI::App_p	get_subcommand_ptr (std::string subcom) const
	Check to see if a subcommand is part of this command (text version)
CLI::App_p	get_subcommand_ptr (int index=0) const
	Get an owning pointer to subcommand by index.
App *	get_option_group (std::string group_name) const
	Check to see if an option group is part of this App.
std::size_t	count () const
std::size_t	count_all () const
App *	group (std::string group_name)
	Changes the group membership.
App *	require_subcommand ()
	The argumentless form of require subcommand requires 1 or more subcommands.
App *	require_subcommand (int value)
App *	require_subcommand (std::size_t min, std::size_t max)
App *	require_option ()
	The argumentless form of require option requires 1 or more options be used.
App *	require_option (int value)
App *	require_option (std::size_t min, std::size_t max)
App *	fallthrough (bool value=true)
	operator bool () const
Extras for subclassing
virtual void	pre_callback ()
Post parsing
std::size_t	count (std::string option_name) const
	Counts the number of times the given option was passed.
std::vector< App * >	get_subcommands () const
std::vector< const App * >	get_subcommands (const std::function< bool(const App *)> &filter) const
std::vector< App * >	get_subcommands (const std::function< bool(App *)> &filter)
bool	got_subcommand (const App *subcom) const
	Check to see if given subcommand was selected.
bool	got_subcommand (std::string subcommand_name) const
	Check with name instead of pointer to see if subcommand was selected.
App *	excludes (Option *opt)
	Sets excluded options for the subcommand.
App *	excludes (App *app)
	Sets excluded subcommands for the subcommand.
App *	needs (Option *opt)
App *	needs (App *app)
bool	remove_excludes (Option *opt)
	Removes an option from the excludes list of this subcommand.
bool	remove_excludes (App *app)
	Removes a subcommand from the excludes list of this subcommand.
bool	remove_needs (Option *opt)
	Removes an option from the needs list of this subcommand.
bool	remove_needs (App *app)
	Removes a subcommand from the needs list of this subcommand.
Getters
std::shared_ptr< FormatterBase >	get_formatter () const
	Access the formatter.
std::shared_ptr< Config >	get_config_formatter () const
	Access the config formatter.
std::shared_ptr< ConfigBase >	get_config_formatter_base () const
	Access the config formatter as a configBase pointer.
std::string	get_description () const
	Get the app or subcommand description.
App *	description (std::string app_description)
	Set the description of the app.
std::vector< const Option * >	get_options (const std::function< bool(const Option *)> filter={}) const
	Get the list of options (user facing function, so returns raw pointers), has optional filter function.
std::vector< Option * >	get_options (const std::function< bool(Option *)> filter={})
	Non-const version of the above.
Option *	get_option_no_throw (std::string option_name) noexcept
	Get an option by name (noexcept non-const version)
const Option *	get_option_no_throw (std::string option_name) const noexcept
	Get an option by name (noexcept const version)
const Option *	get_option (std::string option_name) const
	Get an option by name.
Option *	get_option (std::string option_name)
	Get an option by name (non-const version)
const Option *	operator[] (const std::string &option_name) const
	Shortcut bracket operator for getting a pointer to an option.
const Option *	operator[] (const char *option_name) const
	Shortcut bracket operator for getting a pointer to an option.
bool	get_ignore_case () const
	Check the status of ignore_case.
bool	get_ignore_underscore () const
	Check the status of ignore_underscore.
bool	get_fallthrough () const
	Check the status of fallthrough.
bool	get_allow_windows_style_options () const
	Check the status of the allow windows style options.
bool	get_positionals_at_end () const
	Check the status of the allow windows style options.
bool	get_configurable () const
	Check the status of the allow windows style options.
const std::string &	get_group () const
	Get the group of this subcommand.
std::string	get_footer () const
	Generate and return the footer.
std::size_t	get_require_subcommand_min () const
	Get the required min subcommand value.
std::size_t	get_require_subcommand_max () const
	Get the required max subcommand value.
std::size_t	get_require_option_min () const
	Get the required min option value.
std::size_t	get_require_option_max () const
	Get the required max option value.
bool	get_prefix_command () const
	Get the prefix command status.
bool	get_allow_extras () const
	Get the status of allow extras.
bool	get_required () const
	Get the status of required.
bool	get_disabled () const
	Get the status of disabled.
bool	get_immediate_callback () const
	Get the status of disabled.
bool	get_disabled_by_default () const
	Get the status of disabled by default.
bool	get_enabled_by_default () const
	Get the status of disabled by default.
bool	get_validate_positionals () const
	Get the status of validating positionals.
config_extras_mode	get_allow_config_extras () const
	Get the status of allow extras.
Option *	get_help_ptr ()
	Get a pointer to the help flag.
const Option *	get_help_ptr () const
	Get a pointer to the help flag. (const)
const Option *	get_help_all_ptr () const
	Get a pointer to the help all flag. (const)
Option *	get_config_ptr ()
	Get a pointer to the config option.
const Option *	get_config_ptr () const
	Get a pointer to the config option. (const)
App *	get_parent ()
	Get the parent of this subcommand (or nullptr if master app)
const App *	get_parent () const
	Get the parent of this subcommand (or nullptr if master app) (const version)
const std::string &	get_name () const
	Get the name of the current app.
const std::vector< std::string > &	get_aliases () const
	Get the aliases of the current app.
App *	clear_aliases ()
	clear all the aliases of the current App
std::string	get_display_name () const
	Get a display name for an app.
bool	check_name (std::string name_to_check) const
	Check the name, case insensitive and underscore insensitive if set.
std::vector< std::string >	get_groups () const
	Get the groups available directly from this option (in order)
const std::vector< Option * > &	parse_order () const
	This gets a vector of pointers with the original parse order.
std::vector< std::string >	remaining (bool recurse=false) const
	This returns the missing options from the current subcommand.
std::vector< std::string >	remaining_for_passthrough (bool recurse=false) const
	This returns the missing options in a form ready for processing by another command line program.
std::size_t	remaining_size (bool recurse=false) const
	This returns the number of remaining options, minus the – separator.

Protected Member Functions
	App (std::string app_description, std::string app_name, App *parent)
	Special private constructor for subcommand.
void	_validate () const
void	_configure ()
void	run_callback (bool final_mode=false)
	Internal function to run (App) callback, bottom up.
bool	_valid_subcommand (const std::string &current, bool ignore_used=true) const
	Check to see if a subcommand is valid. Give up immediately if subcommand max has been reached.
detail::Classifier	_recognize (const std::string &current, bool ignore_used_subcommands=true) const
	Selects a Classifier enum based on the type of the current argument.
void	_process_config_file ()
	Read and process a configuration file (main app only)
void	_process_env ()
	Get envname options if not yet passed. Runs on all subcommands.
void	_process_callbacks ()
	Process callbacks. Runs on all subcommands.
void	_process_help_flags (bool trigger_help=false, bool trigger_all_help=false) const
void	_process_requirements ()
	Verify required options and cross requirements. Subcommands too (only if selected).
void	_process ()
	Process callbacks and such.
void	_process_extras ()
	Throw an error if anything is left over and should not be.
void	_process_extras (std::vector< std::string > &args)
void	increment_parsed ()
	Internal function to recursively increment the parsed counter on the current app as well unnamed subcommands.
void	_parse (std::vector< std::string > &args)
	Internal parse function.
void	_parse (std::vector< std::string > &&args)
	Internal parse function.
void	_parse_config (std::vector< ConfigItem > &args)
bool	_parse_single_config (const ConfigItem &item, std::size_t level=0)
	Fill in a single config option.
bool	_parse_single (std::vector< std::string > &args, bool &positional_only)
std::size_t	_count_remaining_positionals (bool required_only=false) const
	Count the required remaining positional arguments.
bool	_has_remaining_positionals () const
	Count the required remaining positional arguments.
bool	_parse_positional (std::vector< std::string > &args, bool haltOnSubcommand)
App *	_find_subcommand (const std::string &subc_name, bool ignore_disabled, bool ignore_used) const noexcept
bool	_parse_subcommand (std::vector< std::string > &args)
bool	_parse_arg (std::vector< std::string > &args, detail::Classifier current_type)
void	_trigger_pre_parse (std::size_t remaining_args)
	Trigger the pre_parse callback if needed.
App *	_get_fallthrough_parent ()
	Get the appropriate parent to fallthrough to which is the first one that has a name or the main app.
const std::string &	_compare_subcommand_names (const App &subcom, const App &base) const
	Helper function to run through all possible comparisons of subcommand names to check there is no overlap.
void	_move_to_missing (detail::Classifier val_type, const std::string &val)
	Helper function to place extra values in the most appropriate position.

Protected Attributes
Basics
std::string	name_ {}
	Subcommand name or program name (from parser if name is empty)
std::string	description_ {}
	Description of the current program/subcommand.
bool	allow_extras_ {false}
	If true, allow extra arguments (ie, don't throw an error). INHERITABLE.
config_extras_mode	allow_config_extras_ {config_extras_mode::ignore}
bool	prefix_command_ {false}
	If true, return immediately on an unrecognized option (implies allow_extras) INHERITABLE.
bool	has_automatic_name_ {false}
	If set to true the name was automatically generated from the command line vs a user set name.
bool	required_ {false}
	If set to true the subcommand is required to be processed and used, ignored for main app.
bool	disabled_ {false}
	If set to true the subcommand is disabled and cannot be used, ignored for main app.
bool	pre_parse_called_ {false}
	Flag indicating that the pre_parse_callback has been triggered.
bool	immediate_callback_ {false}
std::function< void(std::size_t)>	pre_parse_callback_ {}
	This is a function that runs prior to the start of parsing.
std::function< void()>	parse_complete_callback_ {}
	This is a function that runs when parsing has finished.
std::function< void()>	final_callback_ {}
	This is a function that runs when all processing has completed.
Options
OptionDefaults	option_defaults_ {}
	The default values for options, customizable and changeable INHERITABLE.
std::vector< Option_p >	options_ {}
	The list of options, stored locally.
Config
Option *	config_ptr_ {nullptr}
	Pointer to the config option.
std::shared_ptr< Config >	config_formatter_ {new ConfigINI()}
	This is the formatter for help printing. Default provided. INHERITABLE (same pointer)

Subcommands
enum class	startup_mode : char { stable , enabled , disabled }
std::vector< App_p >	subcommands_ {}
	Storage for subcommand list.
bool	ignore_case_ {false}
	If true, the program name is not case sensitive INHERITABLE.
bool	ignore_underscore_ {false}
	If true, the program should ignore underscores INHERITABLE.
bool	fallthrough_ {false}
	Allow subcommand fallthrough, so that parent commands can collect commands after subcommand. INHERITABLE.
bool	allow_windows_style_options_
	Allow '/' for options for Windows like options. Defaults to true on Windows, false otherwise. INHERITABLE.
bool	positionals_at_end_ {false}
	specify that positional arguments come at the end of the argument sequence not inheritable
startup_mode	default_startup {startup_mode::stable}
bool	configurable_ {false}
	if set to true the subcommand can be triggered via configuration files INHERITABLE
bool	validate_positionals_ {false}
	If set to true positional options are validated before assigning INHERITABLE.
App *	parent_ {nullptr}
	A pointer to the parent if this is a subcommand.
std::size_t	parsed_ {0}
	Counts the number of times this command/subcommand was parsed.
std::size_t	require_subcommand_min_ {0}
	Minimum required subcommands (not inheritable!)
std::size_t	require_subcommand_max_ {0}
	Max number of subcommands allowed (parsing stops after this number). 0 is unlimited INHERITABLE.
std::size_t	require_option_min_ {0}
	Minimum required options (not inheritable!)
std::size_t	require_option_max_ {0}
	Max number of options allowed. 0 is unlimited (not inheritable)
std::string	group_ {"Subcommands"}
	The group membership INHERITABLE.
std::vector< std::string >	aliases_ {}
	Alias names for the subcommand.

Parsing
using	missing_t = std::vector<std::pair<detail::Classifier, std::string>>
missing_t	missing_ {}
std::vector< Option * >	parse_order_ {}
	This is a list of pointers to options with the original parse order.
std::vector< App * >	parsed_subcommands_ {}
	This is a list of the subcommands collected, in order.
std::set< App * >	exclude_subcommands_ {}
	this is a list of subcommands that are exclusionary to this one
std::set< Option * >	exclude_options_ {}
std::set< App * >	need_subcommands_ {}
std::set< Option * >	need_options_ {}
void	clear ()
	Reset the parsed data.
void	parse (int argc, const char *const *argv)
void	parse (std::string commandline, bool program_name_included=false)
void	parse (std::vector< std::string > &args)
void	parse (std::vector< std::string > &&args)
	The real work is done here. Expects a reversed vector.
void	failure_message (std::function< std::string(const App *, const Error &e)> function)
	Provide a function to print a help message. The function gets access to the App pointer and error.
int	exit (const Error &e, std::ostream &out=std::cout, std::ostream &err=std::cerr) const
	Print a nice error message and return the exit code.

Help
std::string	footer_ {}
	Footer to put after all options in the help output INHERITABLE.
std::function< std::string()>	footer_callback_ {}
	This is a function that generates a footer to put after all other options in help output.
Option *	help_ptr_ {nullptr}
	A pointer to the help flag if there is one INHERITABLE.
Option *	help_all_ptr_ {nullptr}
	A pointer to the help all flag if there is one INHERITABLE.
std::shared_ptr< FormatterBase >	formatter_ {new Formatter()}
	This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
std::function< std::string(const App *, const Error &e)>	failure_message_ {FailureMessage::simple}
	The error message printing function INHERITABLE.
App *	footer (std::string footer_string)
	Set footer.
App *	footer (std::function< std::string()> footer_function)
	Set footer.
std::string	config_to_str (bool default_also=false, bool write_description=false) const
std::string	help (std::string prev="", AppFormatMode mode=AppFormatMode::Normal) const

Adding options
Option *	add_option (std::string option_name, callback_t option_callback, std::string option_description="", bool defaulted=false, std::function< std::string()> func={})
template<typename AssignTo , typename ConvertTo = AssignTo, enable_if_t<!std::is_const< ConvertTo >::value, detail::enabler > = detail::dummy>
Option *	add_option (std::string option_name, AssignTo &variable, std::string option_description="", bool defaulted=false)
	Add option for assigning to a variable.
template<typename T >
Option *	add_option_function (std::string option_name, const std::function< void(const T &)> &func, std::string option_description="")
	Add option for a callback of a specific type.
Option *	add_option (std::string option_name)
	Add option with no description or variable assignment.
template<typename T , enable_if_t< std::is_const< T >::value &&std::is_constructible< std::string, T >::value, detail::enabler > = detail::dummy>
Option *	add_option (std::string option_name, T &option_description)
	Add option with description but with no variable assignment or callback.
Option *	set_help_flag (std::string flag_name="", const std::string &help_description="")
	Set a help flag, replace the existing one if present.
Option *	set_help_all_flag (std::string help_name="", const std::string &help_description="")
	Set a help all flag, replaced the existing one if present.
Option *	add_flag (std::string flag_name)
	Add a flag with no description or variable assignment.
template<typename T , enable_if_t< std::is_const< T >::value &&std::is_constructible< std::string, T >::value, detail::enabler > = detail::dummy>
Option *	add_flag (std::string flag_name, T &flag_description)
template<typename T , enable_if_t< std::is_integral< T >::value &&!is_bool< T >::value, detail::enabler > = detail::dummy>
Option *	add_flag (std::string flag_name, T &flag_count, std::string flag_description="")
template<typename T , enable_if_t<!is_vector< T >::value &&!std::is_const< T >::value &&(!std::is_integral< T >::value||is_bool< T >::value) &&!std::is_constructible< std::function< void(int)>, T >::value, detail::enabler > = detail::dummy>
Option *	add_flag (std::string flag_name, T &flag_result, std::string flag_description="")
template<typename T , enable_if_t<!std::is_assignable< std::function< void(int64_t)>, T >::value, detail::enabler > = detail::dummy>
Option *	add_flag (std::string flag_name, std::vector< T > &flag_results, std::string flag_description="")
	Vector version to capture multiple flags.
Option *	add_flag_callback (std::string flag_name, std::function< void(void)> function, std::string flag_description="")
	Add option for callback that is triggered with a true flag and takes no arguments.
Option *	add_flag_function (std::string flag_name, std::function< void(int64_t)> function, std::string flag_description="")
	Add option for callback with an integer value.
template<typename T >
Option *	add_set (std::string option_name, T &member, std::set< T > options, std::string option_description="")
	Add set of options (No default, temp reference, such as an inline set) DEPRECATED.
template<typename T >
Option *	add_mutable_set (std::string option_name, T &member, const std::set< T > &options, std::string option_description="")
	Add set of options (No default, set can be changed afterwards - do not destroy the set) DEPRECATED.
template<typename T >
Option *	add_set (std::string option_name, T &member, std::set< T > options, std::string option_description, bool defaulted)
	Add set of options (with default, static set, such as an inline set) DEPRECATED.
template<typename T >
Option *	add_mutable_set (std::string option_name, T &member, const std::set< T > &options, std::string option_description, bool defaulted)
	Add set of options (with default, set can be changed afterwards - do not destroy the set) DEPRECATED.
template<typename T , typename XC = double>
Option *	add_complex (std::string option_name, T &variable, std::string option_description="", bool defaulted=false, std::string label="COMPLEX")
	Add a complex number.
Option *	set_config (std::string option_name="", std::string default_filename="", const std::string &help_message="Read an ini file", bool config_required=false)
	Set a configuration ini file option, or clear it if no name passed.
bool	remove_option (Option *opt)
	Removes an option from the App. Takes an option pointer. Returns true if found and removed.
template<typename T = Option_group>
T *	add_option_group (std::string group_name, std::string group_description="")
	creates an option group as part of the given app

Detailed Description

To use, create a new Program() instance with argc, argv, and a help description. The templated add_option methods make it easy to prepare options. Remember to call .start before starting your program, so that the options can be evaluated and the help option doesn't accidentally run your program.

Definition at line 4614 of file CLI11.hpp.

Member Typedef Documentation

missing_t

using CLI::App::missing_t = std::vector<std::pair<detail::Classifier, std::string>>

protected

Definition at line 4700 of file CLI11.hpp.

Member Enumeration Documentation

startup_mode

enum class CLI::App::startup_mode : char

strongprotected

Enumerator
stable
enabled
disabled

Definition at line 4755 of file CLI11.hpp.

: char { stable, enabled, disabled };

Constructor & Destructor Documentation

App() [1/3]

CLI::App::App ( std::string app_description, std::string app_name, App * parent )

inlineprotected

OptionDefaults

Definition at line 4803 of file CLI11.hpp.

        : name_(std::move(app_name)), description_(std::move(app_description)), parent_(parent) {
        // Inherit if not from a nullptr
        if(parent_ != nullptr) {
            if(parent_->help_ptr_ != nullptr)
                set_help_flag(parent_->help_ptr_->get_name(false, true), parent_->help_ptr_->get_description());
            if(parent_->help_all_ptr_ != nullptr)
                set_help_all_flag(parent_->help_all_ptr_->get_name(false, true),
                                  parent_->help_all_ptr_->get_description());
 
            option_defaults_ = parent_->option_defaults_;
 
            // INHERITABLE
            failure_message_ = parent_->failure_message_;
            allow_extras_ = parent_->allow_extras_;
            allow_config_extras_ = parent_->allow_config_extras_;
            prefix_command_ = parent_->prefix_command_;
            immediate_callback_ = parent_->immediate_callback_;
            ignore_case_ = parent_->ignore_case_;
            ignore_underscore_ = parent_->ignore_underscore_;
            fallthrough_ = parent_->fallthrough_;
            validate_positionals_ = parent_->validate_positionals_;
            configurable_ = parent_->configurable_;
            allow_windows_style_options_ = parent_->allow_windows_style_options_;
            group_ = parent_->group_;
            footer_ = parent_->footer_;
            formatter_ = parent_->formatter_;
            config_formatter_ = parent_->config_formatter_;
            require_subcommand_max_ = parent_->require_subcommand_max_;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

App() [2/3]

CLI::App::App ( std::string app_description = "", std::string app_name = "" )

inlineexplicit

Definition at line 4841 of file CLI11.hpp.

        : App(app_description, app_name, nullptr) {
        set_help_flag("-h,--help", "Print this help message and exit");
    }

Here is the call graph for this function:

App() [3/3]

CLI::App::App ( const App & )

delete

~App()

virtual CLI::App::~App ( )

virtualdefault

Member Function Documentation

_compare_subcommand_names()

const std::string & CLI::App::_compare_subcommand_names ( const App & subcom, const App & base ) const

inlineprotected

Definition at line 7309 of file CLI11.hpp.

                                                                                         {
        static const std::string estring;
        if(subcom.disabled_) {
            return estring;
        }
        for(auto &subc : base.subcommands_) {
            if(subc.get() != &subcom) {
                if(subc->disabled_) {
                    continue;
                }
                if(!subcom.get_name().empty()) {
                    if(subc->check_name(subcom.get_name())) {
                        return subcom.get_name();
                    }
                }
                if(!subc->get_name().empty()) {
                    if(subcom.check_name(subc->get_name())) {
                        return subc->get_name();
                    }
                }
                for(const auto &les : subcom.aliases_) {
                    if(subc->check_name(les)) {
                        return les;
                    }
                }
                // this loop is needed in case of ignore_underscore or ignore_case on one but not the other
                for(const auto &les : subc->aliases_) {
                    if(subcom.check_name(les)) {
                        return les;
                    }
                }
                // if the subcommand is an option group we need to check deeper
                if(subc->get_name().empty()) {
                    auto &cmpres = _compare_subcommand_names(subcom, *subc);
                    if(!cmpres.empty()) {
                        return cmpres;
                    }
                }
                // if the test subcommand is an option group we need to check deeper
                if(subcom.get_name().empty()) {
                    auto &cmpres = _compare_subcommand_names(*subc, subcom);
                    if(!cmpres.empty()) {
                        return cmpres;
                    }
                }
            }
        }
        return estring;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_configure()

void CLI::App::_configure ( )

inlineprotected

configure subcommands to enable parsing through the current object set the correct fallthrough and prefix for nameless subcommands and manage the automatic enable or disable makes sure parent is set correctly

Definition at line 6419 of file CLI11.hpp.

                      {
        if(default_startup == startup_mode::enabled) {
            disabled_ = false;
        } else if(default_startup == startup_mode::disabled) {
            disabled_ = true;
        }
        for(const App_p &app : subcommands_) {
            if(app->has_automatic_name_) {
                app->name_.clear();
            }
            if(app->name_.empty()) {
                app->fallthrough_ = false; // make sure fallthrough_ is false to prevent infinite loop
                app->prefix_command_ = false;
            }
            // make sure the parent is set to be this object in preparation for parse
            app->parent_ = this;
            app->_configure();
        }
    }

Here is the caller graph for this function:

_count_remaining_positionals()

std::size_t CLI::App::_count_remaining_positionals ( bool required_only = false ) const

inlineprotected

Definition at line 6957 of file CLI11.hpp.

                                                                             {
        std::size_t retval = 0;
        for(const Option_p &opt : options_) {
            if(opt->get_positional() && (!required_only || opt->get_required())) {
                if(opt->get_items_expected_min() > 0 &&
                   static_cast<int>(opt->count()) < opt->get_items_expected_min()) {
                    retval += static_cast<std::size_t>(opt->get_items_expected_min()) - opt->count();
                }
            }
        }
        return retval;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_find_subcommand()

App * CLI::App::_find_subcommand ( const std::string & subc_name, bool ignore_disabled, bool ignore_used ) const

inlineprotectednoexcept

Locate a subcommand by name with two conditions, should disabled subcommands be ignored, and should used subcommands be ignored

Definition at line 7085 of file CLI11.hpp.

                                                                                                             {
        for(const App_p &com : subcommands_) {
            if(com->disabled_ && ignore_disabled)
                continue;
            if(com->get_name().empty()) {
                auto subc = com->_find_subcommand(subc_name, ignore_disabled, ignore_used);
                if(subc != nullptr) {
                    return subc;
                }
            }
            if(com->check_name(subc_name)) {
                if((!*com) || !ignore_used)
                    return com.get();
            }
        }
        return nullptr;
    }

Here is the caller graph for this function:

_get_fallthrough_parent()

App * CLI::App::_get_fallthrough_parent ( )

inlineprotected

Definition at line 7297 of file CLI11.hpp.

                                   {
        if(parent_ == nullptr) {
            throw(HorribleError("No Valid parent"));
        }
        auto fallthrough_parent = parent_;
        while((fallthrough_parent->parent_ != nullptr) && (fallthrough_parent->get_name().empty())) {
            fallthrough_parent = fallthrough_parent->parent_;
        }
        return fallthrough_parent;
    }

Here is the caller graph for this function:

_has_remaining_positionals()

bool CLI::App::_has_remaining_positionals ( ) const

inlineprotected

Definition at line 6971 of file CLI11.hpp.

                                            {
        for(const Option_p &opt : options_) {
            if(opt->get_positional() && ((static_cast<int>(opt->count()) < opt->get_items_expected_min()))) {
                return true;
            }
        }
 
        return false;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_move_option()

void CLI::App::_move_option ( Option * opt, App * app )

inline

Definition at line 7377 of file CLI11.hpp.

                                             {
        if(opt == nullptr) {
            throw OptionNotFound("the option is NULL");
        }
        // verify that the give app is actually a subcommand
        bool found = false;
        for(auto &subc : subcommands_) {
            if(app == subc.get()) {
                found = true;
            }
        }
        if(!found) {
            throw OptionNotFound("The Given app is not a subcommand");
        }
 
        if((help_ptr_ == opt) || (help_all_ptr_ == opt))
            throw OptionAlreadyAdded("cannot move help options");
 
        if(config_ptr_ == opt)
            throw OptionAlreadyAdded("cannot move config file options");
 
        auto iterator =
            std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
        if(iterator != std::end(options_)) {
            const auto &opt_p = *iterator;
            if(std::find_if(std::begin(app->options_), std::end(app->options_), [&opt_p](const Option_p &v) {
                   return (*v == *opt_p);
               }) == std::end(app->options_)) {
                // only erase after the insertion was successful
                app->options_.push_back(std::move(*iterator));
                options_.erase(iterator);
            } else {
                throw OptionAlreadyAdded("option was not located: " + opt->get_name());
            }
        } else {
            throw OptionNotFound("could not locate the given Option");
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_move_to_missing()

void CLI::App::_move_to_missing ( detail::Classifier val_type, const std::string & val )

inlineprotected

Definition at line 7359 of file CLI11.hpp.

                                                                           {
        if(allow_extras_ || subcommands_.empty()) {
            missing_.emplace_back(val_type, val);
            return;
        }
        // allow extra arguments to be places in an option group if it is allowed there
        for(auto &subc : subcommands_) {
            if(subc->name_.empty() && subc->allow_extras_) {
                subc->missing_.emplace_back(val_type, val);
                return;
            }
        }
        // if we haven't found any place to put them yet put them in missing
        missing_.emplace_back(val_type, val);
    }

Here is the caller graph for this function:

_parse() [1/2]

void CLI::App::_parse ( std::vector< std::string > && args )

inlineprotected

Definition at line 6824 of file CLI11.hpp.

                                             {
        // this can only be called by the top level in which case parent == nullptr by definition
        // operation is simplified
        increment_parsed();
        _trigger_pre_parse(args.size());
        bool positional_only = false;
 
        while(!args.empty()) {
            _parse_single(args, positional_only);
        }
        _process();
 
        // Throw error if any items are left over (depending on settings)
        _process_extras();
    }

Here is the call graph for this function:

_parse() [2/2]

void CLI::App::_parse ( std::vector< std::string > & args )

inlineprotected

Definition at line 6795 of file CLI11.hpp.

                                            {
        increment_parsed();
        _trigger_pre_parse(args.size());
        bool positional_only = false;
 
        while(!args.empty()) {
            if(!_parse_single(args, positional_only)) {
                break;
            }
        }
 
        if(parent_ == nullptr) {
            _process();
 
            // Throw error if any items are left over (depending on settings)
            _process_extras(args);
 
            // Convert missing (pairs) to extras (string only) ready for processing in another app
            args = remaining_for_passthrough(false);
        } else if(parse_complete_callback_) {
            _process_env();
            _process_callbacks();
            _process_help_flags();
            _process_requirements();
            run_callback();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_parse_arg()

bool CLI::App::_parse_arg ( std::vector< std::string > & args, detail::Classifier current_type )

inlineprotected

Parse a short (false) or long (true) argument, must be at the top of the list return true if the argument was processed or false if nothing was done

Definition at line 7133 of file CLI11.hpp.

                                                                               {
 
        std::string current = args.back();
 
        std::string arg_name;
        std::string value;
        std::string rest;
 
        switch(current_type) {
        case detail::Classifier::LONG:
            if(!detail::split_long(current, arg_name, value))
                throw HorribleError("Long parsed but missing (you should not see this):" + args.back());
            break;
        case detail::Classifier::SHORT:
            if(!detail::split_short(current, arg_name, rest))
                throw HorribleError("Short parsed but missing! You should not see this");
            break;
        case detail::Classifier::WINDOWS:
            if(!detail::split_windows_style(current, arg_name, value))
                throw HorribleError("windows option parsed but missing! You should not see this");
            break;
        case detail::Classifier::SUBCOMMAND:
        case detail::Classifier::SUBCOMMAND_TERMINATOR:
        case detail::Classifier::POSITIONAL_MARK:
        case detail::Classifier::NONE:
        default:
            throw HorribleError("parsing got called with invalid option! You should not see this");
        }
 
        auto op_ptr =
            std::find_if(std::begin(options_), std::end(options_), [arg_name, current_type](const Option_p &opt) {
                if(current_type == detail::Classifier::LONG)
                    return opt->check_lname(arg_name);
                if(current_type == detail::Classifier::SHORT)
                    return opt->check_sname(arg_name);
                // this will only get called for detail::Classifier::WINDOWS
                return opt->check_lname(arg_name) || opt->check_sname(arg_name);
            });
 
        // Option not found
        if(op_ptr == std::end(options_)) {
            for(auto &subc : subcommands_) {
                if(subc->name_.empty() && !subc->disabled_) {
                    if(subc->_parse_arg(args, current_type)) {
                        if(!subc->pre_parse_called_) {
                            subc->_trigger_pre_parse(args.size());
                        }
                        return true;
                    }
                }
            }
            // If a subcommand, try the master command
            if(parent_ != nullptr && fallthrough_)
                return _get_fallthrough_parent()->_parse_arg(args, current_type);
            // don't capture missing if this is a nameless subcommand
            if(parent_ != nullptr && name_.empty()) {
                return false;
            }
            // Otherwise, add to missing
            args.pop_back();
            _move_to_missing(current_type, current);
            return true;
        }
 
        args.pop_back();
 
        // Get a reference to the pointer to make syntax bearable
        Option_p &op = *op_ptr;
 
        int min_num = (std::min)(op->get_type_size_min(), op->get_items_expected_min());
        int max_num = op->get_items_expected_max();
 
        // Make sure we always eat the minimum for unlimited vectors
        int collected = 0;    // total number of arguments collected
        int result_count = 0; // local variable for number of results in a single arg string
        // deal with purely flag like things
        if(max_num == 0) {
            auto res = op->get_flag_value(arg_name, value);
            op->add_result(res);
            parse_order_.push_back(op.get());
        } else if(!value.empty()) { // --this=value
            op->add_result(value, result_count);
            parse_order_.push_back(op.get());
            collected += result_count;
            // -Trest
        } else if(!rest.empty()) {
            op->add_result(rest, result_count);
            parse_order_.push_back(op.get());
            rest = "";
            collected += result_count;
        }
 
        // gather the minimum number of arguments
        while(min_num > collected && !args.empty()) {
            std::string current_ = args.back();
            args.pop_back();
            op->add_result(current_, result_count);
            parse_order_.push_back(op.get());
            collected += result_count;
        }
 
        if(min_num > collected) { // if we have run out of arguments and the minimum was not met
            throw ArgumentMismatch::TypedAtLeast(op->get_name(), min_num, op->get_type_name());
        }
 
        if(max_num > collected || op->get_allow_extra_args()) { // we allow optional arguments
            auto remreqpos = _count_remaining_positionals(true);
            // we have met the minimum now optionally check up to the maximum
            while((collected < max_num || op->get_allow_extra_args()) && !args.empty() &&
                  _recognize(args.back(), false) == detail::Classifier::NONE) {
                // If any required positionals remain, don't keep eating
                if(remreqpos >= args.size()) {
                    break;
                }
 
                op->add_result(args.back(), result_count);
                parse_order_.push_back(op.get());
                args.pop_back();
                collected += result_count;
            }
 
            // Allow -- to end an unlimited list and "eat" it
            if(!args.empty() && _recognize(args.back()) == detail::Classifier::POSITIONAL_MARK)
                args.pop_back();
            // optional flag that didn't receive anything now get the default value
            if(min_num == 0 && max_num > 0 && collected == 0) {
                auto res = op->get_flag_value(arg_name, std::string{});
                op->add_result(res);
                parse_order_.push_back(op.get());
            }
        }
 
        // if we only partially completed a type then add an empty string for later processing
        if(min_num > 0 && op->get_type_size_max() != min_num && collected % op->get_type_size_max() != 0) {
            op->add_result(std::string{});
        }
 
        if(!rest.empty()) {
            rest = "-" + rest;
            args.push_back(rest);
        }
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_parse_config()

void CLI::App::_parse_config ( std::vector< ConfigItem > & args )

inlineprotected

Parse one config param, return false if not found in any subcommand, remove if it is

If this has more than one dot.separated.name, go into the subcommand matching it Returns true if it managed to find the option, if false you'll need to remove the arg manually.

Definition at line 6844 of file CLI11.hpp.

                                                    {
        for(ConfigItem item : args) {
            if(!_parse_single_config(item) && allow_config_extras_ == config_extras_mode::error)
                throw ConfigError::Extras(item.fullname());
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_parse_positional()

bool CLI::App::_parse_positional ( std::vector< std::string > & args, bool haltOnSubcommand )

inlineprotected

Parse a positional, go up the tree to check

Parameters

haltOnSubcommand

if set to true the operation will not process subcommands merely return false Return true if the positional was used false otherwise

Try to find a local subcommand that is repeated

now try one last gasp at subcommands that have been executed before, go to root app and try to find a subcommand in a broader way, if one exists let the parent deal with it

If this is an option group don't deal with it

We are out of other options this goes to missing

Definition at line 6984 of file CLI11.hpp.

                                                                              {
 
        const std::string &positional = args.back();
 
        if(positionals_at_end_) {
            // deal with the case of required arguments at the end which should take precedence over other arguments
            auto arg_rem = args.size();
            auto remreq = _count_remaining_positionals(true);
            if(arg_rem <= remreq) {
                for(const Option_p &opt : options_) {
                    if(opt->get_positional() && opt->required_) {
                        if(static_cast<int>(opt->count()) < opt->get_items_expected_min()) {
                            if(validate_positionals_) {
                                std::string pos = positional;
                                pos = opt->_validate(pos, 0);
                                if(!pos.empty()) {
                                    continue;
                                }
                            }
                            opt->add_result(positional);
                            parse_order_.push_back(opt.get());
                            args.pop_back();
                            return true;
                        }
                    }
                }
            }
        }
        for(const Option_p &opt : options_) {
            // Eat options, one by one, until done
            if(opt->get_positional() &&
               (static_cast<int>(opt->count()) < opt->get_items_expected_min() || opt->get_allow_extra_args())) {
                if(validate_positionals_) {
                    std::string pos = positional;
                    pos = opt->_validate(pos, 0);
                    if(!pos.empty()) {
                        continue;
                    }
                }
                opt->add_result(positional);
                parse_order_.push_back(opt.get());
                args.pop_back();
                return true;
            }
        }
 
        for(auto &subc : subcommands_) {
            if((subc->name_.empty()) && (!subc->disabled_)) {
                if(subc->_parse_positional(args, false)) {
                    if(!subc->pre_parse_called_) {
                        subc->_trigger_pre_parse(args.size());
                    }
                    return true;
                }
            }
        }
        // let the parent deal with it if possible
        if(parent_ != nullptr && fallthrough_)
            return _get_fallthrough_parent()->_parse_positional(args, static_cast<bool>(parse_complete_callback_));
 
        auto com = _find_subcommand(args.back(), true, false);
        if(com != nullptr && (require_subcommand_max_ == 0 || require_subcommand_max_ > parsed_subcommands_.size())) {
            if(haltOnSubcommand) {
                return false;
            }
            args.pop_back();
            com->_parse(args);
            return true;
        }
        auto parent_app = (parent_ != nullptr) ? _get_fallthrough_parent() : this;
        com = parent_app->_find_subcommand(args.back(), true, false);
        if(com != nullptr && (com->parent_->require_subcommand_max_ == 0 ||
                              com->parent_->require_subcommand_max_ > com->parent_->parsed_subcommands_.size())) {
            return false;
        }
 
        if(positionals_at_end_) {
            throw CLI::ExtrasError(name_, args);
        }
        if(parent_ != nullptr && name_.empty()) {
            return false;
        }
        _move_to_missing(detail::Classifier::NONE, positional);
        args.pop_back();
        if(prefix_command_) {
            while(!args.empty()) {
                _move_to_missing(detail::Classifier::NONE, args.back());
                args.pop_back();
            }
        }
 
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_parse_single()

bool CLI::App::_parse_single ( std::vector< std::string > & args, bool & positional_only )

inlineprotected

Parse "one" argument (some may eat more than one), delegate to parent if fails, add to missing if missing from master return false if the parse has failed and needs to return to parent

Definition at line 6914 of file CLI11.hpp.

                                                                          {
        bool retval = true;
        detail::Classifier classifier = positional_only ? detail::Classifier::NONE : _recognize(args.back());
        switch(classifier) {
        case detail::Classifier::POSITIONAL_MARK:
            args.pop_back();
            positional_only = true;
            if((!_has_remaining_positionals()) && (parent_ != nullptr)) {
                retval = false;
            } else {
                _move_to_missing(classifier, "--");
            }
            break;
        case detail::Classifier::SUBCOMMAND_TERMINATOR:
            // treat this like a positional mark if in the parent app
            args.pop_back();
            retval = false;
            break;
        case detail::Classifier::SUBCOMMAND:
            retval = _parse_subcommand(args);
            break;
        case detail::Classifier::LONG:
        case detail::Classifier::SHORT:
        case detail::Classifier::WINDOWS:
            // If already parsed a subcommand, don't accept options_
            _parse_arg(args, classifier);
            break;
        case detail::Classifier::NONE:
            // Probably a positional or something for a parent (sub)command
            retval = _parse_positional(args, false);
            if(retval && positionals_at_end_) {
                positional_only = true;
            }
            break;
            // LCOV_EXCL_START
        default:
            throw HorribleError("unrecognized classifier (you should not see this!)");
            // LCOV_EXCL_STOP
        }
        return retval;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_parse_single_config()

bool CLI::App::_parse_single_config ( const ConfigItem & item, std::size_t level = 0 )

inlineprotected

Definition at line 6852 of file CLI11.hpp.

                                                                           {
        if(level < item.parents.size()) {
            try {
                auto subcom = get_subcommand(item.parents.at(level));
                auto result = subcom->_parse_single_config(item, level + 1);
 
                return result;
            } catch(const OptionNotFound &) {
                return false;
            }
        }
        // check for section open
        if(item.name == "++") {
            if(configurable_) {
                increment_parsed();
                _trigger_pre_parse(2);
                if(parent_ != nullptr) {
                    parent_->parsed_subcommands_.push_back(this);
                }
            }
            return true;
        }
        // check for section close
        if(item.name == "--") {
            if(configurable_) {
                _process_callbacks();
                _process_requirements();
                run_callback();
            }
            return true;
        }
        Option *op = get_option_no_throw("--" + item.name);
        if(op == nullptr) {
            // If the option was not present
            if(get_allow_config_extras() == config_extras_mode::capture)
                // Should we worry about classifying the extras properly?
                missing_.emplace_back(detail::Classifier::NONE, item.fullname());
            return false;
        }
 
        if(!op->get_configurable())
            throw ConfigError::NotConfigurable(item.fullname());
 
        if(op->empty()) {
            // Flag parsing
            if(op->get_expected_min() == 0) {
                auto res = config_formatter_->to_flag(item);
                res = op->get_flag_value(item.name, res);
 
                op->add_result(res);
 
            } else {
                op->add_result(item.inputs);
                op->run_callback();
            }
        }
 
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_parse_subcommand()

bool CLI::App::_parse_subcommand ( std::vector< std::string > & args )

inlineprotected

Parse a subcommand, modify args and continue

Unlike the others, this one will always allow fallthrough return true if the subcommand was processed false otherwise

Definition at line 7107 of file CLI11.hpp.

                                                       {
        if(_count_remaining_positionals(/* required */ true) > 0) {
            _parse_positional(args, false);
            return true;
        }
        auto com = _find_subcommand(args.back(), true, true);
        if(com != nullptr) {
            args.pop_back();
            parsed_subcommands_.push_back(com);
            com->_parse(args);
            auto parent_app = com->parent_;
            while(parent_app != this) {
                parent_app->_trigger_pre_parse(args.size());
                parent_app->parsed_subcommands_.push_back(com);
                parent_app = parent_app->parent_;
            }
            return true;
        }
 
        if(parent_ == nullptr)
            throw HorribleError("Subcommand " + args.back() + " missing");
        return false;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_process()

void CLI::App::_process ( )

inlineprotected

Definition at line 6746 of file CLI11.hpp.

                    {
        _process_config_file();
        _process_env();
        _process_callbacks();
        _process_help_flags();
        _process_requirements();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_process_callbacks()

void CLI::App::_process_callbacks ( )

inlineprotected

Definition at line 6570 of file CLI11.hpp.

                              {
 
        for(App_p &sub : subcommands_) {
            // process the priority option_groups first
            if(sub->get_name().empty() && sub->parse_complete_callback_) {
                if(sub->count_all() > 0) {
                    sub->_process_callbacks();
                    sub->run_callback();
                }
            }
        }
 
        for(const Option_p &opt : options_) {
            if(opt->count() > 0 && !opt->get_callback_run()) {
                opt->run_callback();
            }
        }
        for(App_p &sub : subcommands_) {
            if(!sub->parse_complete_callback_) {
                sub->_process_callbacks();
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_process_config_file()

void CLI::App::_process_config_file ( )

inlineprotected

Definition at line 6506 of file CLI11.hpp.

                                {
        if(config_ptr_ != nullptr) {
            bool config_required = config_ptr_->get_required();
            bool file_given = config_ptr_->count() > 0;
            auto config_file = config_ptr_->as<std::string>();
            if(config_file.empty()) {
                if(config_required) {
                    throw FileError::Missing("no specified config file");
                }
                return;
            }
 
            auto path_result = detail::check_path(config_file.c_str());
            if(path_result == detail::path_type::file) {
                try {
                    std::vector<ConfigItem> values = config_formatter_->from_file(config_file);
                    _parse_config(values);
                    if(!file_given) {
                        config_ptr_->add_result(config_file);
                    }
                } catch(const FileError &) {
                    if(config_required || file_given)
                        throw;
                }
            } else if(config_required || file_given) {
                throw FileError::Missing(config_file);
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_process_env()

void CLI::App::_process_env ( )

inlineprotected

Definition at line 6537 of file CLI11.hpp.

                        {
        for(const Option_p &opt : options_) {
            if(opt->count() == 0 && !opt->envname_.empty()) {
                char *buffer = nullptr;
                std::string ename_string;
 
#ifdef _MSC_VER
                // Windows version
                std::size_t sz = 0;
                if(_dupenv_s(&buffer, &sz, opt->envname_.c_str()) == 0 && buffer != nullptr) {
                    ename_string = std::string(buffer);
                    free(buffer);
                }
#else
                // This also works on Windows, but gives a warning
                buffer = std::getenv(opt->envname_.c_str());
                if(buffer != nullptr)
                    ename_string = std::string(buffer);
#endif
 
                if(!ename_string.empty()) {
                    opt->add_result(ename_string);
                }
            }
        }
 
        for(App_p &sub : subcommands_) {
            if(sub->get_name().empty() || !sub->parse_complete_callback_)
                sub->_process_env();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_process_extras() [1/2]

void CLI::App::_process_extras ( )

inlineprotected

Definition at line 6755 of file CLI11.hpp.

                           {
        if(!(allow_extras_ || prefix_command_)) {
            std::size_t num_left_over = remaining_size();
            if(num_left_over > 0) {
                throw ExtrasError(name_, remaining(false));
            }
        }
 
        for(App_p &sub : subcommands_) {
            if(sub->count() > 0)
                sub->_process_extras();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_process_extras() [2/2]

void CLI::App::_process_extras ( std::vector< std::string > & args )

inlineprotected

Throw an error if anything is left over and should not be. Modifies the args to fill in the missing items before throwing.

Definition at line 6771 of file CLI11.hpp.

                                                     {
        if(!(allow_extras_ || prefix_command_)) {
            std::size_t num_left_over = remaining_size();
            if(num_left_over > 0) {
                args = remaining(false);
                throw ExtrasError(name_, args);
            }
        }
 
        for(App_p &sub : subcommands_) {
            if(sub->count() > 0)
                sub->_process_extras(args);
        }
    }

Here is the call graph for this function:

_process_help_flags()

void CLI::App::_process_help_flags ( bool trigger_help = false, bool trigger_all_help = false ) const

inlineprotected

Run help flag processing if any are found.

The flags allow recursive calls to remember if there was a help flag on a parent.

Definition at line 6597 of file CLI11.hpp.

                                                                                             {
        const Option *help_ptr = get_help_ptr();
        const Option *help_all_ptr = get_help_all_ptr();
 
        if(help_ptr != nullptr && help_ptr->count() > 0)
            trigger_help = true;
        if(help_all_ptr != nullptr && help_all_ptr->count() > 0)
            trigger_all_help = true;
 
        // If there were parsed subcommands, call those. First subcommand wins if there are multiple ones.
        if(!parsed_subcommands_.empty()) {
            for(const App *sub : parsed_subcommands_)
                sub->_process_help_flags(trigger_help, trigger_all_help);
 
            // Only the final subcommand should call for help. All help wins over help.
        } else if(trigger_all_help) {
            throw CallForAllHelp();
        } else if(trigger_help) {
            throw CallForHelp();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_process_requirements()

void CLI::App::_process_requirements ( )

inlineprotected

Definition at line 6620 of file CLI11.hpp.

                                 {
        // check excludes
        bool excluded{false};
        std::string excluder;
        for(auto &opt : exclude_options_) {
            if(opt->count() > 0) {
                excluded = true;
                excluder = opt->get_name();
            }
        }
        for(auto &subc : exclude_subcommands_) {
            if(subc->count_all() > 0) {
                excluded = true;
                excluder = subc->get_display_name();
            }
        }
        if(excluded) {
            if(count_all() > 0) {
                throw ExcludesError(get_display_name(), excluder);
            }
            // if we are excluded but didn't receive anything, just return
            return;
        }
 
        // check excludes
        bool missing_needed{false};
        std::string missing_need;
        for(auto &opt : need_options_) {
            if(opt->count() == 0) {
                missing_needed = true;
                missing_need = opt->get_name();
            }
        }
        for(auto &subc : need_subcommands_) {
            if(subc->count_all() == 0) {
                missing_needed = true;
                missing_need = subc->get_display_name();
            }
        }
        if(missing_needed) {
            if(count_all() > 0) {
                throw RequiresError(get_display_name(), missing_need);
            }
            // if we missing something but didn't have any options, just return
            return;
        }
 
        std::size_t used_options = 0;
        for(const Option_p &opt : options_) {
 
            if(opt->count() != 0) {
                ++used_options;
            }
            // Required but empty
            if(opt->get_required() && opt->count() == 0) {
                throw RequiredError(opt->get_name());
            }
            // Requires
            for(const Option *opt_req : opt->needs_)
                if(opt->count() > 0 && opt_req->count() == 0)
                    throw RequiresError(opt->get_name(), opt_req->get_name());
            // Excludes
            for(const Option *opt_ex : opt->excludes_)
                if(opt->count() > 0 && opt_ex->count() != 0)
                    throw ExcludesError(opt->get_name(), opt_ex->get_name());
        }
        // check for the required number of subcommands
        if(require_subcommand_min_ > 0) {
            auto selected_subcommands = get_subcommands();
            if(require_subcommand_min_ > selected_subcommands.size())
                throw RequiredError::Subcommand(require_subcommand_min_);
        }
 
        // Max error cannot occur, the extra subcommand will parse as an ExtrasError or a remaining item.
 
        // run this loop to check how many unnamed subcommands were actually used since they are considered options
        // from the perspective of an App
        for(App_p &sub : subcommands_) {
            if(sub->disabled_)
                continue;
            if(sub->name_.empty() && sub->count_all() > 0) {
                ++used_options;
            }
        }
 
        if(require_option_min_ > used_options || (require_option_max_ > 0 && require_option_max_ < used_options)) {
            auto option_list = detail::join(options_, [](const Option_p &ptr) { return ptr->get_name(false, true); });
            if(option_list.compare(0, 10, "-h,--help,") == 0) {
                option_list.erase(0, 10);
            }
            auto subc_list = get_subcommands([](App *app) { return ((app->get_name().empty()) && (!app->disabled_)); });
            if(!subc_list.empty()) {
                option_list += "," + detail::join(subc_list, [](const App *app) { return app->get_display_name(); });
            }
            throw RequiredError::Option(require_option_min_, require_option_max_, used_options, option_list);
        }
 
        // now process the requirements for subcommands if needed
        for(App_p &sub : subcommands_) {
            if(sub->disabled_)
                continue;
            if(sub->name_.empty() && sub->required_ == false) {
                if(sub->count_all() == 0) {
                    if(require_option_min_ > 0 && require_option_min_ <= used_options) {
                        continue;
                        // if we have met the requirement and there is nothing in this option group skip checking
                        // requirements
                    }
                    if(require_option_max_ > 0 && used_options >= require_option_min_) {
                        continue;
                        // if we have met the requirement and there is nothing in this option group skip checking
                        // requirements
                    }
                }
            }
            if(sub->count() > 0 || sub->name_.empty()) {
                sub->_process_requirements();
            }
 
            if(sub->required_ && sub->count_all() == 0) {
                throw(CLI::RequiredError(sub->get_display_name()));
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_recognize()

detail::Classifier CLI::App::_recognize ( const std::string & current, bool ignore_used_subcommands = true ) const

inlineprotected

Definition at line 6479 of file CLI11.hpp.

                                                                                                     {
        std::string dummy1, dummy2;
 
        if(current == "--")
            return detail::Classifier::POSITIONAL_MARK;
        if(_valid_subcommand(current, ignore_used_subcommands))
            return detail::Classifier::SUBCOMMAND;
        if(detail::split_long(current, dummy1, dummy2))
            return detail::Classifier::LONG;
        if(detail::split_short(current, dummy1, dummy2)) {
            if(dummy1[0] >= '0' && dummy1[0] <= '9') {
                if(get_option_no_throw(std::string{'-', dummy1[0]}) == nullptr) {
                    return detail::Classifier::NONE;
                }
            }
            return detail::Classifier::SHORT;
        }
        if((allow_windows_style_options_) && (detail::split_windows_style(current, dummy1, dummy2)))
            return detail::Classifier::WINDOWS;
        if((current == "++") && !name_.empty() && parent_ != nullptr)
            return detail::Classifier::SUBCOMMAND_TERMINATOR;
        return detail::Classifier::NONE;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_trigger_pre_parse()

void CLI::App::_trigger_pre_parse ( std::size_t remaining_args )

inlineprotected

Definition at line 7278 of file CLI11.hpp.

                                                      {
        if(!pre_parse_called_) {
            pre_parse_called_ = true;
            if(pre_parse_callback_) {
                pre_parse_callback_(remaining_args);
            }
        } else if(immediate_callback_) {
            if(!name_.empty()) {
                auto pcnt = parsed_;
                auto extras = std::move(missing_);
                clear();
                parsed_ = pcnt;
                pre_parse_called_ = true;
                missing_ = std::move(extras);
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_valid_subcommand()

bool CLI::App::_valid_subcommand ( const std::string & current, bool ignore_used = true ) const

inlineprotected

Definition at line 6465 of file CLI11.hpp.

                                                                                    {
        // Don't match if max has been reached - but still check parents
        if(require_subcommand_max_ != 0 && parsed_subcommands_.size() >= require_subcommand_max_) {
            return parent_ != nullptr && parent_->_valid_subcommand(current, ignore_used);
        }
        auto com = _find_subcommand(current, true, ignore_used);
        if(com != nullptr) {
            return true;
        }
        // Check parent if exists, else return false
        return parent_ != nullptr && parent_->_valid_subcommand(current, ignore_used);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_validate()

void CLI::App::_validate ( ) const

inlineprotected

Check the options to make sure there are no conflicts.

Currently checks to see if multiple positionals exist with unlimited args and checks if the min and max options are feasible

Definition at line 6380 of file CLI11.hpp.

                           {
        // count the number of positional only args
        auto pcount = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
            return opt->get_items_expected_max() >= detail::expected_max_vector_size && !opt->nonpositional();
        });
        if(pcount > 1) {
            auto pcount_req = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
                return opt->get_items_expected_max() >= detail::expected_max_vector_size && !opt->nonpositional() &&
                       opt->get_required();
            });
            if(pcount - pcount_req > 1) {
                throw InvalidError(name_);
            }
        }
 
        std::size_t nameless_subs{0};
        for(const App_p &app : subcommands_) {
            app->_validate();
            if(app->get_name().empty())
                ++nameless_subs;
        }
 
        if(require_option_min_ > 0) {
            if(require_option_max_ > 0) {
                if(require_option_max_ < require_option_min_) {
                    throw(InvalidError("Required min options greater than required max options",
                                       ExitCodes::InvalidError));
                }
            }
            if(require_option_min_ > (options_.size() + nameless_subs)) {
                throw(InvalidError("Required min options greater than number of available options",
                                   ExitCodes::InvalidError));
            }
        }
    }

Here is the caller graph for this function:

add_complex()

template<typename T , typename XC = double>

Option * CLI::App::add_complex ( std::string option_name, T & variable, std::string option_description = "", bool defaulted = false, std::string label = "COMPLEX" )

inline

Definition at line 5425 of file CLI11.hpp.

                                                     {
 
        CLI::callback_t fun = [&variable](const results_t &res) {
            XC x, y;
            bool worked;
            if(res.size() >= 2 && !res[1].empty()) {
                auto str1 = res[1];
                if(str1.back() == 'i' || str1.back() == 'j')
                    str1.pop_back();
                worked = detail::lexical_cast(res[0], x) && detail::lexical_cast(str1, y);
            } else {
                auto str1 = res.front();
                auto nloc = str1.find_last_of('-');
                if(nloc != std::string::npos && nloc > 0) {
                    worked = detail::lexical_cast(str1.substr(0, nloc), x);
                    str1 = str1.substr(nloc);
                    if(str1.back() == 'i' || str1.back() == 'j')
                        str1.pop_back();
                    worked = worked && detail::lexical_cast(str1, y);
                } else {
                    if(str1.back() == 'i' || str1.back() == 'j') {
                        str1.pop_back();
                        worked = detail::lexical_cast(str1, y);
                        x = XC{0};
                    } else {
                        worked = detail::lexical_cast(str1, x);
                        y = XC{0};
                    }
                }
            }
            if(worked)
                variable = T{x, y};
            return worked;
        };
 
        auto default_function = [&variable]() { return CLI::detail::checked_to_string<T, T>(variable); };
 
        CLI::Option *opt =
            add_option(option_name, std::move(fun), std::move(option_description), defaulted, default_function);
 
        opt->type_name(label)->type_size(1, 2)->delimiter('+')->run_callback_for_default();
        return opt;
    }

Here is the call graph for this function:

add_flag() [1/5]

Option * CLI::App::add_flag ( std::string flag_name )

inline

Definition at line 5265 of file CLI11.hpp.

{ return _add_flag_internal(flag_name, CLI::callback_t(), std::string{}); }

Here is the caller graph for this function:

add_flag() [2/5]

template<typename T , enable_if_t<!std::is_assignable< std::function< void(int64_t)>, T >::value, detail::enabler > = detail::dummy>

Option * CLI::App::add_flag ( std::string flag_name, std::vector< T > & flag_results, std::string flag_description = "" )

inline

Parameters

flag_results

A vector of values with the flag results

Definition at line 5317 of file CLI11.hpp.

                                                      {
        CLI::callback_t fun = [&flag_results](const CLI::results_t &res) {
            bool retval = true;
            for(const auto &elem : res) {
                flag_results.emplace_back();
                retval &= detail::lexical_cast(elem, flag_results.back());
            }
            return retval;
        };
        return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description))
            ->multi_option_policy(MultiOptionPolicy::TakeAll)
            ->run_callback_for_default();
    }

Here is the call graph for this function:

add_flag() [3/5]

template<typename T , enable_if_t< std::is_integral< T >::value &&!is_bool< T >::value, detail::enabler > = detail::dummy>

Option * CLI::App::add_flag ( std::string flag_name, T & flag_count, std::string flag_description = "" )

inline

Add option for flag with integer result - defaults to allowing multiple passings, but can be forced to one if multi_option_policy(CLI::MultiOptionPolicy::Throw) is used.

Parameters

flag_count

A variable holding the count

Definition at line 5281 of file CLI11.hpp.

                                                      {
        flag_count = 0;
        CLI::callback_t fun = [&flag_count](const CLI::results_t &res) {
            try {
                detail::sum_flag_vector(res, flag_count);
            } catch(const std::invalid_argument &) {
                return false;
            }
            return true;
        };
        return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description))
            ->multi_option_policy(MultiOptionPolicy::TakeAll);
    }

Here is the call graph for this function:

add_flag() [4/5]

template<typename T , enable_if_t< std::is_const< T >::value &&std::is_constructible< std::string, T >::value, detail::enabler > = detail::dummy>

Option * CLI::App::add_flag ( std::string flag_name, T & flag_description )

inline

Add flag with description but with no variable assignment or callback takes a constant string, if a variable string is passed that variable will be assigned the results from the flag

Definition at line 5273 of file CLI11.hpp.

                                                               {
        return _add_flag_internal(flag_name, CLI::callback_t(), flag_description);
    }

add_flag() [5/5]

template<typename T , enable_if_t<!is_vector< T >::value &&!std::is_const< T >::value &&(!std::is_integral< T >::value||is_bool< T >::value) &&!std::is_constructible< std::function< void(int)>, T >::value, detail::enabler > = detail::dummy>

Option * CLI::App::add_flag ( std::string flag_name, T & flag_result, std::string flag_description = "" )

inline

Other type version accepts all other types that are not vectors such as bool, enum, string or other classes that can be converted from a string

Parameters

flag_result

A variable holding true if passed

Definition at line 5304 of file CLI11.hpp.

                                                      {
 
        CLI::callback_t fun = [&flag_result](const CLI::results_t &res) {
            return CLI::detail::lexical_cast(res[0], flag_result);
        };
        return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description))->run_callback_for_default();
    }

Here is the call graph for this function:

add_flag_callback()

Option * CLI::App::add_flag_callback ( std::string flag_name, std::function< void(void)> function, std::string flag_description = "" )

inline

Parameters

function

A function to call, void(void)

Definition at line 5334 of file CLI11.hpp.

                                                               {
 
        CLI::callback_t fun = [function](const CLI::results_t &res) {
            bool trigger{false};
            auto result = CLI::detail::lexical_cast(res[0], trigger);
            if(result && trigger) {
                function();
            }
            return result;
        };
        return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description));
    }

add_flag_function()

Option * CLI::App::add_flag_function ( std::string flag_name, std::function< void(int64_t)> function, std::string flag_description = "" )

inline

Parameters

function

A function to call, void(int)

Definition at line 5350 of file CLI11.hpp.

                                                               {
 
        CLI::callback_t fun = [function](const CLI::results_t &res) {
            int64_t flag_count = 0;
            detail::sum_flag_vector(res, flag_count);
            function(flag_count);
            return true;
        };
        return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description))
            ->multi_option_policy(MultiOptionPolicy::TakeAll);
    }

Here is the call graph for this function:

add_mutable_set() [1/2]

template<typename T >

Option * CLI::App::add_mutable_set ( std::string option_name, T & member, const std::set< T > & options, std::string option_description, bool defaulted )

inline

Parameters

member	The selected member of the set
options	The set of possibilities

Definition at line 5412 of file CLI11.hpp.

                                            {
 
        Option *opt = add_option(option_name, member, std::move(option_description), defaulted);
        opt->check(IsMember{&options});
        return opt;
    }

Here is the call graph for this function:

add_mutable_set() [2/2]

template<typename T >

Option * CLI::App::add_mutable_set ( std::string option_name, T & member, const std::set< T > & options, std::string option_description = "" )

inline

Parameters

member	The selected member of the set
options	The set of possibilities

Definition at line 5387 of file CLI11.hpp.

                                                               {
 
        Option *opt = add_option(option_name, member, std::move(option_description));
        opt->check(IsMember{&options});
        return opt;
    }

Here is the call graph for this function:

add_option() [1/4]

Option * CLI::App::add_option ( std::string option_name )

inline

Definition at line 5190 of file CLI11.hpp.

                                              {
        return add_option(option_name, CLI::callback_t(), std::string{}, false);
    }

Here is the call graph for this function:

add_option() [2/4]

template<typename AssignTo , typename ConvertTo = AssignTo, enable_if_t<!std::is_const< ConvertTo >::value, detail::enabler > = detail::dummy>

Option * CLI::App::add_option ( std::string option_name, AssignTo & variable, std::string option_description = "", bool defaulted = false )

inline

Parameters

variable

The variable to set

Definition at line 5144 of file CLI11.hpp.

                                               {
 
        auto fun = [&variable](const CLI::results_t &res) { // comment for spacing
            return detail::lexical_conversion<AssignTo, ConvertTo>(res, variable);
        };
 
        Option *opt = add_option(option_name, fun, option_description, defaulted, [&variable]() {
            return CLI::detail::checked_to_string<AssignTo, ConvertTo>(variable);
        });
        opt->type_name(detail::type_name<ConvertTo>());
        // these must be actual lvalues since (std::max) sometimes is defined in terms of references and references
        // to structs used in the evaluation can be temporary so that would cause issues.
        auto Tcount = detail::type_count<AssignTo>::value;
        auto XCcount = detail::type_count<ConvertTo>::value;
        opt->type_size((std::max)(Tcount, XCcount));
        opt->expected(detail::expected_count<ConvertTo>::value);
        opt->run_callback_for_default();
        return opt;
    }

Here is the call graph for this function:

add_option() [3/4]

Option * CLI::App::add_option ( std::string option_name, callback_t option_callback, std::string option_description = "", bool defaulted = false, std::function< std::string()> func = {} )

inline

Add an option, will automatically understand the type for common types.

To use, create a variable with the expected type, and pass it in after the name. After start is called, you can use count to see if the value was passed, and the value will be initialized properly. Numbers, vectors, and strings are supported.

->required(), ->default, and the validators are options, The positional options take an optional number of arguments.

For example,

std::string filename;
program.add_option("filename", filename, "description of filename");

Definition at line 5099 of file CLI11.hpp.

                                                       {}) {
        Option myopt{option_name, option_description, option_callback, this};
 
        if(std::find_if(std::begin(options_), std::end(options_), [&myopt](const Option_p &v) {
               return *v == myopt;
           }) == std::end(options_)) {
            options_.emplace_back();
            Option_p &option = options_.back();
            option.reset(new Option(option_name, option_description, option_callback, this));
 
            // Set the default string capture function
            option->default_function(func);
 
            // For compatibility with CLI11 1.7 and before, capture the default string here
            if(defaulted)
                option->capture_default_str();
 
            // Transfer defaults to the new option
            option_defaults_.copy_to(option.get());
 
            // Don't bother to capture if we already did
            if(!defaulted && option->get_always_capture_default())
                option->capture_default_str();
 
            return option.get();
        }
        // we know something matches now find what it is so we can produce more error information
        for(auto &opt : options_) {
            auto &matchname = opt->matching_name(myopt);
            if(!matchname.empty()) {
                throw(OptionAlreadyAdded("added option matched existing option name: " + matchname));
            }
        }
        // this line should not be reached the above loop should trigger the throw
        throw(OptionAlreadyAdded("added option matched existing option name")); // LCOV_EXCL_LINE
    }

add_option() [4/4]

template<typename T , enable_if_t< std::is_const< T >::value &&std::is_constructible< std::string, T >::value, detail::enabler > = detail::dummy>

Option * CLI::App::add_option ( std::string option_name, T & option_description )

inline

Definition at line 5198 of file CLI11.hpp.

                                                                     {
        return add_option(option_name, CLI::callback_t(), option_description, false);
    }

Here is the call graph for this function:

add_option_function()

template<typename T >

Option * CLI::App::add_option_function ( std::string option_name, const std::function< void(const T &)> & func, std::string option_description = "" )

inline

Parameters

func	the callback to execute

Definition at line 5169 of file CLI11.hpp.

                                                                   {
 
        auto fun = [func](const CLI::results_t &res) {
            T variable;
            bool result = detail::lexical_conversion<T, T>(res, variable);
            if(result) {
                func(variable);
            }
            return result;
        };
 
        Option *opt = add_option(option_name, std::move(fun), option_description, false);
        opt->type_name(detail::type_name<T>());
        opt->type_size(detail::type_count<T>::value);
        opt->expected(detail::expected_count<T>::value);
        return opt;
    }

Here is the call graph for this function:

add_option_group()

template<typename T = Option_group>

T * CLI::App::add_option_group ( std::string group_name, std::string group_description = "" )

inline

Definition at line 5524 of file CLI11.hpp.

                                                                                {
        auto option_group = std::make_shared<T>(std::move(group_description), group_name, nullptr);
        auto ptr = option_group.get();
        // move to App_p for overload resolution on older gcc versions
        App_p app_ptr = std::dynamic_pointer_cast<App>(option_group);
        add_subcommand(std::move(app_ptr));
        return ptr;
    }

Here is the call graph for this function:

add_set() [1/2]

template<typename T >

Option * CLI::App::add_set ( std::string option_name, T & member, std::set< T > options, std::string option_description, bool defaulted )

inline

Parameters

member	The selected member of the set
options	The set of possibilities

Definition at line 5399 of file CLI11.hpp.

                                    {
 
        Option *opt = add_option(option_name, member, std::move(option_description), defaulted);
        opt->check(IsMember{options});
        return opt;
    }

Here is the call graph for this function:

add_set() [2/2]

template<typename T >

Option * CLI::App::add_set ( std::string option_name, T & member, std::set< T > options, std::string option_description = "" )

inline

Parameters

member	The selected member of the set
options	The set of possibilities

Definition at line 5375 of file CLI11.hpp.

                                                       {
 
        Option *opt = add_option(option_name, member, std::move(option_description));
        opt->check(IsMember{options});
        return opt;
    }

Here is the call graph for this function:

add_subcommand() [1/2]

App * CLI::App::add_subcommand ( CLI::App_p subcom )

inline

Definition at line 5547 of file CLI11.hpp.

                                         {
        if(!subcom)
            throw IncorrectConstruction("passed App is not valid");
        auto ckapp = (name_.empty() && parent_ != nullptr) ? _get_fallthrough_parent() : this;
        auto &mstrg = _compare_subcommand_names(*subcom, *ckapp);
        if(!mstrg.empty()) {
            throw(OptionAlreadyAdded("subcommand name or alias matches existing subcommand: " + mstrg));
        }
        subcom->parent_ = this;
        subcommands_.push_back(std::move(subcom));
        return subcommands_.back().get();
    }

Here is the call graph for this function:

add_subcommand() [2/2]

App * CLI::App::add_subcommand ( std::string subcommand_name = "", std::string subcommand_description = "" )

inline

Definition at line 5538 of file CLI11.hpp.

                                                                                               {
        if(!subcommand_name.empty() && !detail::valid_name_string(subcommand_name)) {
            throw IncorrectConstruction("subcommand name is not valid");
        }
        CLI::App_p subcom = std::shared_ptr<App>(new App(std::move(subcommand_description), subcommand_name, this));
        return add_subcommand(std::move(subcom));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

alias()

App * CLI::App::alias ( std::string app_name )

inline

Definition at line 4907 of file CLI11.hpp.

                                   {
        if(!detail::valid_name_string(app_name)) {
            throw(IncorrectConstruction("alias is not a valid name string"));
        }
 
        if(parent_ != nullptr) {
            aliases_.push_back(app_name);
            auto &res = _compare_subcommand_names(*this, *_get_fallthrough_parent());
            if(!res.empty()) {
                aliases_.pop_back();
                throw(OptionAlreadyAdded("alias already matches an existing subcommand: " + app_name));
            }
        } else {
            aliases_.push_back(app_name);
        }
 
        return this;
    }

Here is the call graph for this function:

allow_config_extras() [1/2]

App * CLI::App::allow_config_extras ( bool allow = true )

inline

Definition at line 4986 of file CLI11.hpp.

                                                {
        if(allow) {
            allow_config_extras_ = config_extras_mode::capture;
            allow_extras_ = true;
        } else {
            allow_config_extras_ = config_extras_mode::error;
        }
        return this;
    }

allow_config_extras() [2/2]

App * CLI::App::allow_config_extras ( config_extras_mode mode )

inline

Definition at line 4997 of file CLI11.hpp.

                                                      {
        allow_config_extras_ = mode;
        return this;
    }

allow_extras()

App * CLI::App::allow_extras ( bool allow = true )

inline

Definition at line 4927 of file CLI11.hpp.

                                         {
        allow_extras_ = allow;
        return this;
    }

allow_windows_style_options()

App * CLI::App::allow_windows_style_options ( bool value = true )

inline

Allow windows style options, such as /opt. First matching short or long name used. Subcommands inherit value.

Definition at line 5025 of file CLI11.hpp.

                                                        {
        allow_windows_style_options_ = value;
        return this;
    }

callback()

App * CLI::App::callback ( std::function< void()> app_callback )

inline

Set a callback for execution when all parsing and processing has completed

Due to a bug in c++11, it is not possible to overload on std::function (fixed in c++14 and backported to c++11 on newer compilers). Use capture by reference to get a pointer to App if needed.

Definition at line 4858 of file CLI11.hpp.

                                                    {
        if(immediate_callback_) {
            parse_complete_callback_ = std::move(app_callback);
        } else {
            final_callback_ = std::move(app_callback);
        }
        return this;
    }

check_name()

bool CLI::App::check_name ( std::string name_to_check ) const

inline

Definition at line 6279 of file CLI11.hpp.

                                                   {
        std::string local_name = name_;
        if(ignore_underscore_) {
            local_name = detail::remove_underscore(name_);
            name_to_check = detail::remove_underscore(name_to_check);
        }
        if(ignore_case_) {
            local_name = detail::to_lower(name_);
            name_to_check = detail::to_lower(name_to_check);
        }
 
        if(local_name == name_to_check) {
            return true;
        }
        for(auto les : aliases_) {
            if(ignore_underscore_) {
                les = detail::remove_underscore(les);
            }
            if(ignore_case_) {
                les = detail::to_lower(les);
            }
            if(les == name_to_check) {
                return true;
            }
        }
        return false;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

void CLI::App::clear ( )

inline

Definition at line 5752 of file CLI11.hpp.

                 {
 
        parsed_ = 0;
        pre_parse_called_ = false;
 
        missing_.clear();
        parsed_subcommands_.clear();
        for(const Option_p &opt : options_) {
            opt->clear();
        }
        for(const App_p &subc : subcommands_) {
            subc->clear();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

clear_aliases()

App * CLI::App::clear_aliases ( )

inline

Definition at line 6270 of file CLI11.hpp.

                         {
        aliases_.clear();
        return this;
    }

Here is the call graph for this function:

config_formatter()

App * CLI::App::config_formatter ( std::shared_ptr< Config > fmt )

inline

Definition at line 5070 of file CLI11.hpp.

                                                     {
        config_formatter_ = fmt;
        return this;
    }

config_to_str()

std::string CLI::App::config_to_str ( bool default_also = false, bool write_description = false ) const

inline

Produce a string that could be read in as a config of the current values of the App. Set default_also to include default arguments. Prefix will add a string to the beginning of each option.

Definition at line 6041 of file CLI11.hpp.

                                                                                             {
        return config_formatter_->to_config(this, default_also, write_description, "");
    }

configurable()

App * CLI::App::configurable ( bool value = true )

inline

Definition at line 5037 of file CLI11.hpp.

                                         {
        configurable_ = value;
        return this;
    }

count() [1/2]

std::size_t CLI::App::count ( ) const

inline

No argument version of count counts the number of times this subcommand was passed in. The main app will return 1. Unnamed subcommands will also return 1 unless otherwise modified in a callback

Definition at line 5645 of file CLI11.hpp.

{ return parsed_; }

count() [2/2]

std::size_t CLI::App::count ( std::string option_name ) const

inline

Definition at line 5889 of file CLI11.hpp.

{ return get_option(option_name)->count(); }

Here is the call graph for this function:

count_all()

std::size_t CLI::App::count_all ( ) const

inline

Get a count of all the arguments processed in options and subcommands, this excludes arguments which were treated as extras.

Definition at line 5649 of file CLI11.hpp.

                                {
        std::size_t cnt{0};
        for(auto &opt : options_) {
            cnt += opt->count();
        }
        for(auto &sub : subcommands_) {
            cnt += sub->count_all();
        }
        if(!get_name().empty()) { // for named subcommands add the number of times the subcommand was called
            cnt += parsed_;
        }
        return cnt;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

description()

App * CLI::App::description ( std::string app_description )

inline

Definition at line 6080 of file CLI11.hpp.

                                                {
        description_ = std::move(app_description);
        return this;
    }

disabled()

App * CLI::App::disabled ( bool disable = true )

inline

Definition at line 4939 of file CLI11.hpp.

                                       {
        disabled_ = disable;
        return this;
    }

Here is the caller graph for this function:

disabled_by_default()

App * CLI::App::disabled_by_default ( bool disable = true )

inline

Definition at line 4945 of file CLI11.hpp.

                                                  {
        if(disable) {
            default_startup = startup_mode::disabled;
        } else {
            default_startup = (default_startup == startup_mode::enabled) ? startup_mode::enabled : startup_mode::stable;
        }
        return this;
    }

Here is the caller graph for this function:

enabled_by_default()

App * CLI::App::enabled_by_default ( bool enable = true )

inline

Set the subcommand to be enabled by default, so on clear(), at the start of each parse it is enabled (not disabled)

Definition at line 4956 of file CLI11.hpp.

                                                {
        if(enable) {
            default_startup = startup_mode::enabled;
        } else {
            default_startup =
                (default_startup == startup_mode::disabled) ? startup_mode::disabled : startup_mode::stable;
        }
        return this;
    }

Here is the caller graph for this function:

excludes() [1/2]

App * CLI::App::excludes ( App * app )

inline

Definition at line 5949 of file CLI11.hpp.

                            {
        if(app == nullptr) {
            throw OptionNotFound("nullptr passed");
        }
        if(app == this) {
            throw OptionNotFound("cannot self reference in needs");
        }
        auto res = exclude_subcommands_.insert(app);
        // subcommand exclusion should be symmetric
        if(res.second) {
            app->exclude_subcommands_.insert(this);
        }
        return this;
    }

excludes() [2/2]

App * CLI::App::excludes ( Option * opt )

inline

Definition at line 5940 of file CLI11.hpp.

                               {
        if(opt == nullptr) {
            throw OptionNotFound("nullptr passed");
        }
        exclude_options_.insert(opt);
        return this;
    }

exit()

int CLI::App::exit ( const Error & e, std::ostream & out = std::cout, std::ostream & err = std::cerr ) const

inline

Avoid printing anything if this is a CLI::RuntimeError

Definition at line 5860 of file CLI11.hpp.

                                                                                         {
 
        if(dynamic_cast<const CLI::RuntimeError *>(&e) != nullptr)
            return e.get_exit_code();
 
        if(dynamic_cast<const CLI::CallForHelp *>(&e) != nullptr) {
            out << help();
            return e.get_exit_code();
        }
 
        if(dynamic_cast<const CLI::CallForAllHelp *>(&e) != nullptr) {
            out << help("", AppFormatMode::All);
            return e.get_exit_code();
        }
 
        if(e.get_exit_code() != static_cast<int>(ExitCodes::Success)) {
            if(failure_message_)
                err << failure_message_(this, e) << std::flush;
        }
 
        return e.get_exit_code();
    }

Here is the call graph for this function:

failure_message()

void CLI::App::failure_message ( std::function< std::string(const App *, const Error &e)> function )

inline

Definition at line 5855 of file CLI11.hpp.

                                                                                       {
        failure_message_ = function;
    }

fallthrough()

App * CLI::App::fallthrough ( bool value = true )

inline

Stop subcommand fallthrough, so that parent commands cannot collect commands after subcommand. Default from parent, usually set on parent.

Definition at line 5729 of file CLI11.hpp.

                                        {
        fallthrough_ = value;
        return this;
    }

final_callback()

App * CLI::App::final_callback ( std::function< void()> app_callback )

inline

Set a callback for execution when all parsing and processing has completed aliased as callback

Definition at line 4869 of file CLI11.hpp.

                                                          {
        final_callback_ = std::move(app_callback);
        return this;
    }

footer() [1/2]

App * CLI::App::footer ( std::function< std::string()> footer_function )

inline

Definition at line 6035 of file CLI11.hpp.

                                                          {
        footer_callback_ = std::move(footer_function);
        return this;
    }

footer() [2/2]

App * CLI::App::footer ( std::string footer_string )

inline

Definition at line 6030 of file CLI11.hpp.

                                         {
        footer_ = std::move(footer_string);
        return this;
    }

formatter()

App * CLI::App::formatter ( std::shared_ptr< FormatterBase > fmt )

inline

Definition at line 5058 of file CLI11.hpp.

                                                     {
        formatter_ = fmt;
        return this;
    }

formatter_fn()

App * CLI::App::formatter_fn ( std::function< std::string(const App *, std::string, AppFormatMode)> fmt )

inline

Definition at line 5064 of file CLI11.hpp.

                                                                                         {
        formatter_ = std::make_shared<FormatterLambda>(fmt);
        return this;
    }

get_aliases()

const std::vector< std::string > & CLI::App::get_aliases ( ) const

inline

Definition at line 6267 of file CLI11.hpp.

{ return aliases_; }

get_allow_config_extras()

config_extras_mode CLI::App::get_allow_config_extras ( ) const

inline

Definition at line 6240 of file CLI11.hpp.

{ return allow_config_extras_; }

Here is the caller graph for this function:

get_allow_extras()

bool CLI::App::get_allow_extras ( ) const

inline

Definition at line 6220 of file CLI11.hpp.

{ return allow_extras_; }

get_allow_windows_style_options()

bool CLI::App::get_allow_windows_style_options ( ) const

inline

Definition at line 6190 of file CLI11.hpp.

{ return allow_windows_style_options_; }

get_config_formatter()

std::shared_ptr< Config > CLI::App::get_config_formatter ( ) const

inline

Definition at line 6069 of file CLI11.hpp.

{ return config_formatter_; }

get_config_formatter_base()

std::shared_ptr< ConfigBase > CLI::App::get_config_formatter_base ( ) const

inline

Definition at line 6072 of file CLI11.hpp.

                                                                {
        return std::dynamic_pointer_cast<ConfigBase>(config_formatter_);
    }

get_config_ptr() [1/2]

Option * CLI::App::get_config_ptr ( )

inline

Definition at line 6252 of file CLI11.hpp.

{ return config_ptr_; }

get_config_ptr() [2/2]

const Option * CLI::App::get_config_ptr ( ) const

inline

Definition at line 6255 of file CLI11.hpp.

{ return config_ptr_; }

get_configurable()

bool CLI::App::get_configurable ( ) const

inline

Definition at line 6196 of file CLI11.hpp.

{ return configurable_; }

get_description()

std::string CLI::App::get_description ( ) const

inline

Definition at line 6077 of file CLI11.hpp.

{ return description_; }

get_disabled()

bool CLI::App::get_disabled ( ) const

inline

Definition at line 6226 of file CLI11.hpp.

{ return disabled_; }

get_disabled_by_default()

bool CLI::App::get_disabled_by_default ( ) const

inline

Definition at line 6232 of file CLI11.hpp.

{ return (default_startup == startup_mode::disabled); }

get_display_name()

std::string CLI::App::get_display_name ( ) const

inline

Definition at line 6276 of file CLI11.hpp.

{ return (!name_.empty()) ? name_ : "[Option Group: " + get_group() + "]"; }

Here is the call graph for this function:

Here is the caller graph for this function:

get_enabled_by_default()

bool CLI::App::get_enabled_by_default ( ) const

inline

Definition at line 6235 of file CLI11.hpp.

{ return (default_startup == startup_mode::enabled); }

get_fallthrough()

bool CLI::App::get_fallthrough ( ) const

inline

Definition at line 6187 of file CLI11.hpp.

{ return fallthrough_; }

get_footer()

std::string CLI::App::get_footer ( ) const

inline

Definition at line 6202 of file CLI11.hpp.

{ return (footer_callback_) ? footer_callback_() + '\n' + footer_ : footer_; }

get_formatter()

std::shared_ptr< FormatterBase > CLI::App::get_formatter ( ) const

inline

Definition at line 6066 of file CLI11.hpp.

{ return formatter_; }

get_group()

const std::string & CLI::App::get_group ( ) const

inline

Definition at line 6199 of file CLI11.hpp.

{ return group_; }

Here is the caller graph for this function:

get_groups()

std::vector< std::string > CLI::App::get_groups ( ) const

inline

Definition at line 6308 of file CLI11.hpp.

                                            {
        std::vector<std::string> groups;
 
        for(const Option_p &opt : options_) {
            // Add group if it is not already in there
            if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
                groups.push_back(opt->get_group());
            }
        }
 
        return groups;
    }

Here is the call graph for this function:

get_help_all_ptr()

const Option * CLI::App::get_help_all_ptr ( ) const

inline

Definition at line 6249 of file CLI11.hpp.

{ return help_all_ptr_; }

Here is the caller graph for this function:

get_help_ptr() [1/2]

Option * CLI::App::get_help_ptr ( )

inline

Definition at line 6243 of file CLI11.hpp.

{ return help_ptr_; }

Here is the caller graph for this function:

get_help_ptr() [2/2]

const Option * CLI::App::get_help_ptr ( ) const

inline

Definition at line 6246 of file CLI11.hpp.

{ return help_ptr_; }

get_ignore_case()

bool CLI::App::get_ignore_case ( ) const

inline

Definition at line 6181 of file CLI11.hpp.

{ return ignore_case_; }

get_ignore_underscore()

bool CLI::App::get_ignore_underscore ( ) const

inline

Definition at line 6184 of file CLI11.hpp.

{ return ignore_underscore_; }

get_immediate_callback()

bool CLI::App::get_immediate_callback ( ) const

inline

Definition at line 6229 of file CLI11.hpp.

{ return immediate_callback_; }

get_name()

const std::string & CLI::App::get_name ( ) const

inline

Definition at line 6264 of file CLI11.hpp.

{ return name_; }

Here is the caller graph for this function:

get_option() [1/2]

Option * CLI::App::get_option ( std::string option_name )

inline

Definition at line 6166 of file CLI11.hpp.

                                              {
        auto opt = get_option_no_throw(option_name);
        if(opt == nullptr) {
            throw OptionNotFound(option_name);
        }
        return opt;
    }

Here is the call graph for this function:

get_option() [2/2]

const Option * CLI::App::get_option ( std::string option_name ) const

inline

Definition at line 6157 of file CLI11.hpp.

                                                          {
        auto opt = get_option_no_throw(option_name);
        if(opt == nullptr) {
            throw OptionNotFound(option_name);
        }
        return opt;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_option_group()

App * CLI::App::get_option_group ( std::string group_name ) const

inline

Definition at line 5633 of file CLI11.hpp.

                                                      {
        for(const App_p &app : subcommands_) {
            if(app->name_.empty() && app->group_ == group_name) {
                return app.get();
            }
        }
        throw OptionNotFound(group_name);
    }

get_option_no_throw() [1/2]

const Option * CLI::App::get_option_no_throw ( std::string option_name ) const

inlinenoexcept

Definition at line 6138 of file CLI11.hpp.

                                                                            {
        for(const Option_p &opt : options_) {
            if(opt->check_name(option_name)) {
                return opt.get();
            }
        }
        for(const auto &subc : subcommands_) {
            // also check down into nameless subcommands
            if(subc->get_name().empty()) {
                auto opt = subc->get_option_no_throw(option_name);
                if(opt != nullptr) {
                    return opt;
                }
            }
        }
        return nullptr;
    }

Here is the call graph for this function:

get_option_no_throw() [2/2]

Option * CLI::App::get_option_no_throw ( std::string option_name )

inlinenoexcept

Definition at line 6119 of file CLI11.hpp.

                                                                {
        for(Option_p &opt : options_) {
            if(opt->check_name(option_name)) {
                return opt.get();
            }
        }
        for(auto &subc : subcommands_) {
            // also check down into nameless subcommands
            if(subc->get_name().empty()) {
                auto opt = subc->get_option_no_throw(option_name);
                if(opt != nullptr) {
                    return opt;
                }
            }
        }
        return nullptr;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_options() [1/2]

std::vector< const Option * > CLI::App::get_options ( const std::function< bool(const Option *)> filter = {} ) const

inline

Definition at line 6086 of file CLI11.hpp.

                                                                                           {}) const {
        std::vector<const Option *> options(options_.size());
        std::transform(std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) {
            return val.get();
        });
 
        if(filter) {
            options.erase(std::remove_if(std::begin(options),
                                         std::end(options),
                                         [&filter](const Option *opt) { return !filter(opt); }),
                          std::end(options));
        }
 
        return options;
    }

get_options() [2/2]

std::vector< Option * > CLI::App::get_options ( const std::function< bool(Option *)> filter = {} )

inline

Definition at line 6103 of file CLI11.hpp.

                                                                               {}) {
        std::vector<Option *> options(options_.size());
        std::transform(std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) {
            return val.get();
        });
 
        if(filter) {
            options.erase(
                std::remove_if(std::begin(options), std::end(options), [&filter](Option *opt) { return !filter(opt); }),
                std::end(options));
        }
 
        return options;
    }

get_parent() [1/2]

App * CLI::App::get_parent ( )

inline

Definition at line 6258 of file CLI11.hpp.

{ return parent_; }

Here is the caller graph for this function:

get_parent() [2/2]

const App * CLI::App::get_parent ( ) const

inline

Definition at line 6261 of file CLI11.hpp.

{ return parent_; }

get_positionals_at_end()

bool CLI::App::get_positionals_at_end ( ) const

inline

Definition at line 6193 of file CLI11.hpp.

{ return positionals_at_end_; }

get_prefix_command()

bool CLI::App::get_prefix_command ( ) const

inline

Definition at line 6217 of file CLI11.hpp.

{ return prefix_command_; }

get_require_option_max()

std::size_t CLI::App::get_require_option_max ( ) const

inline

Definition at line 6214 of file CLI11.hpp.

{ return require_option_max_; }

get_require_option_min()

std::size_t CLI::App::get_require_option_min ( ) const

inline

Definition at line 6211 of file CLI11.hpp.

{ return require_option_min_; }

get_require_subcommand_max()

std::size_t CLI::App::get_require_subcommand_max ( ) const

inline

Definition at line 6208 of file CLI11.hpp.

{ return require_subcommand_max_; }

get_require_subcommand_min()

std::size_t CLI::App::get_require_subcommand_min ( ) const

inline

Definition at line 6205 of file CLI11.hpp.

{ return require_subcommand_min_; }

get_required()

bool CLI::App::get_required ( ) const

inline

Definition at line 6223 of file CLI11.hpp.

{ return required_; }

get_subcommand() [1/3]

App * CLI::App::get_subcommand ( const App * subcom ) const

inline

Check to see if a subcommand is part of this command (doesn't have to be in command line) returns the first subcommand if passed a nullptr

Definition at line 5578 of file CLI11.hpp.

                                                 {
        if(subcom == nullptr)
            throw OptionNotFound("nullptr passed");
        for(const App_p &subcomptr : subcommands_)
            if(subcomptr.get() == subcom)
                return subcomptr.get();
        throw OptionNotFound(subcom->get_name());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_subcommand() [2/3]

App * CLI::App::get_subcommand ( int index = 0 ) const

inline

Definition at line 5595 of file CLI11.hpp.

                                             {
        if(index >= 0) {
            auto uindex = static_cast<unsigned>(index);
            if(uindex < subcommands_.size())
                return subcommands_[uindex].get();
        }
        throw OptionNotFound(std::to_string(index));
    }

get_subcommand() [3/3]

App * CLI::App::get_subcommand ( std::string subcom ) const

inline

Definition at line 5588 of file CLI11.hpp.

                                                {
        auto subc = _find_subcommand(subcom, false, false);
        if(subc == nullptr)
            throw OptionNotFound(subcom);
        return subc;
    }

Here is the call graph for this function:

get_subcommand_ptr() [1/3]

CLI::App_p CLI::App::get_subcommand_ptr ( App * subcom ) const

inline

Definition at line 5605 of file CLI11.hpp.

                                                   {
        if(subcom == nullptr)
            throw OptionNotFound("nullptr passed");
        for(const App_p &subcomptr : subcommands_)
            if(subcomptr.get() == subcom)
                return subcomptr;
        throw OptionNotFound(subcom->get_name());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_subcommand_ptr() [2/3]

CLI::App_p CLI::App::get_subcommand_ptr ( int index = 0 ) const

inline

Definition at line 5623 of file CLI11.hpp.

                                                     {
        if(index >= 0) {
            auto uindex = static_cast<unsigned>(index);
            if(uindex < subcommands_.size())
                return subcommands_[uindex];
        }
        throw OptionNotFound(std::to_string(index));
    }

get_subcommand_ptr() [3/3]

CLI::App_p CLI::App::get_subcommand_ptr ( std::string subcom ) const

inline

Definition at line 5615 of file CLI11.hpp.

                                                        {
        for(const App_p &subcomptr : subcommands_)
            if(subcomptr->check_name(subcom))
                return subcomptr;
        throw OptionNotFound(subcom);
    }

get_subcommands() [1/3]

std::vector< App * > CLI::App::get_subcommands ( ) const

inline

Get a subcommand pointer list to the currently selected subcommands (after parsing by default, in command line order; use parsed = false to get the original definition list.)

Definition at line 5893 of file CLI11.hpp.

{ return parsed_subcommands_; }

Here is the caller graph for this function:

get_subcommands() [2/3]

std::vector< App * > CLI::App::get_subcommands ( const std::function< bool(App *)> & filter )

inline

Get a filtered subcommand pointer list from the original definition list. An empty function will provide all subcommands

Definition at line 5915 of file CLI11.hpp.

                                                                             {
        std::vector<App *> subcomms(subcommands_.size());
        std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
            return v.get();
        });
 
        if(filter) {
            subcomms.erase(
                std::remove_if(std::begin(subcomms), std::end(subcomms), [&filter](App *app) { return !filter(app); }),
                std::end(subcomms));
        }
 
        return subcomms;
    }

get_subcommands() [3/3]

std::vector< const App * > CLI::App::get_subcommands ( const std::function< bool(const App *)> & filter ) const

inline

Get a filtered subcommand pointer list from the original definition list. An empty function will provide all subcommands (const)

Definition at line 5897 of file CLI11.hpp.

                                                                                               {
        std::vector<const App *> subcomms(subcommands_.size());
        std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
            return v.get();
        });
 
        if(filter) {
            subcomms.erase(std::remove_if(std::begin(subcomms),
                                          std::end(subcomms),
                                          [&filter](const App *app) { return !filter(app); }),
                           std::end(subcomms));
        }
 
        return subcomms;
    }

get_validate_positionals()

bool CLI::App::get_validate_positionals ( ) const

inline

Definition at line 6237 of file CLI11.hpp.

{ return validate_positionals_; }

got_subcommand() [1/2]

bool CLI::App::got_subcommand ( const App * subcom ) const

inline

Definition at line 5931 of file CLI11.hpp.

                                                 {
        // get subcom needed to verify that this was a real subcommand
        return get_subcommand(subcom)->parsed_ > 0;
    }

Here is the call graph for this function:

got_subcommand() [2/2]

bool CLI::App::got_subcommand ( std::string subcommand_name ) const

inline

Definition at line 5937 of file CLI11.hpp.

{ return get_subcommand(subcommand_name)->parsed_ > 0; }

Here is the call graph for this function:

group()

App * CLI::App::group ( std::string group_name )

inline

Definition at line 5664 of file CLI11.hpp.

                                     {
        group_ = group_name;
        return this;
    }

Here is the caller graph for this function:

help()

std::string CLI::App::help ( std::string prev = "", AppFormatMode mode = AppFormatMode::Normal ) const

inline

Makes a help message, using the currently configured formatter Will only do one subcommand at a time

Definition at line 6047 of file CLI11.hpp.

                                                                                        {
        if(prev.empty())
            prev = get_name();
        else
            prev += " " + get_name();
 
        // Delegate to subcommand if needed
        auto selected_subcommands = get_subcommands();
        if(!selected_subcommands.empty()) {
            return selected_subcommands.at(0)->help(prev, mode);
        }
        return formatter_->make_help(this, prev, mode);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

ignore_case()

App * CLI::App::ignore_case ( bool value = true )

inline

Definition at line 5009 of file CLI11.hpp.

                                        {
        if(value && !ignore_case_) {
            ignore_case_ = true;
            auto *p = (parent_ != nullptr) ? _get_fallthrough_parent() : this;
            auto &match = _compare_subcommand_names(*this, *p);
            if(!match.empty()) {
                ignore_case_ = false; // we are throwing so need to be exception invariant
                throw OptionAlreadyAdded("ignore case would cause subcommand name conflicts: " + match);
            }
        }
        ignore_case_ = value;
        return this;
    }

Here is the call graph for this function:

ignore_underscore()

App * CLI::App::ignore_underscore ( bool value = true )

inline

Definition at line 5043 of file CLI11.hpp.

                                              {
        if(value && !ignore_underscore_) {
            ignore_underscore_ = true;
            auto *p = (parent_ != nullptr) ? _get_fallthrough_parent() : this;
            auto &match = _compare_subcommand_names(*this, *p);
            if(!match.empty()) {
                ignore_underscore_ = false;
                throw OptionAlreadyAdded("ignore underscore would cause subcommand name conflicts: " + match);
            }
        }
        ignore_underscore_ = value;
        return this;
    }

Here is the call graph for this function:

immediate_callback()

App * CLI::App::immediate_callback ( bool immediate = true )

inline

Definition at line 4967 of file CLI11.hpp.

                                                   {
        immediate_callback_ = immediate;
        if(immediate_callback_) {
            if(final_callback_ && !(parse_complete_callback_)) {
                std::swap(final_callback_, parse_complete_callback_);
            }
        } else if(!(final_callback_) && parse_complete_callback_) {
            std::swap(final_callback_, parse_complete_callback_);
        }
        return this;
    }

Here is the call graph for this function:

increment_parsed()

void CLI::App::increment_parsed ( )

inlineprotected

Definition at line 6787 of file CLI11.hpp.

                            {
        ++parsed_;
        for(App_p &sub : subcommands_) {
            if(sub->get_name().empty())
                sub->increment_parsed();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

name()

App * CLI::App::name ( std::string app_name = "" )

inline

Definition at line 4889 of file CLI11.hpp.

                                       {
 
        if(parent_ != nullptr) {
            auto oname = name_;
            name_ = app_name;
            auto &res = _compare_subcommand_names(*this, *_get_fallthrough_parent());
            if(!res.empty()) {
                name_ = oname;
                throw(OptionAlreadyAdded(app_name + " conflicts with existing subcommand names"));
            }
        } else {
            name_ = app_name;
        }
        has_automatic_name_ = false;
        return this;
    }

Here is the call graph for this function:

needs() [1/2]

App * CLI::App::needs ( App * app )

inline

Definition at line 5972 of file CLI11.hpp.

                         {
        if(app == nullptr) {
            throw OptionNotFound("nullptr passed");
        }
        if(app == this) {
            throw OptionNotFound("cannot self reference in needs");
        }
        need_subcommands_.insert(app);
        return this;
    }

needs() [2/2]

App * CLI::App::needs ( Option * opt )

inline

Definition at line 5964 of file CLI11.hpp.

                            {
        if(opt == nullptr) {
            throw OptionNotFound("nullptr passed");
        }
        need_options_.insert(opt);
        return this;
    }

operator bool()

CLI::App::operator bool ( ) const

inlineexplicit

Check to see if this subcommand was parsed, true only if received on command line. This allows the subcommand to be directly checked.

Definition at line 5736 of file CLI11.hpp.

{ return parsed_ > 0; }

operator=()

App & CLI::App::operator= ( const App & )

delete

operator[]() [1/2]

const Option * CLI::App::operator[] ( const char * option_name ) const

inline

Definition at line 6178 of file CLI11.hpp.

{ return get_option(option_name); }

Here is the call graph for this function:

operator[]() [2/2]

const Option * CLI::App::operator[] ( const std::string & option_name ) const

inline

Definition at line 6175 of file CLI11.hpp.

{ return get_option(option_name); }

Here is the call graph for this function:

option_defaults()

OptionDefaults * CLI::App::option_defaults ( )

inline

Definition at line 5079 of file CLI11.hpp.

{ return &option_defaults_; }

parse() [1/4]

void CLI::App::parse ( int argc, const char *const * argv )

inline

Parses the command line - throws errors. This must be called after the options are in but before the rest of the program.

Definition at line 5769 of file CLI11.hpp.

                                                  {
        // If the name is not set, read from command line
        if(name_.empty() || has_automatic_name_) {
            has_automatic_name_ = true;
            name_ = argv[0];
        }
 
        std::vector<std::string> args;
        args.reserve(static_cast<std::size_t>(argc) - 1);
        for(int i = argc - 1; i > 0; i--)
            args.emplace_back(argv[i]);
        parse(std::move(args));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

parse() [2/4]

void CLI::App::parse ( std::string commandline, bool program_name_included = false )

inline

Parse a single string as if it contained command line arguments. This function splits the string into arguments then calls parse(std::vector<std::string> &) the function takes an optional boolean argument specifying if the programName is included in the string to process

Definition at line 5787 of file CLI11.hpp.

                                                                          {
 
        if(program_name_included) {
            auto nstr = detail::split_program_name(commandline);
            if((name_.empty()) || (has_automatic_name_)) {
                has_automatic_name_ = true;
                name_ = nstr.first;
            }
            commandline = std::move(nstr.second);
        } else
            detail::trim(commandline);
        // the next section of code is to deal with quoted arguments after an '=' or ':' for windows like operations
        if(!commandline.empty()) {
            commandline = detail::find_and_modify(commandline, "=", detail::escape_detect);
            if(allow_windows_style_options_)
                commandline = detail::find_and_modify(commandline, ":", detail::escape_detect);
        }
 
        auto args = detail::split_up(std::move(commandline));
        // remove all empty strings
        args.erase(std::remove(args.begin(), args.end(), std::string{}), args.end());
        std::reverse(args.begin(), args.end());
 
        parse(std::move(args));
    }

Here is the call graph for this function:

parse() [3/4]

void CLI::App::parse ( std::vector< std::string > && args )

inline

Definition at line 5835 of file CLI11.hpp.

                                            {
        // Clear if parsed
        if(parsed_ > 0)
            clear();
 
        // parsed_ is incremented in commands/subcommands,
        // but placed here to make sure this is cleared when
        // running parse after an error is thrown, even by _validate or _configure.
        parsed_ = 1;
        _validate();
        _configure();
        // set the parent as nullptr as this object should be the top now
        parent_ = nullptr;
        parsed_ = 0;
 
        _parse(std::move(args));
        run_callback();
    }

Here is the call graph for this function:

parse() [4/4]

void CLI::App::parse ( std::vector< std::string > & args )

inline

The real work is done here. Expects a reversed vector. Changes the vector to the remaining options.

Definition at line 5815 of file CLI11.hpp.

                                           {
        // Clear if parsed
        if(parsed_ > 0)
            clear();
 
        // parsed_ is incremented in commands/subcommands,
        // but placed here to make sure this is cleared when
        // running parse after an error is thrown, even by _validate or _configure.
        parsed_ = 1;
        _validate();
        _configure();
        // set the parent as nullptr as this object should be the top now
        parent_ = nullptr;
        parsed_ = 0;
 
        _parse(args);
        run_callback();
    }

Here is the call graph for this function:

parse_complete_callback()

App * CLI::App::parse_complete_callback ( std::function< void()> pc_callback )

inline

Set a callback to execute when parsing has completed for the app

Definition at line 4876 of file CLI11.hpp.

                                                                  {
        parse_complete_callback_ = std::move(pc_callback);
        return this;
    }

parse_order()

const std::vector< Option * > & CLI::App::parse_order ( ) const

inline

Definition at line 6322 of file CLI11.hpp.

{ return parse_order_; }

parsed()

bool CLI::App::parsed ( ) const

inline

Definition at line 5076 of file CLI11.hpp.

{ return parsed_ > 0; }

positionals_at_end()

App * CLI::App::positionals_at_end ( bool value = true )

inline

Definition at line 5031 of file CLI11.hpp.

                                               {
        positionals_at_end_ = value;
        return this;
    }

pre_callback()

virtual void CLI::App::pre_callback ( )

inlinevirtual

This allows subclasses to inject code before callbacks but after parse.

This does not run if any errors or help is thrown.

Definition at line 5745 of file CLI11.hpp.

{}

Here is the caller graph for this function:

prefix_command()

App * CLI::App::prefix_command ( bool allow = true )

inline

Definition at line 5003 of file CLI11.hpp.

                                           {
        prefix_command_ = allow;
        return this;
    }

preparse_callback()

App * CLI::App::preparse_callback ( std::function< void(std::size_t)> pp_callback )

inline

Set a callback to execute prior to parsing.

Definition at line 4883 of file CLI11.hpp.

                                                                     {
        pre_parse_callback_ = std::move(pp_callback);
        return this;
    }

Here is the caller graph for this function:

remaining()

std::vector< std::string > CLI::App::remaining ( bool recurse = false ) const

inline

Definition at line 6325 of file CLI11.hpp.

                                                               {
        std::vector<std::string> miss_list;
        for(const std::pair<detail::Classifier, std::string> &miss : missing_) {
            miss_list.push_back(std::get<1>(miss));
        }
        // Get from a subcommand that may allow extras
        if(recurse) {
            if(!allow_extras_) {
                for(const auto &sub : subcommands_) {
                    if(sub->name_.empty() && !sub->missing_.empty()) {
                        for(const std::pair<detail::Classifier, std::string> &miss : sub->missing_) {
                            miss_list.push_back(std::get<1>(miss));
                        }
                    }
                }
            }
            // Recurse into subcommands
 
            for(const App *sub : parsed_subcommands_) {
                std::vector<std::string> output = sub->remaining(recurse);
                std::copy(std::begin(output), std::end(output), std::back_inserter(miss_list));
            }
        }
        return miss_list;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

remaining_for_passthrough()

std::vector< std::string > CLI::App::remaining_for_passthrough ( bool recurse = false ) const

inline

Definition at line 6352 of file CLI11.hpp.

                                                                               {
        std::vector<std::string> miss_list = remaining(recurse);
        std::reverse(std::begin(miss_list), std::end(miss_list));
        return miss_list;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

remaining_size()

std::size_t CLI::App::remaining_size ( bool recurse = false ) const

inline

Definition at line 6359 of file CLI11.hpp.

                                                         {
        auto remaining_options = static_cast<std::size_t>(std::count_if(
            std::begin(missing_), std::end(missing_), [](const std::pair<detail::Classifier, std::string> &val) {
                return val.first != detail::Classifier::POSITIONAL_MARK;
            }));
 
        if(recurse) {
            for(const App_p &sub : subcommands_) {
                remaining_options += sub->remaining_size(recurse);
            }
        }
        return remaining_options;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

remove_excludes() [1/2]

bool CLI::App::remove_excludes ( App * app )

inline

Definition at line 5994 of file CLI11.hpp.

                                   {
        auto iterator = std::find(std::begin(exclude_subcommands_), std::end(exclude_subcommands_), app);
        if(iterator == std::end(exclude_subcommands_)) {
            return false;
        }
        auto other_app = *iterator;
        exclude_subcommands_.erase(iterator);
        other_app->remove_excludes(this);
        return true;
    }

remove_excludes() [2/2]

bool CLI::App::remove_excludes ( Option * opt )

inline

Definition at line 5984 of file CLI11.hpp.

                                      {
        auto iterator = std::find(std::begin(exclude_options_), std::end(exclude_options_), opt);
        if(iterator == std::end(exclude_options_)) {
            return false;
        }
        exclude_options_.erase(iterator);
        return true;
    }

remove_needs() [1/2]

bool CLI::App::remove_needs ( App * app )

inline

Definition at line 6016 of file CLI11.hpp.

                                {
        auto iterator = std::find(std::begin(need_subcommands_), std::end(need_subcommands_), app);
        if(iterator == std::end(need_subcommands_)) {
            return false;
        }
        need_subcommands_.erase(iterator);
        return true;
    }

remove_needs() [2/2]

bool CLI::App::remove_needs ( Option * opt )

inline

Definition at line 6006 of file CLI11.hpp.

                                   {
        auto iterator = std::find(std::begin(need_options_), std::end(need_options_), opt);
        if(iterator == std::end(need_options_)) {
            return false;
        }
        need_options_.erase(iterator);
        return true;
    }

remove_option()

bool CLI::App::remove_option ( Option * opt )

inline

Definition at line 5501 of file CLI11.hpp.

                                    {
        // Make sure no links exist
        for(Option_p &op : options_) {
            op->remove_needs(opt);
            op->remove_excludes(opt);
        }
 
        if(help_ptr_ == opt)
            help_ptr_ = nullptr;
        if(help_all_ptr_ == opt)
            help_all_ptr_ = nullptr;
 
        auto iterator =
            std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
        if(iterator != std::end(options_)) {
            options_.erase(iterator);
            return true;
        }
        return false;
    }

Here is the caller graph for this function:

remove_subcommand()

bool CLI::App::remove_subcommand ( App * subcom )

inline

Definition at line 5561 of file CLI11.hpp.

                                        {
        // Make sure no links exist
        for(App_p &sub : subcommands_) {
            sub->remove_excludes(subcom);
            sub->remove_needs(subcom);
        }
 
        auto iterator = std::find_if(
            std::begin(subcommands_), std::end(subcommands_), [subcom](const App_p &v) { return v.get() == subcom; });
        if(iterator != std::end(subcommands_)) {
            subcommands_.erase(iterator);
            return true;
        }
        return false;
    }

Here is the call graph for this function:

require_option() [1/3]

App * CLI::App::require_option ( )

inline

Definition at line 5699 of file CLI11.hpp.

                          {
        require_option_min_ = 1;
        require_option_max_ = 0;
        return this;
    }

require_option() [2/3]

App * CLI::App::require_option ( int value )

inline

Require an option to be given (does not affect help call) The number required can be given. Negative values indicate maximum number allowed (0 for any number).

Definition at line 5708 of file CLI11.hpp.

                                   {
        if(value < 0) {
            require_option_min_ = 0;
            require_option_max_ = static_cast<std::size_t>(-value);
        } else {
            require_option_min_ = static_cast<std::size_t>(value);
            require_option_max_ = static_cast<std::size_t>(value);
        }
        return this;
    }

require_option() [3/3]

App * CLI::App::require_option ( std::size_t min, std::size_t max )

inline

Explicitly control the number of options required. Setting 0 for the max means unlimited number allowed. Max number inheritable.

Definition at line 5721 of file CLI11.hpp.

                                                      {
        require_option_min_ = min;
        require_option_max_ = max;
        return this;
    }

require_subcommand() [1/3]

App * CLI::App::require_subcommand ( )

inline

Definition at line 5670 of file CLI11.hpp.

                              {
        require_subcommand_min_ = 1;
        require_subcommand_max_ = 0;
        return this;
    }

require_subcommand() [2/3]

App * CLI::App::require_subcommand ( int value )

inline

Require a subcommand to be given (does not affect help call) The number required can be given. Negative values indicate maximum number allowed (0 for any number). Max number inheritable.

Definition at line 5679 of file CLI11.hpp.

                                       {
        if(value < 0) {
            require_subcommand_min_ = 0;
            require_subcommand_max_ = static_cast<std::size_t>(-value);
        } else {
            require_subcommand_min_ = static_cast<std::size_t>(value);
            require_subcommand_max_ = static_cast<std::size_t>(value);
        }
        return this;
    }

require_subcommand() [3/3]

App * CLI::App::require_subcommand ( std::size_t min, std::size_t max )

inline

Explicitly control the number of subcommands required. Setting 0 for the max means unlimited number allowed. Max number inheritable.

Definition at line 5692 of file CLI11.hpp.

                                                          {
        require_subcommand_min_ = min;
        require_subcommand_max_ = max;
        return this;
    }

required()

App * CLI::App::required ( bool require = true )

inline

Definition at line 4933 of file CLI11.hpp.

                                       {
        required_ = require;
        return this;
    }

run_callback()

void CLI::App::run_callback ( bool final_mode = false )

inlineprotected

Definition at line 6439 of file CLI11.hpp.

                                               {
        pre_callback();
        // in the main app if immediate_callback_ is set it runs the main callback before the used subcommands
        if(!final_mode && parse_complete_callback_) {
            parse_complete_callback_();
        }
        // run the callbacks for the received subcommands
        for(App *subc : get_subcommands()) {
            subc->run_callback(true);
        }
        // now run callbacks for option_groups
        for(auto &subc : subcommands_) {
            if(subc->name_.empty() && subc->count_all() > 0) {
                subc->run_callback(true);
            }
        }
 
        // finally run the main callback
        if(final_callback_ && (parsed_ > 0)) {
            if(!name_.empty() || count_all() > 0) {
                final_callback_();
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

set_config()

Option * CLI::App::set_config ( std::string option_name = "", std::string default_filename = "", const std::string & help_message = "Read an ini file", bool config_required = false )

inline

Definition at line 5474 of file CLI11.hpp.

                                                     {
 
        // Remove existing config if present
        if(config_ptr_ != nullptr) {
            remove_option(config_ptr_);
            config_ptr_ = nullptr; // need to remove the config_ptr completely
        }
 
        // Only add config if option passed
        if(!option_name.empty()) {
            config_ptr_ = add_option(option_name, help_message);
            if(config_required) {
                config_ptr_->required();
            }
            if(!default_filename.empty()) {
                config_ptr_->default_str(std::move(default_filename));
            }
            config_ptr_->configurable(false);
        }
 
        return config_ptr_;
    }

Here is the call graph for this function:

set_help_all_flag()

Option * CLI::App::set_help_all_flag ( std::string help_name = "", const std::string & help_description = "" )

inline

Definition at line 5220 of file CLI11.hpp.

                                                                                                {
        // take flag_description by const reference otherwise add_flag tries to assign to flag_description
        if(help_all_ptr_ != nullptr) {
            remove_option(help_all_ptr_);
            help_all_ptr_ = nullptr;
        }
 
        // Empty name will simply remove the help all flag
        if(!help_name.empty()) {
            help_all_ptr_ = add_flag(help_name, help_description);
            help_all_ptr_->configurable(false);
        }
 
        return help_all_ptr_;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

set_help_flag()

Option * CLI::App::set_help_flag ( std::string flag_name = "", const std::string & help_description = "" )

inline

Definition at line 5203 of file CLI11.hpp.

                                                                                            {
        // take flag_description by const reference otherwise add_flag tries to assign to help_description
        if(help_ptr_ != nullptr) {
            remove_option(help_ptr_);
            help_ptr_ = nullptr;
        }
 
        // Empty name will simply remove the help flag
        if(!flag_name.empty()) {
            help_ptr_ = add_flag(flag_name, help_description);
            help_ptr_->configurable(false);
        }
 
        return help_ptr_;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

validate_positionals()

App * CLI::App::validate_positionals ( bool validate = true )

inline

Definition at line 4980 of file CLI11.hpp.

                                                    {
        validate_positionals_ = validate;
        return this;
    }

Here is the call graph for this function:

Member Data Documentation

aliases_

std::vector<std::string> CLI::App::aliases_ {}

protected

Definition at line 4788 of file CLI11.hpp.

{};

allow_config_extras_

config_extras_mode CLI::App::allow_config_extras_ {config_extras_mode::ignore}

protected

If ignore, allow extra arguments in the ini file (ie, don't throw an error). INHERITABLE if error error on an extra argument, and if capture feed it to the app

Definition at line 4635 of file CLI11.hpp.

{config_extras_mode::ignore};

allow_extras_

bool CLI::App::allow_extras_ {false}

protected

Definition at line 4631 of file CLI11.hpp.

{false};

allow_windows_style_options_

bool CLI::App::allow_windows_style_options_

protected

Initial value:

{
 
 
 
        false
 
    }

Definition at line 4745 of file CLI11.hpp.

                                     {
#ifdef _WIN32
        true
#else
        false
#endif
    };

config_formatter_

std::shared_ptr<Config> CLI::App::config_formatter_ {new ConfigINI()}

protected

Definition at line 4798 of file CLI11.hpp.

{new ConfigINI()};

config_ptr_

Option* CLI::App::config_ptr_ {nullptr}

protected

Definition at line 4795 of file CLI11.hpp.

{nullptr};

configurable_

bool CLI::App::configurable_ {false}

protected

Definition at line 4761 of file CLI11.hpp.

{false};

default_startup

startup_mode CLI::App::default_startup {startup_mode::stable}

protected

specify the startup mode for the app stable=no change, enabled= startup enabled, disabled=startup disabled

Definition at line 4758 of file CLI11.hpp.

{startup_mode::stable};

description_

std::string CLI::App::description_ {}

protected

Definition at line 4628 of file CLI11.hpp.

{};

disabled_

bool CLI::App::disabled_ {false}

protected

Definition at line 4647 of file CLI11.hpp.

{false};

exclude_options_

std::set<Option *> CLI::App::exclude_options_ {}

protected

This is a list of options which are exclusionary to this App, if the options were used this subcommand should not be

Definition at line 4718 of file CLI11.hpp.

{};

exclude_subcommands_

std::set<App *> CLI::App::exclude_subcommands_ {}

protected

Definition at line 4714 of file CLI11.hpp.

{};

failure_message_

std::function<std::string(const App *, const Error &e)> CLI::App::failure_message_ {FailureMessage::simple}

protected

Definition at line 4694 of file CLI11.hpp.

{FailureMessage::simple};

fallthrough_

bool CLI::App::fallthrough_ {false}

protected

Definition at line 4742 of file CLI11.hpp.

{false};

final_callback_

std::function<void()> CLI::App::final_callback_ {}

protected

Definition at line 4662 of file CLI11.hpp.

{};

footer_

std::string CLI::App::footer_ {}

protected

Definition at line 4679 of file CLI11.hpp.

{};

footer_callback_

std::function<std::string()> CLI::App::footer_callback_ {}

protected

Definition at line 4682 of file CLI11.hpp.

{};

formatter_

std::shared_ptr<FormatterBase> CLI::App::formatter_ {new Formatter()}

protected

Definition at line 4691 of file CLI11.hpp.

{new Formatter()};

group_

std::string CLI::App::group_ {"Subcommands"}

protected

Definition at line 4785 of file CLI11.hpp.

{"Subcommands"};

has_automatic_name_

bool CLI::App::has_automatic_name_ {false}

protected

Definition at line 4641 of file CLI11.hpp.

{false};

help_all_ptr_

Option* CLI::App::help_all_ptr_ {nullptr}

protected

Definition at line 4688 of file CLI11.hpp.

{nullptr};

help_ptr_

Option* CLI::App::help_ptr_ {nullptr}

protected

Definition at line 4685 of file CLI11.hpp.

{nullptr};

ignore_case_

bool CLI::App::ignore_case_ {false}

protected

Definition at line 4736 of file CLI11.hpp.

{false};

ignore_underscore_

bool CLI::App::ignore_underscore_ {false}

protected

Definition at line 4739 of file CLI11.hpp.

{false};

immediate_callback_

bool CLI::App::immediate_callback_ {false}

protected

Flag indicating that the callback for the subcommand should be executed immediately on parse completion which is before help or ini files are processed. INHERITABLE

Definition at line 4654 of file CLI11.hpp.

{false};

missing_

missing_t CLI::App::missing_ {}

protected

Pair of classifier, string for missing options. (extra detail is removed on returning from parse)

This is faster and cleaner than storing just a list of strings and reparsing. This may contain the – separator.

Definition at line 4705 of file CLI11.hpp.

{};

name_

std::string CLI::App::name_ {}

protected

Definition at line 4625 of file CLI11.hpp.

{};

need_options_

std::set<Option *> CLI::App::need_options_ {}

protected

This is a list of options which are required by this app, the list is not mutual, listed options do not need the subcommand not be

Definition at line 4726 of file CLI11.hpp.

{};

need_subcommands_

std::set<App *> CLI::App::need_subcommands_ {}

protected

this is a list of subcommands or option groups that are required by this one, the list is not mutual, the listed subcommands do not require this one

Definition at line 4722 of file CLI11.hpp.

{};

option_defaults_

OptionDefaults CLI::App::option_defaults_ {}

protected

Definition at line 4669 of file CLI11.hpp.

{};

options_

std::vector<Option_p> CLI::App::options_ {}

protected

Definition at line 4672 of file CLI11.hpp.

{};

parent_

App* CLI::App::parent_ {nullptr}

protected

Definition at line 4767 of file CLI11.hpp.

{nullptr};

parse_complete_callback_

std::function<void()> CLI::App::parse_complete_callback_ {}

protected

Definition at line 4660 of file CLI11.hpp.

{};

parse_order_

std::vector<Option *> CLI::App::parse_order_ {}

protected

Definition at line 4708 of file CLI11.hpp.

{};

parsed_

std::size_t CLI::App::parsed_ {0}

protected

Definition at line 4770 of file CLI11.hpp.

{0};

parsed_subcommands_

std::vector<App *> CLI::App::parsed_subcommands_ {}

protected

Definition at line 4711 of file CLI11.hpp.

{};

positionals_at_end_

bool CLI::App::positionals_at_end_ {false}

protected

Definition at line 4753 of file CLI11.hpp.

{false};

pre_parse_callback_

std::function<void(std::size_t)> CLI::App::pre_parse_callback_ {}

protected

Definition at line 4657 of file CLI11.hpp.

{};

pre_parse_called_

bool CLI::App::pre_parse_called_ {false}

protected

Definition at line 4650 of file CLI11.hpp.

{false};

prefix_command_

bool CLI::App::prefix_command_ {false}

protected

Definition at line 4638 of file CLI11.hpp.

{false};

require_option_max_

std::size_t CLI::App::require_option_max_ {0}

protected

Definition at line 4782 of file CLI11.hpp.

{0};

require_option_min_

std::size_t CLI::App::require_option_min_ {0}

protected

Definition at line 4779 of file CLI11.hpp.

{0};

require_subcommand_max_

std::size_t CLI::App::require_subcommand_max_ {0}

protected

Definition at line 4776 of file CLI11.hpp.

{0};

require_subcommand_min_

std::size_t CLI::App::require_subcommand_min_ {0}

protected

Definition at line 4773 of file CLI11.hpp.

{0};

required_

bool CLI::App::required_ {false}

protected

Definition at line 4644 of file CLI11.hpp.

{false};

subcommands_

std::vector<App_p> CLI::App::subcommands_ {}

protected

Definition at line 4733 of file CLI11.hpp.

{};

validate_positionals_

bool CLI::App::validate_positionals_ {false}

protected

Definition at line 4764 of file CLI11.hpp.

{false};

---

The documentation for this class was generated from the following file:

• programs/clio/CLI11.hpp