15#include "../Encoding.hpp"
28CLI11_INLINE
App::App(std::string app_description, std::string app_name,
App *parent)
29 : name_(std::move(app_name)), description_(std::move(app_description)), parent_(parent) {
66 normalized_argv_ = detail::compute_win32_argv();
68 if(!normalized_argv_view_.empty()) {
69 normalized_argv_view_.clear();
72 normalized_argv_view_.reserve(normalized_argv_.size());
73 for(
auto &arg : normalized_argv_) {
75 normalized_argv_view_.push_back(
const_cast<char *
>(arg.data()));
78 return normalized_argv_view_.data();
87 std::string oname =
name_;
102 if(app_name.empty() || !detail::valid_alias_name_string(app_name)) {
110 throw(
OptionAlreadyAdded(
"alias already matches an existing subcommand: " + app_name));
138 throw OptionAlreadyAdded(
"ignore case would cause subcommand name conflicts: " + match);
152 throw OptionAlreadyAdded(
"ignore underscore would cause subcommand name conflicts: " + match);
160 callback_t option_callback,
161 std::string option_description,
163 std::function<std::string()> func) {
164 Option myopt{option_name, option_description, option_callback,
this};
166 if(std::find_if(std::begin(
options_), std::end(
options_), [&myopt](
const Option_p &v) {
return *v == myopt; }) ==
168 if(myopt.lnames_.empty() && myopt.snames_.empty()) {
172 if(test_name.size() == 3) {
173 test_name.erase(0, 1);
178 throw(
OptionAlreadyAdded(
"added option positional name matches existing option: " + test_name));
180 }
else if(
parent_ !=
nullptr) {
181 for(
auto &ln : myopt.lnames_) {
187 for(
auto &sn : myopt.snames_) {
196 option.reset(
new Option(option_name, option_description, option_callback,
this));
209 if(!defaulted && option->get_always_capture_default())
210 option->capture_default_str();
216 const auto &matchname = opt->matching_name(myopt);
217 if(!matchname.empty()) {
233 if(!flag_name.empty()) {
249 if(!help_name.empty()) {
266 if(!flag_name.empty()) {
268 flag_name, [versionString]() {
throw(
CLI::CallForVersion(versionString, 0)); }, version_help);
283 if(!flag_name.empty()) {
292CLI11_INLINE
Option *App::_add_flag_internal(std::string flag_name, CLI::callback_t fun, std::string flag_description) {
294 if(detail::has_default_flag_values(flag_name)) {
296 auto flag_defaults = detail::get_default_flag_values(flag_name);
297 detail::remove_default_flag_values(flag_name);
298 opt =
add_option(std::move(flag_name), std::move(fun), std::move(flag_description),
false);
299 for(
const auto &fname : flag_defaults)
300 opt->fnames_.push_back(fname.first);
301 opt->default_flag_values_ = std::move(flag_defaults);
303 opt =
add_option(std::move(flag_name), std::move(fun), std::move(flag_description),
false);
307 auto pos_name = opt->
get_name(
true);
309 throw IncorrectConstruction::PositionalFlag(pos_name);
318 std::function<
void(
void)> function,
319 std::string flag_description) {
321 CLI::callback_t fun = [function](
const CLI::results_t &res) {
322 using CLI::detail::lexical_cast;
324 auto result = lexical_cast(res[0], trigger);
325 if(result && trigger) {
330 return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description));
335 std::function<
void(std::int64_t)> function,
336 std::string flag_description) {
338 CLI::callback_t fun = [function](
const CLI::results_t &res) {
339 using CLI::detail::lexical_cast;
340 std::int64_t flag_count{0};
341 lexical_cast(res[0], flag_count);
342 function(flag_count);
345 return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description))
350 std::string default_filename,
351 const std::string &help_message,
352 bool config_required) {
361 if(!option_name.empty()) {
363 if(config_required) {
366 if(!default_filename.empty()) {
381 op->remove_needs(opt);
382 op->remove_excludes(opt);
391 std::find_if(std::begin(
options_), std::end(
options_), [opt](
const Option_p &v) {
return v.get() == opt; });
392 if(iterator != std::end(
options_)) {
400 if(!subcommand_name.empty() && !detail::valid_name_string(subcommand_name)) {
401 if(!detail::valid_first_char(subcommand_name[0])) {
403 "Subcommand name starts with invalid character, '!' and '-' and control characters");
405 for(
auto c : subcommand_name) {
406 if(!detail::valid_later_char(c)) {
408 "'), all characters are allowed except"
409 "'=',':','{','}', ' ', and control characters");
413 CLI::App_p subcom = std::shared_ptr<App>(
new App(std::move(subcommand_description), subcommand_name,
this));
423 throw(
OptionAlreadyAdded(
"subcommand name or alias matches existing subcommand: " + mstrg));
425 subcom->parent_ =
this;
433 sub->remove_excludes(subcom);
434 sub->remove_needs(subcom);
437 auto iterator = std::find_if(
447 if(subcom ==
nullptr)
450 if(subcomptr.get() == subcom)
451 return subcomptr.get();
463 return _find_subcommand(subcom,
false,
false);
468 auto uindex =
static_cast<unsigned>(index);
476 if(subcom ==
nullptr)
479 if(subcomptr.get() == subcom)
486 if(subcomptr->check_name(subcom))
493 auto uindex =
static_cast<unsigned>(index);
502 if(app->name_.empty() && app->group_ == group_name) {
515 cnt += sub->count_all();
530 for(
const Option_p &opt :
options_) {
538CLI11_INLINE
void App::parse(
int argc,
const char *
const *argv) { parse_char_t(argc, argv); }
539CLI11_INLINE
void App::parse(
int argc,
const wchar_t *
const *argv) { parse_char_t(argc, argv); }
544CLI11_INLINE
const char *maybe_narrow(
const char *str) {
return str; }
545CLI11_INLINE std::string maybe_narrow(
const wchar_t *str) {
return narrow(str); }
549template <
class CharT> CLI11_INLINE
void App::parse_char_t(
int argc,
const CharT *
const *argv) {
553 name_ = detail::maybe_narrow(argv[0]);
556 std::vector<std::string> args;
557 args.reserve(
static_cast<std::size_t
>(argc) - 1U);
558 for(
auto i =
static_cast<std::size_t
>(argc) - 1U; i > 0U; --i)
559 args.emplace_back(detail::maybe_narrow(argv[i]));
561 parse(std::move(args));
564CLI11_INLINE
void App::parse(std::string commandline,
bool program_name_included) {
566 if(program_name_included) {
567 auto nstr = detail::split_program_name(commandline);
572 commandline = std::move(nstr.second);
574 detail::trim(commandline);
577 if(!commandline.empty()) {
578 commandline = detail::find_and_modify(commandline,
"=", detail::escape_detect);
580 commandline = detail::find_and_modify(commandline,
":", detail::escape_detect);
583 auto args = detail::split_up(std::move(commandline));
585 args.erase(std::remove(args.begin(), args.end(), std::string{}), args.end());
587 detail::remove_quotes(args);
588 }
catch(
const std::invalid_argument &arg) {
591 std::reverse(args.begin(), args.end());
592 parse(std::move(args));
595CLI11_INLINE
void App::parse(std::wstring commandline,
bool program_name_included) {
596 parse(narrow(commandline), program_name_included);
599CLI11_INLINE
void App::parse(std::vector<std::string> &args) {
618CLI11_INLINE
void App::parse(std::vector<std::string> &&args) {
637CLI11_INLINE
void App::parse_from_stream(std::istream &input) {
648CLI11_INLINE
int App::exit(
const Error &e, std::ostream &out, std::ostream &err)
const {
651 if(e.get_name() ==
"RuntimeError")
652 return e.get_exit_code();
654 if(e.get_name() ==
"CallForHelp") {
656 return e.get_exit_code();
659 if(e.get_name() ==
"CallForAllHelp") {
660 out <<
help(
"", AppFormatMode::All);
661 return e.get_exit_code();
664 if(e.get_name() ==
"CallForVersion") {
665 out << e.what() <<
'\n';
666 return e.get_exit_code();
669 if(e.get_exit_code() !=
static_cast<int>(ExitCodes::Success)) {
674 return e.get_exit_code();
683 subcomms.erase(std::remove_if(std::begin(subcomms),
685 [&filter](
const App *app) {
return !filter(app); }),
699 std::remove_if(std::begin(subcomms), std::end(subcomms), [&filter](
App *app) {
return !filter(app); }),
720 auto *other_app = *iterator;
722 other_app->remove_excludes(
this);
744CLI11_NODISCARD CLI11_INLINE std::string
App::help(std::string prev, AppFormatMode mode)
const {
752 if(!selected_subcommands.empty()) {
753 return selected_subcommands.back()->help(prev, mode);
755 return formatter_->make_help(
this, prev, mode);
777 std::vector<const Option *> options(
options_.size());
779 std::begin(
options_), std::end(
options_), std::begin(options), [](
const Option_p &val) {
return val.get(); });
782 options.erase(std::remove_if(std::begin(options),
784 [&filter](
const Option *opt) {
return !filter(opt); }),
792 std::vector<Option *> options(
options_.size());
794 std::begin(
options_), std::end(
options_), std::begin(options), [](
const Option_p &val) {
return val.get(); });
798 std::remove_if(std::begin(options), std::end(options), [&filter](
Option *opt) {
return !filter(opt); }),
806 for(Option_p &opt : options_) {
807 if(opt->check_name(option_name)) {
811 for(
auto &subc : subcommands_) {
813 if(subc->get_name().empty()) {
814 auto *opt = subc->get_option_no_throw(option_name);
824 for(
const Option_p &opt : options_) {
825 if(opt->check_name(option_name)) {
829 for(
const auto &subc : subcommands_) {
831 if(subc->get_name().empty()) {
832 auto *opt = subc->get_option_no_throw(option_name);
843 return std::string(
"[Option Group: ") +
get_group() +
"]";
845 if(
aliases_.empty() || !with_aliases) {
848 std::string dispname =
name_;
849 for(
const auto &lalias :
aliases_) {
850 dispname.push_back(
',');
851 dispname.push_back(
' ');
852 dispname.append(lalias);
858 std::string local_name =
name_;
860 local_name = detail::remove_underscore(
name_);
861 name_to_check = detail::remove_underscore(name_to_check);
864 local_name = detail::to_lower(
name_);
865 name_to_check = detail::to_lower(name_to_check);
868 if(local_name == name_to_check) {
873 les = detail::remove_underscore(les);
876 les = detail::to_lower(les);
878 if(les == name_to_check) {
886 std::vector<std::string> groups;
888 for(
const Option_p &opt :
options_) {
890 if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
891 groups.push_back(opt->get_group());
898CLI11_NODISCARD CLI11_INLINE std::vector<std::string>
App::remaining(
bool recurse)
const {
899 std::vector<std::string> miss_list;
900 for(
const std::pair<detail::Classifier, std::string> &miss :
missing_) {
901 miss_list.push_back(std::get<1>(miss));
907 if(sub->name_.empty() && !sub->missing_.empty()) {
908 for(
const std::pair<detail::Classifier, std::string> &miss : sub->missing_) {
909 miss_list.push_back(std::get<1>(miss));
917 std::vector<std::string> output = sub->remaining(recurse);
918 std::copy(std::begin(output), std::end(output), std::back_inserter(miss_list));
925 std::vector<std::string> miss_list =
remaining(recurse);
926 std::reverse(std::begin(miss_list), std::end(miss_list));
931 auto remaining_options =
static_cast<std::size_t
>(std::count_if(
932 std::begin(
missing_), std::end(
missing_), [](
const std::pair<detail::Classifier, std::string> &val) {
933 return val.first != detail::Classifier::POSITIONAL_MARK;
938 remaining_options += sub->remaining_size(recurse);
941 return remaining_options;
946 auto pcount = std::count_if(std::begin(
options_), std::end(
options_), [](
const Option_p &opt) {
947 return opt->get_items_expected_max() >= detail::expected_max_vector_size && !opt->nonpositional();
950 auto pcount_req = std::count_if(std::begin(
options_), std::end(
options_), [](
const Option_p &opt) {
951 return opt->get_items_expected_max() >= detail::expected_max_vector_size && !opt->nonpositional() &&
954 if(pcount - pcount_req > 1) {
959 std::size_t nameless_subs{0};
962 if(app->get_name().empty())
969 throw(
InvalidError(
"Required min options greater than required max options", ExitCodes::InvalidError));
974 InvalidError(
"Required min options greater than number of available options", ExitCodes::InvalidError));
986 if(app->has_automatic_name_) {
989 if(app->name_.empty()) {
990 app->fallthrough_ =
false;
991 app->prefix_command_ =
false;
1007 if(subc->parent_ ==
this) {
1008 subc->run_callback(
true, suppress_final_callback);
1013 if(subc->name_.empty() && subc->count_all() > 0) {
1014 subc->run_callback(
true, suppress_final_callback);
1032 if(com !=
nullptr) {
1039CLI11_NODISCARD CLI11_INLINE detail::Classifier
App::_recognize(
const std::string ¤t,
1040 bool ignore_used_subcommands)
const {
1041 std::string dummy1, dummy2;
1044 return detail::Classifier::POSITIONAL_MARK;
1046 return detail::Classifier::SUBCOMMAND;
1047 if(detail::split_long(current, dummy1, dummy2))
1048 return detail::Classifier::LONG;
1049 if(detail::split_short(current, dummy1, dummy2)) {
1050 if(dummy1[0] >=
'0' && dummy1[0] <=
'9') {
1052 return detail::Classifier::NONE;
1055 return detail::Classifier::SHORT;
1058 return detail::Classifier::WINDOWS_STYLE;
1059 if((current ==
"++") && !
name_.empty() &&
parent_ !=
nullptr)
1060 return detail::Classifier::SUBCOMMAND_TERMINATOR;
1061 auto dotloc = current.find_first_of(
'.');
1062 if(dotloc != std::string::npos) {
1063 auto *cm =
_find_subcommand(current.substr(0, dotloc),
true, ignore_used_subcommands);
1065 auto res = cm->_recognize(current.substr(dotloc + 1), ignore_used_subcommands);
1066 if(res == detail::Classifier::SUBCOMMAND) {
1071 return detail::Classifier::NONE;
1075 auto path_result = detail::check_path(config_file.c_str());
1076 if(path_result == detail::path_type::file) {
1087 }
else if(throw_error) {
1088 throw FileError::Missing(config_file);
1100 if(!ename_string.empty()) {
1106 auto config_files =
config_ptr_->
as<std::vector<std::string>>();
1107 bool files_used{file_given};
1108 if(config_files.empty() || config_files.front().empty()) {
1109 if(config_required) {
1110 throw FileError(
"config file is required but none was given");
1114 for(
const auto &config_file : config_files) {
1131 for(
const Option_p &opt :
options_) {
1132 if(opt->count() == 0 && !opt->envname_.empty()) {
1133 std::string ename_string = detail::get_environment_value(opt->envname_);
1134 if(!ename_string.empty()) {
1135 std::string result = ename_string;
1136 result = opt->_validate(result, 0);
1137 if(result.empty()) {
1138 opt->add_result(ename_string);
1145 if(sub->get_name().empty() || (sub->count_all() > 0 && !sub->parse_complete_callback_)) {
1147 sub->_process_env();
1156 if(sub->get_name().empty() && sub->parse_complete_callback_) {
1157 if(sub->count_all() > 0) {
1158 sub->_process_callbacks();
1159 sub->run_callback();
1164 for(
const Option_p &opt :
options_) {
1165 if((*opt) && !opt->get_callback_run()) {
1166 opt->run_callback();
1170 if(!sub->parse_complete_callback_) {
1171 sub->_process_callbacks();
1180 if(help_ptr !=
nullptr && help_ptr->count() > 0)
1181 trigger_help =
true;
1182 if(help_all_ptr !=
nullptr && help_all_ptr->count() > 0)
1183 trigger_all_help =
true;
1188 sub->_process_help_flags(trigger_help, trigger_all_help);
1191 }
else if(trigger_all_help) {
1193 }
else if(trigger_help) {
1200 bool excluded{
false};
1201 std::string excluder;
1203 if(opt->count() > 0) {
1205 excluder = opt->get_name();
1209 if(subc->count_all() > 0) {
1211 excluder = subc->get_display_name();
1223 bool missing_needed{
false};
1224 std::string missing_need;
1226 if(opt->count() == 0) {
1227 missing_needed =
true;
1228 missing_need = opt->get_name();
1232 if(subc->count_all() == 0) {
1233 missing_needed =
true;
1234 missing_need = subc->get_display_name();
1237 if(missing_needed) {
1245 std::size_t used_options = 0;
1246 for(
const Option_p &opt :
options_) {
1248 if(opt->count() != 0) {
1252 if(opt->get_required() && opt->count() == 0) {
1256 for(
const Option *opt_req : opt->needs_)
1257 if(opt->count() > 0 && opt_req->count() == 0)
1260 for(
const Option *opt_ex : opt->excludes_)
1261 if(opt->count() > 0 && opt_ex->count() != 0)
1278 if(sub->name_.empty() && sub->count_all() > 0) {
1284 auto option_list = detail::join(
options_, [
this](
const Option_p &ptr) {
1286 return std::string{};
1288 return ptr->get_name(
false,
true);
1291 auto subc_list =
get_subcommands([](
App *app) {
return ((app->get_name().empty()) && (!app->disabled_)); });
1292 if(!subc_list.empty()) {
1293 option_list +=
"," + detail::join(subc_list, [](
const App *app) {
return app->get_display_name(); });
1299 for(App_p &sub : subcommands_) {
1302 if(sub->name_.empty() && sub->required_ ==
false) {
1303 if(sub->count_all() == 0) {
1304 if(require_option_min_ > 0 && require_option_min_ <= used_options) {
1309 if(require_option_max_ > 0 && used_options >= require_option_min_) {
1316 if(sub->count() > 0 || sub->name_.empty()) {
1317 sub->_process_requirements();
1320 if(sub->required_ && sub->count_all() == 0) {
1326CLI11_INLINE
void App::_process() {
1330 _process_config_file();
1337 _process_callbacks();
1338 _process_help_flags();
1342 _process_callbacks();
1343 _process_help_flags();
1345 _process_requirements();
1348CLI11_INLINE
void App::_process_extras() {
1349 if(!(allow_extras_ || prefix_command_)) {
1350 std::size_t num_left_over = remaining_size();
1351 if(num_left_over > 0) {
1356 for(App_p &sub : subcommands_) {
1357 if(sub->count() > 0)
1358 sub->_process_extras();
1362CLI11_INLINE
void App::_process_extras(std::vector<std::string> &args) {
1363 if(!(allow_extras_ || prefix_command_)) {
1364 std::size_t num_left_over = remaining_size();
1365 if(num_left_over > 0) {
1366 args = remaining(
false);
1371 for(App_p &sub : subcommands_) {
1372 if(sub->count() > 0)
1373 sub->_process_extras(args);
1377CLI11_INLINE
void App::increment_parsed() {
1379 for(App_p &sub : subcommands_) {
1380 if(sub->get_name().empty())
1381 sub->increment_parsed();
1385CLI11_INLINE
void App::_parse(std::vector<std::string> &args) {
1387 _trigger_pre_parse(args.size());
1388 bool positional_only =
false;
1390 while(!args.empty()) {
1391 if(!_parse_single(args, positional_only)) {
1396 if(parent_ ==
nullptr) {
1400 _process_extras(args);
1403 args = remaining_for_passthrough(
false);
1404 }
else if(parse_complete_callback_) {
1406 _process_callbacks();
1407 _process_help_flags();
1408 _process_requirements();
1409 run_callback(
false,
true);
1413CLI11_INLINE
void App::_parse(std::vector<std::string> &&args) {
1417 _trigger_pre_parse(args.size());
1418 bool positional_only =
false;
1420 while(!args.empty()) {
1421 _parse_single(args, positional_only);
1429CLI11_INLINE
void App::_parse_stream(std::istream &input) {
1430 auto values = config_formatter_->from_config(input);
1431 _parse_config(values);
1433 _trigger_pre_parse(values.size());
1440CLI11_INLINE
void App::_parse_config(
const std::vector<ConfigItem> &args) {
1442 if(!_parse_single_config(item) && allow_config_extras_ == config_extras_mode::error)
1443 throw ConfigError::Extras(item.fullname());
1447CLI11_INLINE
bool App::_parse_single_config(
const ConfigItem &item, std::size_t level) {
1449 if(level < item.parents.size()) {
1450 auto *subcom = get_subcommand_no_throw(item.parents.at(level));
1451 return (subcom !=
nullptr) ? subcom->_parse_single_config(item, level + 1) :
false;
1454 if(item.name ==
"++") {
1457 _trigger_pre_parse(2);
1458 if(parent_ !=
nullptr) {
1459 parent_->parsed_subcommands_.push_back(
this);
1465 if(item.name ==
"--") {
1466 if(configurable_ && parse_complete_callback_) {
1467 _process_callbacks();
1468 _process_requirements();
1473 Option *op = get_option_no_throw(
"--" + item.name);
1475 if(item.name.size() == 1) {
1476 op = get_option_no_throw(
"-" + item.name);
1479 op = get_option_no_throw(item.name);
1485 if(get_allow_config_extras() == config_extras_mode::capture) {
1487 missing_.emplace_back(detail::Classifier::NONE, item.fullname());
1488 for(
const auto &input : item.inputs) {
1489 missing_.emplace_back(detail::Classifier::NONE, input);
1495 if(!op->get_configurable()) {
1496 if(get_allow_config_extras() == config_extras_mode::ignore_all) {
1499 throw ConfigError::NotConfigurable(item.fullname());
1504 if(op->get_expected_min() == 0) {
1505 if(item.inputs.size() <= 1) {
1507 auto res = config_formatter_->to_flag(item);
1508 bool converted{
false};
1509 if(op->get_disable_flag_override()) {
1510 auto val = detail::to_flag_value(res);
1512 res = op->get_flag_value(item.name,
"{}");
1519 res = op->get_flag_value(item.name, res);
1522 op->add_result(res);
1525 if(
static_cast<int>(item.inputs.size()) > op->get_items_expected_max() &&
1526 op->get_multi_option_policy() != MultiOptionPolicy::TakeAll) {
1527 if(op->get_items_expected_max() > 1) {
1528 throw ArgumentMismatch::AtMost(item.fullname(), op->get_items_expected_max(), item.inputs.size());
1531 if(!op->get_disable_flag_override()) {
1532 throw ConversionError::TooManyInputsFlag(item.fullname());
1536 for(
const auto &res : item.inputs) {
1537 bool valid_value{
false};
1538 if(op->default_flag_values_.empty()) {
1539 if(res ==
"true" || res ==
"false" || res ==
"1" || res ==
"0") {
1543 for(
const auto &valid_res : op->default_flag_values_) {
1544 if(valid_res.second == res) {
1552 op->add_result(res);
1560 op->add_result(item.inputs);
1567CLI11_INLINE
bool App::_parse_single(std::vector<std::string> &args,
bool &positional_only) {
1569 detail::Classifier classifier = positional_only ? detail::Classifier::NONE : _recognize(args.back());
1570 switch(classifier) {
1571 case detail::Classifier::POSITIONAL_MARK:
1573 positional_only =
true;
1574 if((!_has_remaining_positionals()) && (parent_ !=
nullptr)) {
1577 _move_to_missing(classifier,
"--");
1580 case detail::Classifier::SUBCOMMAND_TERMINATOR:
1585 case detail::Classifier::SUBCOMMAND:
1586 retval = _parse_subcommand(args);
1588 case detail::Classifier::LONG:
1589 case detail::Classifier::SHORT:
1590 case detail::Classifier::WINDOWS_STYLE:
1592 retval = _parse_arg(args, classifier,
false);
1594 case detail::Classifier::NONE:
1596 retval = _parse_positional(args,
false);
1597 if(retval && positionals_at_end_) {
1598 positional_only =
true;
1603 throw HorribleError(
"unrecognized classifier (you should not see this!)");
1609CLI11_NODISCARD CLI11_INLINE std::size_t App::_count_remaining_positionals(
bool required_only)
const {
1610 std::size_t retval = 0;
1611 for(
const Option_p &opt : options_) {
1612 if(opt->get_positional() && (!required_only || opt->get_required())) {
1613 if(opt->get_items_expected_min() > 0 &&
static_cast<int>(opt->count()) < opt->get_items_expected_min()) {
1614 retval +=
static_cast<std::size_t
>(opt->get_items_expected_min()) - opt->count();
1621CLI11_NODISCARD CLI11_INLINE
bool App::_has_remaining_positionals()
const {
1622 for(
const Option_p &opt : options_) {
1623 if(opt->get_positional() && ((
static_cast<int>(opt->count()) < opt->get_items_expected_min()))) {
1631CLI11_INLINE
bool App::_parse_positional(std::vector<std::string> &args,
bool haltOnSubcommand) {
1633 const std::string &positional = args.back();
1636 if(positionals_at_end_) {
1638 auto arg_rem = args.size();
1639 auto remreq = _count_remaining_positionals(
true);
1640 if(arg_rem <= remreq) {
1641 for(
const Option_p &opt : options_) {
1642 if(opt->get_positional() && opt->required_) {
1643 if(
static_cast<int>(opt->count()) < opt->get_items_expected_min()) {
1644 if(validate_positionals_) {
1645 std::string pos = positional;
1646 pos = opt->_validate(pos, 0);
1658 if(posOpt ==
nullptr) {
1659 for(
const Option_p &opt : options_) {
1661 if(opt->get_positional() &&
1662 (
static_cast<int>(opt->count()) < opt->get_items_expected_min() || opt->get_allow_extra_args())) {
1663 if(validate_positionals_) {
1664 std::string pos = positional;
1665 pos = opt->_validate(pos, 0);
1675 if(posOpt !=
nullptr) {
1676 parse_order_.push_back(posOpt);
1677 if(posOpt->get_inject_separator()) {
1678 if(!posOpt->results().empty() && !posOpt->results().back().empty()) {
1679 posOpt->add_result(std::string{});
1682 if(posOpt->get_trigger_on_parse() && posOpt->current_option_state_ == Option::option_state::callback_run) {
1685 posOpt->add_result(positional);
1686 if(posOpt->get_trigger_on_parse()) {
1687 posOpt->run_callback();
1694 for(
auto &subc : subcommands_) {
1695 if((subc->name_.empty()) && (!subc->disabled_)) {
1696 if(subc->_parse_positional(args,
false)) {
1697 if(!subc->pre_parse_called_) {
1698 subc->_trigger_pre_parse(args.size());
1705 if(parent_ !=
nullptr && fallthrough_)
1706 return _get_fallthrough_parent()->_parse_positional(args,
static_cast<bool>(parse_complete_callback_));
1709 auto *com = _find_subcommand(args.back(),
true,
false);
1710 if(com !=
nullptr && (require_subcommand_max_ == 0 || require_subcommand_max_ > parsed_subcommands_.size())) {
1711 if(haltOnSubcommand) {
1720 auto *parent_app = (parent_ !=
nullptr) ? _get_fallthrough_parent() :
this;
1721 com = parent_app->_find_subcommand(args.back(),
true,
false);
1722 if(com !=
nullptr && (com->parent_->require_subcommand_max_ == 0 ||
1723 com->parent_->require_subcommand_max_ > com->parent_->parsed_subcommands_.size())) {
1727 if(positionals_at_end_) {
1731 if(parent_ !=
nullptr && name_.empty()) {
1735 _move_to_missing(detail::Classifier::NONE, positional);
1737 if(prefix_command_) {
1738 while(!args.empty()) {
1739 _move_to_missing(detail::Classifier::NONE, args.back());
1747CLI11_NODISCARD CLI11_INLINE
App *
1748App::_find_subcommand(
const std::string &subc_name,
bool ignore_disabled,
bool ignore_used)
const noexcept {
1749 for(
const App_p &com : subcommands_) {
1750 if(com->disabled_ && ignore_disabled)
1752 if(com->get_name().empty()) {
1753 auto *subc = com->
_find_subcommand(subc_name, ignore_disabled, ignore_used);
1754 if(subc !=
nullptr) {
1758 if(com->check_name(subc_name)) {
1759 if((!*com) || !ignore_used)
1766CLI11_INLINE
bool App::_parse_subcommand(std::vector<std::string> &args) {
1767 if(_count_remaining_positionals(
true) > 0) {
1768 _parse_positional(args,
false);
1771 auto *com = _find_subcommand(args.back(),
true,
true);
1772 if(com ==
nullptr) {
1774 auto dotloc = args.back().find_first_of(
'.');
1775 if(dotloc != std::string::npos) {
1776 com = _find_subcommand(args.back().substr(0, dotloc),
true,
true);
1777 if(com !=
nullptr) {
1778 args.back() = args.back().substr(dotloc + 1);
1779 args.push_back(com->get_display_name());
1783 if(com !=
nullptr) {
1786 parsed_subcommands_.push_back(com);
1789 auto *parent_app = com->parent_;
1790 while(parent_app !=
this) {
1791 parent_app->_trigger_pre_parse(args.size());
1793 parent_app->parsed_subcommands_.push_back(com);
1795 parent_app = parent_app->parent_;
1800 if(parent_ ==
nullptr)
1801 throw HorribleError(
"Subcommand " + args.back() +
" missing");
1806App::_parse_arg(std::vector<std::string> &args, detail::Classifier current_type,
bool local_processing_only) {
1808 std::string current = args.back();
1810 std::string arg_name;
1814 switch(current_type) {
1815 case detail::Classifier::LONG:
1816 if(!detail::split_long(current, arg_name, value))
1817 throw HorribleError(
"Long parsed but missing (you should not see this):" + args.back());
1819 case detail::Classifier::SHORT:
1820 if(!detail::split_short(current, arg_name, rest))
1821 throw HorribleError(
"Short parsed but missing! You should not see this");
1823 case detail::Classifier::WINDOWS_STYLE:
1824 if(!detail::split_windows_style(current, arg_name, value))
1825 throw HorribleError(
"windows option parsed but missing! You should not see this");
1827 case detail::Classifier::SUBCOMMAND:
1828 case detail::Classifier::SUBCOMMAND_TERMINATOR:
1829 case detail::Classifier::POSITIONAL_MARK:
1830 case detail::Classifier::NONE:
1832 throw HorribleError(
"parsing got called with invalid option! You should not see this");
1835 auto op_ptr = std::find_if(std::begin(options_), std::end(options_), [arg_name, current_type](
const Option_p &opt) {
1836 if(current_type == detail::Classifier::LONG)
1837 return opt->check_lname(arg_name);
1838 if(current_type == detail::Classifier::SHORT)
1839 return opt->check_sname(arg_name);
1841 return opt->check_lname(arg_name) || opt->check_sname(arg_name);
1845 if(op_ptr == std::end(options_)) {
1846 for(
auto &subc : subcommands_) {
1847 if(subc->name_.empty() && !subc->disabled_) {
1848 if(subc->_parse_arg(args, current_type, local_processing_only)) {
1849 if(!subc->pre_parse_called_) {
1850 subc->_trigger_pre_parse(args.size());
1858 if(parent_ !=
nullptr && name_.empty()) {
1863 auto dotloc = arg_name.find_first_of(
'.', 1);
1864 if(dotloc != std::string::npos) {
1866 auto *sub = _find_subcommand(arg_name.substr(0, dotloc),
true,
false);
1867 if(sub !=
nullptr) {
1868 auto v = args.back();
1870 arg_name = arg_name.substr(dotloc + 1);
1871 if(arg_name.size() > 1) {
1872 args.push_back(std::string(
"--") + v.substr(dotloc + 3));
1873 current_type = detail::Classifier::LONG;
1875 auto nval = v.substr(dotloc + 2);
1877 if(nval.size() > 2) {
1879 args.push_back(nval.substr(3));
1882 args.push_back(nval);
1883 current_type = detail::Classifier::SHORT;
1885 auto val = sub->_parse_arg(args, current_type,
true);
1888 parsed_subcommands_.push_back(sub);
1892 _trigger_pre_parse(args.size());
1894 if(sub->parse_complete_callback_) {
1895 sub->_process_env();
1896 sub->_process_callbacks();
1897 sub->_process_help_flags();
1898 sub->_process_requirements();
1899 sub->run_callback(
false,
true);
1907 if(local_processing_only) {
1911 if(parent_ !=
nullptr && fallthrough_)
1912 return _get_fallthrough_parent()->_parse_arg(args, current_type,
false);
1916 _move_to_missing(current_type, current);
1923 Option_p &op = *op_ptr;
1925 if(op->get_inject_separator()) {
1926 if(!op->results().empty() && !op->results().back().empty()) {
1927 op->add_result(std::string{});
1930 if(op->get_trigger_on_parse() && op->current_option_state_ == Option::option_state::callback_run) {
1933 int min_num = (std::min)(op->get_type_size_min(), op->get_items_expected_min());
1934 int max_num = op->get_items_expected_max();
1937 if(max_num >= detail::expected_max_vector_size / 16 && !op->get_allow_extra_args()) {
1938 auto tmax = op->get_type_size_max();
1939 max_num = detail::checked_multiply(tmax, op->get_expected_min()) ? tmax : detail::expected_max_vector_size;
1943 int result_count = 0;
1946 auto res = op->get_flag_value(arg_name, value);
1947 op->add_result(res);
1948 parse_order_.push_back(op.get());
1949 }
else if(!value.empty()) {
1950 op->add_result(value, result_count);
1951 parse_order_.push_back(op.get());
1952 collected += result_count;
1954 }
else if(!rest.empty()) {
1955 op->add_result(rest, result_count);
1956 parse_order_.push_back(op.get());
1958 collected += result_count;
1962 while(min_num > collected && !args.empty()) {
1963 std::string current_ = args.back();
1965 op->add_result(current_, result_count);
1966 parse_order_.push_back(op.get());
1967 collected += result_count;
1970 if(min_num > collected) {
1971 throw ArgumentMismatch::TypedAtLeast(op->get_name(), min_num, op->get_type_name());
1975 if(max_num > collected || op->get_allow_extra_args()) {
1976 auto remreqpos = _count_remaining_positionals(
true);
1978 while((collected < max_num || op->get_allow_extra_args()) && !args.empty() &&
1979 _recognize(args.back(),
false) == detail::Classifier::NONE) {
1981 if(remreqpos >= args.size()) {
1984 if(validate_optional_arguments_) {
1985 std::string arg = args.back();
1986 arg = op->_validate(arg, 0);
1991 op->add_result(args.back(), result_count);
1992 parse_order_.push_back(op.get());
1994 collected += result_count;
1998 if(!args.empty() && _recognize(args.back()) == detail::Classifier::POSITIONAL_MARK)
2001 if(min_num == 0 && max_num > 0 && collected == 0) {
2002 auto res = op->get_flag_value(arg_name, std::string{});
2003 op->add_result(res);
2004 parse_order_.push_back(op.get());
2008 if(min_num > 0 && (collected % op->get_type_size_max()) != 0) {
2009 if(op->get_type_size_max() != op->get_type_size_min()) {
2010 op->add_result(std::string{});
2012 throw ArgumentMismatch::PartialType(op->get_name(), op->get_type_size_min(), op->get_type_name());
2015 if(op->get_trigger_on_parse()) {
2020 args.push_back(rest);
2025CLI11_INLINE
void App::_trigger_pre_parse(std::size_t remaining_args) {
2026 if(!pre_parse_called_) {
2027 pre_parse_called_ =
true;
2028 if(pre_parse_callback_) {
2029 pre_parse_callback_(remaining_args);
2031 }
else if(immediate_callback_) {
2032 if(!name_.empty()) {
2033 auto pcnt = parsed_;
2034 missing_t extras = std::move(missing_);
2037 pre_parse_called_ =
true;
2038 missing_ = std::move(extras);
2043CLI11_INLINE
App *App::_get_fallthrough_parent() {
2044 if(parent_ ==
nullptr) {
2047 auto *fallthrough_parent = parent_;
2048 while((fallthrough_parent->parent_ !=
nullptr) && (fallthrough_parent->get_name().empty())) {
2049 fallthrough_parent = fallthrough_parent->
parent_;
2051 return fallthrough_parent;
2054CLI11_NODISCARD CLI11_INLINE
const std::string &App::_compare_subcommand_names(
const App &subcom,
2055 const App &base)
const {
2056 static const std::string estring;
2057 if(subcom.disabled_) {
2060 for(
const auto &subc : base.subcommands_) {
2061 if(subc.get() != &subcom) {
2062 if(subc->disabled_) {
2065 if(!subcom.get_name().empty()) {
2066 if(subc->check_name(subcom.get_name())) {
2067 return subcom.get_name();
2070 if(!subc->get_name().empty()) {
2071 if(subcom.check_name(subc->get_name())) {
2072 return subc->get_name();
2075 for(
const auto &les : subcom.aliases_) {
2076 if(subc->check_name(les)) {
2081 for(
const auto &les : subc->aliases_) {
2082 if(subcom.check_name(les)) {
2087 if(subc->get_name().empty()) {
2088 const auto &cmpres = _compare_subcommand_names(subcom, *subc);
2089 if(!cmpres.empty()) {
2094 if(subcom.get_name().empty()) {
2095 const auto &cmpres = _compare_subcommand_names(*subc, subcom);
2096 if(!cmpres.empty()) {
2105CLI11_INLINE
void App::_move_to_missing(detail::Classifier val_type,
const std::string &val) {
2106 if(allow_extras_ || subcommands_.empty()) {
2107 missing_.emplace_back(val_type, val);
2111 for(
auto &subc : subcommands_) {
2112 if(subc->name_.empty() && subc->allow_extras_) {
2113 subc->missing_.emplace_back(val_type, val);
2118 missing_.emplace_back(val_type, val);
2122 if(opt ==
nullptr) {
2127 for(
auto &subc : subcommands_) {
2128 if(app == subc.get()) {
2136 if((help_ptr_ == opt) || (help_all_ptr_ == opt))
2139 if(config_ptr_ == opt)
2143 std::find_if(std::begin(options_), std::end(options_), [opt](
const Option_p &v) {
return v.get() == opt; });
2144 if(iterator != std::end(options_)) {
2145 const auto &opt_p = *iterator;
2146 if(std::find_if(std::begin(app->options_), std::end(app->options_), [&opt_p](
const Option_p &v) {
2147 return (*v == *opt_p);
2148 }) == std::end(app->options_)) {
2150 app->options_.push_back(std::move(*iterator));
2151 options_.erase(iterator);
2160CLI11_INLINE
void TriggerOn(
App *trigger_app,
App *app_to_enable) {
2161 app_to_enable->enabled_by_default(
false);
2162 app_to_enable->disabled_by_default();
2163 trigger_app->preparse_callback([app_to_enable](std::size_t) { app_to_enable->disabled(
false); });
2166CLI11_INLINE
void TriggerOn(App *trigger_app, std::vector<App *> apps_to_enable) {
2167 for(
auto &app : apps_to_enable) {
2168 app->enabled_by_default(
false);
2169 app->disabled_by_default();
2172 trigger_app->preparse_callback([apps_to_enable](std::size_t) {
2173 for(
const auto &app : apps_to_enable) {
2174 app->disabled(
false);
2179CLI11_INLINE
void TriggerOff(App *trigger_app, App *app_to_enable) {
2180 app_to_enable->disabled_by_default(
false);
2181 app_to_enable->enabled_by_default();
2182 trigger_app->preparse_callback([app_to_enable](std::size_t) { app_to_enable->disabled(); });
2185CLI11_INLINE
void TriggerOff(App *trigger_app, std::vector<App *> apps_to_enable) {
2186 for(
auto &app : apps_to_enable) {
2187 app->disabled_by_default(
false);
2188 app->enabled_by_default();
2191 trigger_app->preparse_callback([apps_to_enable](std::size_t) {
2192 for(
const auto &app : apps_to_enable) {
2198CLI11_INLINE
void deprecate_option(Option *opt,
const std::string &replacement) {
2199 Validator deprecate_warning{[opt, replacement](std::string &) {
2200 std::cout << opt->get_name() <<
" is deprecated please use '" << replacement
2202 return std::string();
2205 deprecate_warning.application_index(0);
2206 opt->check(deprecate_warning);
2207 if(!replacement.empty()) {
2208 opt->description(opt->get_description() +
" DEPRECATED: please use '" + replacement +
"' instead");
2212CLI11_INLINE
void retire_option(App *app, Option *opt) {
2214 auto *option_copy = temp.add_option(opt->get_name(
false,
true))
2215 ->type_size(opt->get_type_size_min(), opt->get_type_size_max())
2216 ->expected(opt->get_expected_min(), opt->get_expected_max())
2217 ->allow_extra_args(opt->get_allow_extra_args());
2219 app->remove_option(opt);
2220 auto *opt2 = app->add_option(option_copy->get_name(
false,
true),
"option has been retired and has no effect");
2221 opt2->type_name(
"RETIRED")
2222 ->default_str(
"RETIRED")
2223 ->type_size(option_copy->get_type_size_min(), option_copy->get_type_size_max())
2224 ->expected(option_copy->get_expected_min(), option_copy->get_expected_max())
2225 ->allow_extra_args(option_copy->get_allow_extra_args());
2227 Validator retired_warning{[opt2](std::string &) {
2228 std::cout <<
"WARNING " << opt2->get_name() <<
" is retired and has no effect\n";
2229 return std::string();
2232 retired_warning.application_index(0);
2233 opt2->check(retired_warning);
2236CLI11_INLINE
void retire_option(App &app, Option *opt) { retire_option(&app, opt); }
2238CLI11_INLINE
void retire_option(App *app,
const std::string &option_name) {
2240 auto *opt = app->get_option_no_throw(option_name);
2241 if(opt !=
nullptr) {
2242 retire_option(app, opt);
2245 auto *opt2 = app->add_option(option_name,
"option has been retired and has no effect")
2246 ->type_name(
"RETIRED")
2248 ->default_str(
"RETIRED");
2249 Validator retired_warning{[opt2](std::string &) {
2250 std::cout <<
"WARNING " << opt2->get_name() <<
" is retired and has no effect\n";
2251 return std::string();
2254 retired_warning.application_index(0);
2255 opt2->check(retired_warning);
2258CLI11_INLINE
void retire_option(App &app,
const std::string &option_name) { retire_option(&app, option_name); }
2260namespace FailureMessage {
2262CLI11_INLINE std::string simple(
const App *app,
const Error &e) {
2263 std::string header = std::string(e.what()) +
"\n";
2264 std::vector<std::string> names;
2267 if(app->get_help_ptr() !=
nullptr)
2268 names.push_back(app->get_help_ptr()->get_name());
2270 if(app->get_help_all_ptr() !=
nullptr)
2271 names.push_back(app->get_help_all_ptr()->get_name());
2275 header +=
"Run with " + detail::join(names,
" or ") +
" for more information.\n";
2280CLI11_INLINE std::string help(
const App *app,
const Error &e) {
2281 std::string header = std::string(
"ERROR: ") + e.get_name() +
": " + e.what() +
"\n";
2282 header += app->help();
Creates a command line program, with very few defaults.
Definition App.hpp:90
CLI11_NODISCARD Option * get_option_no_throw(std::string option_name) noexcept
Get an option by name (noexcept non-const version)
Definition App_inl.hpp:805
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.
Definition App_inl.hpp:648
CLI11_NODISCARD std::string help(std::string prev="", AppFormatMode mode=AppFormatMode::Normal) const
Definition App_inl.hpp:744
CLI11_NODISCARD std::size_t remaining_size(bool recurse=false) const
This returns the number of remaining options, minus the – separator.
Definition App_inl.hpp:930
CLI11_NODISCARD detail::Classifier _recognize(const std::string ¤t, bool ignore_used_subcommands=true) const
Selects a Classifier enum based on the type of the current argument.
Definition App_inl.hpp:1039
App * immediate_callback(bool immediate=true)
Set the subcommand callback to be executed immediately on subcommand completion.
Definition App_inl.hpp:119
Option * set_help_flag(std::string flag_name="", const std::string &help_description="")
Set a help flag, replace the existing one if present.
Definition App_inl.hpp:225
App * _get_fallthrough_parent()
Get the appropriate parent to fallthrough to which is the first one that has a name or the main app.
Definition App_inl.hpp:2043
Option * config_ptr_
Pointer to the config option.
Definition App.hpp:288
std::size_t require_option_min_
Minimum required options (not inheritable!)
Definition App.hpp:269
App * ignore_underscore(bool value=true)
Ignore underscore. Subcommands inherit value.
Definition App_inl.hpp:145
std::size_t require_subcommand_max_
Max number of subcommands allowed (parsing stops after this number). 0 is unlimited INHERITABLE.
Definition App.hpp:266
std::vector< App_p > subcommands_
Storage for subcommand list.
Definition App.hpp:219
CLI11_NODISCARD std::vector< std::string > remaining(bool recurse=false) const
This returns the missing options from the current subcommand.
Definition App_inl.hpp:898
CLI11_NODISCARD 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.
Definition App_inl.hpp:924
std::uint32_t parsed_
Counts the number of times this command/subcommand was parsed.
Definition App.hpp:260
CLI11_NODISCARD App * get_option_group(std::string group_name) const
Check to see if an option group is part of this App.
Definition App_inl.hpp:500
std::string usage_
Usage to put after program/subcommand description in the help output INHERITABLE.
Definition App.hpp:156
OptionDefaults option_defaults_
The default values for options, customizable and changeable INHERITABLE.
Definition App.hpp:146
void _process_help_flags(bool trigger_help=false, bool trigger_all_help=false) const
Definition App_inl.hpp:1176
void _process_requirements()
Verify required options and cross requirements. Subcommands too (only if selected).
Definition App_inl.hpp:1198
CLI11_NODISCARD std::size_t count_all() const
Definition App_inl.hpp:509
bool disabled_
If set to true the subcommand is disabled and cannot be used, ignored for main app.
Definition App.hpp:123
Option * set_version_flag(std::string flag_name="", const std::string &versionString="", const std::string &version_help="Display program version information and exit")
Set a version flag and version display string, replace the existing one if present.
Definition App_inl.hpp:258
bool remove_needs(Option *opt)
Removes an option from the needs list of this subcommand.
Definition App_inl.hpp:726
Option * get_help_ptr()
Get a pointer to the help flag.
Definition App.hpp:1152
void _configure()
Definition App_inl.hpp:979
Option * add_flag_function(std::string flag_name, std::function< void(std::int64_t)> function, std::string flag_description="")
Add option for callback with an integer value.
Definition App_inl.hpp:334
void parse(int argc, const char *const *argv)
Definition App_inl.hpp:538
void _process_config_file()
Read and process a configuration file (main app only)
Definition App_inl.hpp:1094
std::string footer_
Footer to put after all options in the help output INHERITABLE.
Definition App.hpp:162
config_extras_mode allow_config_extras_
Definition App.hpp:111
CLI11_NODISCARD bool check_name(std::string name_to_check) const
Check the name, case insensitive and underscore insensitive if set.
Definition App_inl.hpp:857
Option * version_ptr_
A pointer to a version flag if there is one.
Definition App.hpp:174
CLI11_NODISCARD const Option * get_help_all_ptr() const
Get a pointer to the help all flag. (const)
Definition App.hpp:1158
bool remove_subcommand(App *subcom)
Removes a subcommand from the App. Takes a subcommand pointer. Returns true if found and removed.
Definition App_inl.hpp:430
App * parent_
A pointer to the parent if this is a subcommand.
Definition App.hpp:275
std::set< Option * > exclude_options_
Definition App.hpp:204
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.
Definition App_inl.hpp:475
std::function< void()> parse_complete_callback_
This is a function that runs when parsing has finished.
Definition App.hpp:136
virtual void pre_callback()
Definition App.hpp:848
Option * add_flag(std::string flag_name)
Add a flag with no description or variable assignment.
Definition App.hpp:625
void _validate() const
Definition App_inl.hpp:944
std::string name_
Subcommand name or program name (from parser if name is empty)
Definition App.hpp:101
std::vector< App * > parsed_subcommands_
This is a list of the subcommands collected, in order.
Definition App.hpp:197
bool ignore_underscore_
If true, the program should ignore underscores INHERITABLE.
Definition App.hpp:225
missing_t missing_
Definition App.hpp:191
void run_callback(bool final_mode=false, bool suppress_final_callback=false)
Internal function to run (App) callback, bottom up.
Definition App_inl.hpp:999
std::size_t require_subcommand_min_
Minimum required subcommands (not inheritable!)
Definition App.hpp:263
void _process_env()
Get envname options if not yet passed. Runs on all subcommands.
Definition App_inl.hpp:1130
std::function< std::string(const App *, const Error &e)> failure_message_
The error message printing function INHERITABLE.
Definition App.hpp:180
void _parse_stream(std::istream &input)
Internal function to parse a stream.
Definition App_inl.hpp:1429
CLI11_NODISCARD std::string get_display_name(bool with_aliases=false) const
Get a display name for an app.
Definition App_inl.hpp:841
bool has_automatic_name_
If set to true the name was automatically generated from the command line vs a user set name.
Definition App.hpp:117
CLI11_NODISCARD 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 over...
Definition App_inl.hpp:2054
void clear()
Reset the parsed data.
Definition App_inl.hpp:523
App * get_subcommand(const App *subcom) const
Definition App_inl.hpp:446
CLI11_NODISCARD std::string version() const
Displays a version string.
Definition App_inl.hpp:758
CLI11_NODISCARD App * get_subcommand_no_throw(std::string subcom) const noexcept
Definition App_inl.hpp:462
std::vector< Option_p > options_
The list of options, stored locally.
Definition App.hpp:149
Option * help_all_ptr_
A pointer to the help all flag if there is one INHERITABLE.
Definition App.hpp:171
bool validate_optional_arguments_
If set to true optional vector arguments are validated before assigning INHERITABLE.
Definition App.hpp:253
std::function< void()> final_callback_
This is a function that runs when all processing has completed.
Definition App.hpp:139
bool remove_option(Option *opt)
Removes an option from the App. Takes an option pointer. Returns true if found and removed.
Definition App_inl.hpp:378
App(std::string app_description, std::string app_name, App *parent)
Special private constructor for subcommand.
Definition App_inl.hpp:28
App * add_subcommand(std::string subcommand_name="", std::string subcommand_description="")
Add a subcommand. Inherits INHERITABLE and OptionDefaults, and help flag.
Definition App_inl.hpp:399
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.
Definition App_inl.hpp:317
bool immediate_callback_
Definition App.hpp:130
App * name(std::string app_name="")
Set a name for the app (empty will use parser to set the name)
Definition App_inl.hpp:84
CLI11_NODISCARD bool _valid_subcommand(const std::string ¤t, bool ignore_used=true) const
Check to see if a subcommand is valid. Give up immediately if subcommand max has been reached.
Definition App_inl.hpp:1026
bool configurable_
if set to true the subcommand can be triggered via configuration files INHERITABLE
Definition App.hpp:247
CLI11_NODISCARD std::vector< std::string > get_groups() const
Get the groups available directly from this option (in order)
Definition App_inl.hpp:885
void _parse_config(const std::vector< ConfigItem > &args)
Definition App_inl.hpp:1440
std::size_t require_option_max_
Max number of options allowed. 0 is unlimited (not inheritable)
Definition App.hpp:272
std::vector< std::string > aliases_
Alias names for the subcommand.
Definition App.hpp:281
std::set< App * > exclude_subcommands_
this is a list of subcommands that are exclusionary to this one
Definition App.hpp:200
bool ignore_case_
If true, the program name is not case sensitive INHERITABLE.
Definition App.hpp:222
CLI11_NODISCARD const std::string & get_group() const
Get the group of this subcommand.
Definition App.hpp:1096
std::string group_
The group membership INHERITABLE.
Definition App.hpp:278
App * alias(std::string app_name)
Set an alias for the app.
Definition App_inl.hpp:101
bool pre_parse_called_
Flag indicating that the pre_parse_callback has been triggered.
Definition App.hpp:126
void _process_callbacks()
Process callbacks. Runs on all subcommands.
Definition App_inl.hpp:1152
Option * help_ptr_
A pointer to the help flag if there is one INHERITABLE.
Definition App.hpp:168
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.
Definition App_inl.hpp:349
App * ignore_case(bool value=true)
Ignore case. Subcommands inherit value.
Definition App_inl.hpp:131
bool remove_excludes(Option *opt)
Removes an option from the excludes list of this subcommand.
Definition App_inl.hpp:706
CLI11_NODISCARD std::vector< App * > get_subcommands() const
Definition App.hpp:899
bool fallthrough_
Allow subcommand fallthrough, so that parent commands can collect commands after subcommand....
Definition App.hpp:228
std::set< Option * > need_options_
Definition App.hpp:212
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...
Definition App_inl.hpp:776
std::set< App * > need_subcommands_
Definition App.hpp:208
bool prefix_command_
If true, return immediately on an unrecognized option (implies allow_extras) INHERITABLE.
Definition App.hpp:114
Option * add_option(std::string option_name, callback_t option_callback, std::string option_description="", bool defaulted=false, std::function< std::string()> func={})
Definition App_inl.hpp:159
void _parse(std::vector< std::string > &args)
Internal parse function.
Definition App_inl.hpp:1385
bool validate_positionals_
If set to true positional options are validated before assigning INHERITABLE.
Definition App.hpp:250
startup_mode default_startup
Definition App.hpp:244
bool allow_extras_
If true, allow extra arguments (ie, don't throw an error). INHERITABLE.
Definition App.hpp:107
CLI11_NODISCARD char ** ensure_utf8(char **argv)
Convert the contents of argv to UTF-8. Only does something on Windows, does nothing elsewhere.
Definition App_inl.hpp:62
CLI11_NODISCARD App * _find_subcommand(const std::string &subc_name, bool ignore_disabled, bool ignore_used) const noexcept
Definition App_inl.hpp:1748
CLI11_NODISCARD const std::string & get_name() const
Get the name of the current app.
Definition App.hpp:1179
std::shared_ptr< FormatterBase > formatter_
This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
Definition App.hpp:177
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.
Definition App_inl.hpp:241
bool allow_windows_style_options_
Allow '/' for options for Windows like options. Defaults to true on Windows, false otherwise....
Definition App.hpp:231
std::shared_ptr< Config > config_formatter_
This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
Definition App.hpp:291
Usually something like –help-all on command line.
Definition Error.hpp:178
-h or –help on command line
Definition Error.hpp:172
-v or –version on command line
Definition Error.hpp:185
All errors derive from this one.
Definition Error.hpp:73
Thrown when an excludes option is present.
Definition Error.hpp:301
Thrown when parsing an INI file and it is missing.
Definition Error.hpp:198
Thrown when an option is set to conflicting values (non-vector and multi args, for example)
Definition Error.hpp:96
Thrown when validation fails before parsing.
Definition Error.hpp:334
Thrown when an option already exists.
Definition Error.hpp:144
CLI11_NODISCARD bool get_required() const
True if this is a required option.
Definition Option.hpp:118
CRTP * configurable(bool value=true)
Allow in a configuration file.
Definition Option.hpp:180
void copy_to(T *other) const
Copy the contents to another similar class (one based on OptionBase)
Definition Option_inl.hpp:24
CRTP * required(bool value=true)
Set the option as required.
Definition Option.hpp:99
Definition Option.hpp:231
Option * expected(int value)
Set the number of expected arguments.
Definition Option_inl.hpp:36
CLI11_NODISCARD bool get_positional() const
True if the argument can be given directly.
Definition Option.hpp:583
Option * default_function(const std::function< std::string()> &func)
Set a capture function for the default. Mostly used by App.
Definition Option.hpp:739
void run_callback()
Process the callback.
Definition Option_inl.hpp:286
CLI11_NODISCARD std::string get_name(bool positional=false, bool all_options=false) const
Gets a comma separated list of names. Will include / prefer the positional name if positional is true...
Definition Option_inl.hpp:233
bool force_callback_
flag indicating that the option should force the callback regardless if any results present
Definition Option.hpp:340
CLI11_NODISCARD const results_t & results() const
Get the current complete results set.
Definition Option.hpp:667
CLI11_NODISCARD std::size_t count() const
Count the total number of times an option was passed.
Definition Option.hpp:357
Option * multi_option_policy(MultiOptionPolicy value=MultiOptionPolicy::Throw)
Take the last argument if given multiple times (or another policy)
Definition Option_inl.hpp:220
CLI11_NODISCARD const std::string & get_description() const
Get the description.
Definition Option.hpp:592
CLI11_NODISCARD const std::string & get_single_name() const
Get a single name for the option, first of lname, pname, sname, envname.
Definition Option.hpp:551
void clear()
Clear the parsed results (mostly for testing)
Definition Option.hpp:366
Option * capture_default_str()
Capture the default value from the original value (if it can be captured)
Definition Option.hpp:745
Option * default_str(std::string val)
Set the default value string representation (does not change the contained value)
Definition Option.hpp:753
std::string envname_
If given, check the environment for this option.
Definition Option.hpp:255
Option * add_result(std::string s)
Puts a result at the end.
Definition Option_inl.hpp:424
CLI11_NODISCARD T as() const
Return the results as the specified type.
Definition Option.hpp:704
Thrown when counting a non-existent option.
Definition Error.hpp:351
Anything that can error in Parse.
Definition Error.hpp:159
Thrown when a required option is missing.
Definition Error.hpp:228
Thrown when a requires option is missing.
Definition Error.hpp:294
Holds values to load into Options.
Definition ConfigFwd.hpp:29