CLI11
C++11 Command Line Interface Parser
Loading...
Searching...
No Matches
App_inl.hpp
1// Copyright (c) 2017-2025, University of Cincinnati, developed by Henry Schreiner
2// under NSF AWARD 1414736 and by the respective contributors.
3// All rights reserved.
4//
5// SPDX-License-Identifier: BSD-3-Clause
6
7#pragma once
8
9// IWYU pragma: private, include "CLI/CLI.hpp"
10
11// This include is only needed for IDEs to discover symbols
12#include "../App.hpp"
13
14#include "../Argv.hpp"
15#include "../Encoding.hpp"
16
17// [CLI11:public_includes:set]
18#include <algorithm>
19#include <iostream>
20#include <memory>
21#include <string>
22#include <utility>
23#include <vector>
24// [CLI11:public_includes:end]
25
26namespace CLI {
27// [CLI11:app_inl_hpp:verbatim]
28
29CLI11_INLINE App::App(std::string app_description, std::string app_name, App *parent)
30 : name_(std::move(app_name)), description_(std::move(app_description)), parent_(parent) {
31 // Inherit if not from a nullptr
32 if(parent_ != nullptr) {
33 if(parent_->help_ptr_ != nullptr)
35 if(parent_->help_all_ptr_ != nullptr)
37
40
41 // INHERITABLE
61 }
62}
63
64CLI11_NODISCARD CLI11_INLINE char **App::ensure_utf8(char **argv) {
65#ifdef _WIN32
66 (void)argv;
67
68 normalized_argv_ = detail::compute_win32_argv();
69
70 if(!normalized_argv_view_.empty()) {
71 normalized_argv_view_.clear();
72 }
73
74 normalized_argv_view_.reserve(normalized_argv_.size());
75 for(auto &arg : normalized_argv_) {
76 // using const_cast is well-defined, string is known to not be const.
77 normalized_argv_view_.push_back(const_cast<char *>(arg.data()));
78 }
79
80 return normalized_argv_view_.data();
81#else
82 return argv;
83#endif
84}
85
86CLI11_INLINE App *App::name(std::string app_name) {
87
88 if(parent_ != nullptr) {
89 std::string oname = name_;
90 name_ = app_name;
91 const auto &res = _compare_subcommand_names(*this, *_get_fallthrough_parent());
92 if(!res.empty()) {
93 name_ = oname;
94 throw(OptionAlreadyAdded(app_name + " conflicts with existing subcommand names"));
95 }
96 } else {
97 name_ = app_name;
98 }
99 has_automatic_name_ = false;
100 return this;
101}
102
103CLI11_INLINE App *App::alias(std::string app_name) {
104 if(app_name.empty() || !detail::valid_alias_name_string(app_name)) {
105 throw IncorrectConstruction("Aliases may not be empty or contain newlines or null characters");
106 }
107 if(parent_ != nullptr) {
108 aliases_.push_back(app_name);
109 const auto &res = _compare_subcommand_names(*this, *_get_fallthrough_parent());
110 if(!res.empty()) {
111 aliases_.pop_back();
112 throw(OptionAlreadyAdded("alias already matches an existing subcommand: " + app_name));
113 }
114 } else {
115 aliases_.push_back(app_name);
116 }
117
118 return this;
119}
120
121CLI11_INLINE App *App::immediate_callback(bool immediate) {
122 immediate_callback_ = immediate;
126 }
129 }
130 return this;
131}
132
133CLI11_INLINE App *App::ignore_case(bool value) {
134 if(value && !ignore_case_) {
135 ignore_case_ = true;
136 auto *p = (parent_ != nullptr) ? _get_fallthrough_parent() : this;
137 const auto &match = _compare_subcommand_names(*this, *p);
138 if(!match.empty()) {
139 ignore_case_ = false; // we are throwing so need to be exception invariant
140 throw OptionAlreadyAdded("ignore case would cause subcommand name conflicts: " + match);
141 }
142 }
143 ignore_case_ = value;
144 return this;
145}
146
147CLI11_INLINE App *App::ignore_underscore(bool value) {
148 if(value && !ignore_underscore_) {
149 ignore_underscore_ = true;
150 auto *p = (parent_ != nullptr) ? _get_fallthrough_parent() : this;
151 const auto &match = _compare_subcommand_names(*this, *p);
152 if(!match.empty()) {
153 ignore_underscore_ = false;
154 throw OptionAlreadyAdded("ignore underscore would cause subcommand name conflicts: " + match);
155 }
156 }
157 ignore_underscore_ = value;
158 return this;
159}
160
161CLI11_INLINE Option *App::add_option(std::string option_name,
162 callback_t option_callback,
163 std::string option_description,
164 bool defaulted,
165 std::function<std::string()> func) {
166 Option myopt{option_name, option_description, option_callback, this, allow_non_standard_options_};
167
168 if(std::find_if(std::begin(options_), std::end(options_), [&myopt](const Option_p &v) { return *v == myopt; }) ==
169 std::end(options_)) {
170 if(myopt.lnames_.empty() && myopt.snames_.empty()) {
171 // if the option is positional only there is additional potential for ambiguities in config files and needs
172 // to be checked
173 std::string test_name = "--" + myopt.get_single_name();
174 if(test_name.size() == 3) {
175 test_name.erase(0, 1);
176 }
177
178 auto *op = get_option_no_throw(test_name);
179 if(op != nullptr && op->get_configurable()) {
180 throw(OptionAlreadyAdded("added option positional name matches existing option: " + test_name));
181 }
182 // need to check if there is another positional with the same name that also doesn't have any long or short
183 // names
184 op = get_option_no_throw(myopt.get_single_name());
185 if(op != nullptr && op->lnames_.empty() && op->snames_.empty()) {
186 throw(OptionAlreadyAdded("unable to disambiguate with existing option: " + test_name));
187 }
188 } else if(parent_ != nullptr) {
189 for(auto &ln : myopt.lnames_) {
190 auto *op = parent_->get_option_no_throw(ln);
191 if(op != nullptr && op->get_configurable()) {
192 throw(OptionAlreadyAdded("added option matches existing positional option: " + ln));
193 }
194 }
195 for(auto &sn : myopt.snames_) {
196 auto *op = parent_->get_option_no_throw(sn);
197 if(op != nullptr && op->get_configurable()) {
198 throw(OptionAlreadyAdded("added option matches existing positional option: " + sn));
199 }
200 }
201 }
202 if(allow_non_standard_options_ && !myopt.snames_.empty()) {
203 for(auto &sname : myopt.snames_) {
204 if(sname.length() > 1) {
205 std::string test_name;
206 test_name.push_back('-');
207 test_name.push_back(sname.front());
208 auto *op = get_option_no_throw(test_name);
209 if(op != nullptr) {
210 throw(OptionAlreadyAdded("added option interferes with existing short option: " + sname));
211 }
212 }
213 }
214 for(auto &opt : options_) {
215 for(const auto &osn : opt->snames_) {
216 if(osn.size() > 1) {
217 std::string test_name;
218 test_name.push_back(osn.front());
219 if(myopt.check_sname(test_name)) {
220 throw(OptionAlreadyAdded("added option interferes with existing non standard option: " +
221 osn));
222 }
223 }
224 }
225 }
226 }
227 options_.emplace_back();
228 Option_p &option = options_.back();
229 option.reset(new Option(option_name, option_description, option_callback, this, allow_non_standard_options_));
230
231 // Set the default string capture function
232 option->default_function(func);
233
234 // For compatibility with CLI11 1.7 and before, capture the default string here
235 if(defaulted)
236 option->capture_default_str();
237
238 // Transfer defaults to the new option
239 option_defaults_.copy_to(option.get());
240
241 // Don't bother to capture if we already did
242 if(!defaulted && option->get_always_capture_default())
243 option->capture_default_str();
244
245 return option.get();
246 }
247 // we know something matches now find what it is so we can produce more error information
248 for(auto &opt : options_) {
249 const auto &matchname = opt->matching_name(myopt);
250 if(!matchname.empty()) {
251 throw(OptionAlreadyAdded("added option matched existing option name: " + matchname));
252 }
253 }
254 // this line should not be reached the above loop should trigger the throw
255 throw(OptionAlreadyAdded("added option matched existing option name")); // LCOV_EXCL_LINE
256}
257
258CLI11_INLINE Option *App::set_help_flag(std::string flag_name, const std::string &help_description) {
259 // take flag_description by const reference otherwise add_flag tries to assign to help_description
260 if(help_ptr_ != nullptr) {
262 help_ptr_ = nullptr;
263 }
264
265 // Empty name will simply remove the help flag
266 if(!flag_name.empty()) {
267 help_ptr_ = add_flag(flag_name, help_description);
268 help_ptr_->configurable(false);
269 }
270
271 return help_ptr_;
272}
273
274CLI11_INLINE Option *App::set_help_all_flag(std::string help_name, const std::string &help_description) {
275 // take flag_description by const reference otherwise add_flag tries to assign to flag_description
276 if(help_all_ptr_ != nullptr) {
278 help_all_ptr_ = nullptr;
279 }
280
281 // Empty name will simply remove the help all flag
282 if(!help_name.empty()) {
283 help_all_ptr_ = add_flag(help_name, help_description);
285 }
286
287 return help_all_ptr_;
288}
289
290CLI11_INLINE Option *
291App::set_version_flag(std::string flag_name, const std::string &versionString, const std::string &version_help) {
292 // take flag_description by const reference otherwise add_flag tries to assign to version_description
293 if(version_ptr_ != nullptr) {
295 version_ptr_ = nullptr;
296 }
297
298 // Empty name will simply remove the version flag
299 if(!flag_name.empty()) {
301 flag_name, [versionString]() { throw(CLI::CallForVersion(versionString, 0)); }, version_help);
303 }
304
305 return version_ptr_;
306}
307
308CLI11_INLINE Option *
309App::set_version_flag(std::string flag_name, std::function<std::string()> vfunc, const std::string &version_help) {
310 if(version_ptr_ != nullptr) {
312 version_ptr_ = nullptr;
313 }
314
315 // Empty name will simply remove the version flag
316 if(!flag_name.empty()) {
318 add_flag_callback(flag_name, [vfunc]() { throw(CLI::CallForVersion(vfunc(), 0)); }, version_help);
320 }
321
322 return version_ptr_;
323}
324
325CLI11_INLINE Option *App::_add_flag_internal(std::string flag_name, CLI::callback_t fun, std::string flag_description) {
326 Option *opt = nullptr;
327 if(detail::has_default_flag_values(flag_name)) {
328 // check for default values and if it has them
329 auto flag_defaults = detail::get_default_flag_values(flag_name);
330 detail::remove_default_flag_values(flag_name);
331 opt = add_option(std::move(flag_name), std::move(fun), std::move(flag_description), false);
332 for(const auto &fname : flag_defaults)
333 opt->fnames_.push_back(fname.first);
334 opt->default_flag_values_ = std::move(flag_defaults);
335 } else {
336 opt = add_option(std::move(flag_name), std::move(fun), std::move(flag_description), false);
337 }
338 // flags cannot have positional values
339 if(opt->get_positional()) {
340 auto pos_name = opt->get_name(true);
341 remove_option(opt);
342 throw IncorrectConstruction::PositionalFlag(pos_name);
343 }
344 opt->multi_option_policy(MultiOptionPolicy::TakeLast);
345 opt->expected(0);
346 opt->required(false);
347 return opt;
348}
349
350CLI11_INLINE Option *App::add_flag_callback(std::string flag_name,
351 std::function<void(void)> function,
352 std::string flag_description) {
353
354 CLI::callback_t fun = [function](const CLI::results_t &res) {
355 using CLI::detail::lexical_cast;
356 bool trigger{false};
357 auto result = lexical_cast(res[0], trigger);
358 if(result && trigger) {
359 function();
360 }
361 return result;
362 };
363 return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description));
364}
365
366CLI11_INLINE Option *
367App::add_flag_function(std::string flag_name,
368 std::function<void(std::int64_t)> function,
369 std::string flag_description) {
370
371 CLI::callback_t fun = [function](const CLI::results_t &res) {
372 using CLI::detail::lexical_cast;
373 std::int64_t flag_count{0};
374 lexical_cast(res[0], flag_count);
375 function(flag_count);
376 return true;
377 };
378 return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description))
379 ->multi_option_policy(MultiOptionPolicy::Sum);
380}
381
382CLI11_INLINE Option *App::set_config(std::string option_name,
383 std::string default_filename,
384 const std::string &help_message,
385 bool config_required) {
386
387 // Remove existing config if present
388 if(config_ptr_ != nullptr) {
390 config_ptr_ = nullptr; // need to remove the config_ptr completely
391 }
392
393 // Only add config if option passed
394 if(!option_name.empty()) {
395 config_ptr_ = add_option(option_name, help_message);
396 if(config_required) {
398 }
399 if(!default_filename.empty()) {
400 config_ptr_->default_str(std::move(default_filename));
402 }
404 // set the option to take the last value and reverse given by default
405 config_ptr_->multi_option_policy(MultiOptionPolicy::Reverse);
406 }
407
408 return config_ptr_;
409}
410
411CLI11_INLINE bool App::remove_option(Option *opt) {
412 // Make sure no links exist
413 for(Option_p &op : options_) {
414 op->remove_needs(opt);
415 op->remove_excludes(opt);
416 }
417
418 if(help_ptr_ == opt)
419 help_ptr_ = nullptr;
420 if(help_all_ptr_ == opt)
421 help_all_ptr_ = nullptr;
422 if(config_ptr_ == opt)
423 config_ptr_ = nullptr;
424
425 auto iterator =
426 std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
427 if(iterator != std::end(options_)) {
428 options_.erase(iterator);
429 return true;
430 }
431 return false;
432}
433
434CLI11_INLINE App *App::add_subcommand(std::string subcommand_name, std::string subcommand_description) {
435 if(!subcommand_name.empty() && !detail::valid_name_string(subcommand_name)) {
436 if(!detail::valid_first_char(subcommand_name[0])) {
438 "Subcommand name starts with invalid character, '!' and '-' and control characters");
439 }
440 for(auto c : subcommand_name) {
441 if(!detail::valid_later_char(c)) {
442 throw IncorrectConstruction(std::string("Subcommand name contains invalid character ('") + c +
443 "'), all characters are allowed except"
444 "'=',':','{','}', ' ', and control characters");
445 }
446 }
447 }
448 CLI::App_p subcom = std::shared_ptr<App>(new App(std::move(subcommand_description), subcommand_name, this));
449 return add_subcommand(std::move(subcom));
450}
451
452CLI11_INLINE App *App::add_subcommand(CLI::App_p subcom) {
453 if(!subcom)
454 throw IncorrectConstruction("passed App is not valid");
455 auto *ckapp = (name_.empty() && parent_ != nullptr) ? _get_fallthrough_parent() : this;
456 const auto &mstrg = _compare_subcommand_names(*subcom, *ckapp);
457 if(!mstrg.empty()) {
458 throw(OptionAlreadyAdded("subcommand name or alias matches existing subcommand: " + mstrg));
459 }
460 subcom->parent_ = this;
461 subcommands_.push_back(std::move(subcom));
462 return subcommands_.back().get();
463}
464
465CLI11_INLINE bool App::remove_subcommand(App *subcom) {
466 // Make sure no links exist
467 for(App_p &sub : subcommands_) {
468 sub->remove_excludes(subcom);
469 sub->remove_needs(subcom);
470 }
471
472 auto iterator = std::find_if(
473 std::begin(subcommands_), std::end(subcommands_), [subcom](const App_p &v) { return v.get() == subcom; });
474 if(iterator != std::end(subcommands_)) {
475 subcommands_.erase(iterator);
476 return true;
477 }
478 return false;
479}
480
481CLI11_INLINE App *App::get_subcommand(const App *subcom) const {
482 if(subcom == nullptr)
483 throw OptionNotFound("nullptr passed");
484 for(const App_p &subcomptr : subcommands_)
485 if(subcomptr.get() == subcom)
486 return subcomptr.get();
487 throw OptionNotFound(subcom->get_name());
488}
489
490CLI11_NODISCARD CLI11_INLINE App *App::get_subcommand(std::string subcom) const {
491 auto *subc = _find_subcommand(subcom, false, false);
492 if(subc == nullptr)
493 throw OptionNotFound(subcom);
494 return subc;
495}
496
497CLI11_NODISCARD CLI11_INLINE App *App::get_subcommand_no_throw(std::string subcom) const noexcept {
498 return _find_subcommand(subcom, false, false);
499}
500
501CLI11_NODISCARD CLI11_INLINE App *App::get_subcommand(int index) const {
502 if(index >= 0) {
503 auto uindex = static_cast<unsigned>(index);
504 if(uindex < subcommands_.size())
505 return subcommands_[uindex].get();
506 }
507 throw OptionNotFound(std::to_string(index));
508}
509
510CLI11_INLINE CLI::App_p App::get_subcommand_ptr(App *subcom) const {
511 if(subcom == nullptr)
512 throw OptionNotFound("nullptr passed");
513 for(const App_p &subcomptr : subcommands_)
514 if(subcomptr.get() == subcom)
515 return subcomptr;
516 throw OptionNotFound(subcom->get_name());
517}
518
519CLI11_NODISCARD CLI11_INLINE CLI::App_p App::get_subcommand_ptr(std::string subcom) const {
520 for(const App_p &subcomptr : subcommands_)
521 if(subcomptr->check_name(subcom))
522 return subcomptr;
523 throw OptionNotFound(subcom);
524}
525
526CLI11_NODISCARD CLI11_INLINE CLI::App_p App::get_subcommand_ptr(int index) const {
527 if(index >= 0) {
528 auto uindex = static_cast<unsigned>(index);
529 if(uindex < subcommands_.size())
530 return subcommands_[uindex];
531 }
532 throw OptionNotFound(std::to_string(index));
533}
534
535CLI11_NODISCARD CLI11_INLINE CLI::App *App::get_option_group(std::string group_name) const {
536 for(const App_p &app : subcommands_) {
537 if(app->name_.empty() && app->group_ == group_name) {
538 return app.get();
539 }
540 }
541 throw OptionNotFound(group_name);
542}
543
544CLI11_NODISCARD CLI11_INLINE std::size_t App::count_all() const {
545 std::size_t cnt{0};
546 for(const auto &opt : options_) {
547 cnt += opt->count();
549 for(const auto &sub : subcommands_) {
550 cnt += sub->count_all();
551 }
552 if(!get_name().empty()) { // for named subcommands add the number of times the subcommand was called
553 cnt += parsed_;
554 }
555 return cnt;
556}
557
558CLI11_INLINE void App::clear() {
559
560 parsed_ = 0;
561 pre_parse_called_ = false;
562
563 missing_.clear();
564 parsed_subcommands_.clear();
565 for(const Option_p &opt : options_) {
566 opt->clear();
567 }
568 for(const App_p &subc : subcommands_) {
569 subc->clear();
570 }
571}
572
573CLI11_INLINE void App::parse(int argc, const char *const *argv) { parse_char_t(argc, argv); }
574CLI11_INLINE void App::parse(int argc, const wchar_t *const *argv) { parse_char_t(argc, argv); }
575
576namespace detail {
577
578// Do nothing or perform narrowing
579CLI11_INLINE const char *maybe_narrow(const char *str) { return str; }
580CLI11_INLINE std::string maybe_narrow(const wchar_t *str) { return narrow(str); }
581
582} // namespace detail
583
584template <class CharT> CLI11_INLINE void App::parse_char_t(int argc, const CharT *const *argv) {
585 // If the name is not set, read from command line
586 if(name_.empty() || has_automatic_name_) {
587 has_automatic_name_ = true;
588 name_ = detail::maybe_narrow(argv[0]);
589 }
590
591 std::vector<std::string> args;
592 args.reserve(static_cast<std::size_t>(argc) - 1U);
593 for(auto i = static_cast<std::size_t>(argc) - 1U; i > 0U; --i)
594 args.emplace_back(detail::maybe_narrow(argv[i]));
595
596 parse(std::move(args));
597}
598
599CLI11_INLINE void App::parse(std::string commandline, bool program_name_included) {
600
601 if(program_name_included) {
602 auto nstr = detail::split_program_name(commandline);
603 if((name_.empty()) || (has_automatic_name_)) {
604 has_automatic_name_ = true;
605 name_ = nstr.first;
606 }
607 commandline = std::move(nstr.second);
608 } else {
609 detail::trim(commandline);
610 }
611 // the next section of code is to deal with quoted arguments after an '=' or ':' for windows like operations
612 if(!commandline.empty()) {
613 commandline = detail::find_and_modify(commandline, "=", detail::escape_detect);
615 commandline = detail::find_and_modify(commandline, ":", detail::escape_detect);
616 }
617
618 auto args = detail::split_up(std::move(commandline));
619 // remove all empty strings
620 args.erase(std::remove(args.begin(), args.end(), std::string{}), args.end());
621 try {
622 detail::remove_quotes(args);
623 } catch(const std::invalid_argument &arg) {
624 throw CLI::ParseError(arg.what(), CLI::ExitCodes::InvalidError);
625 }
626 std::reverse(args.begin(), args.end());
627 parse(std::move(args));
628}
629
630CLI11_INLINE void App::parse(std::wstring commandline, bool program_name_included) {
631 parse(narrow(commandline), program_name_included);
632}
633
634CLI11_INLINE void App::parse(std::vector<std::string> &args) {
635 // Clear if parsed
636 if(parsed_ > 0)
637 clear();
638
639 // parsed_ is incremented in commands/subcommands,
640 // but placed here to make sure this is cleared when
641 // running parse after an error is thrown, even by _validate or _configure.
642 parsed_ = 1;
643 _validate();
644 _configure();
645 // set the parent as nullptr as this object should be the top now
646 parent_ = nullptr;
647 parsed_ = 0;
648
649 _parse(args);
650 run_callback();
651}
652
653CLI11_INLINE void App::parse(std::vector<std::string> &&args) {
654 // Clear if parsed
655 if(parsed_ > 0)
656 clear();
657
658 // parsed_ is incremented in commands/subcommands,
659 // but placed here to make sure this is cleared when
660 // running parse after an error is thrown, even by _validate or _configure.
661 parsed_ = 1;
662 _validate();
663 _configure();
664 // set the parent as nullptr as this object should be the top now
665 parent_ = nullptr;
666 parsed_ = 0;
667
668 _parse(std::move(args));
669 run_callback();
670}
671
672CLI11_INLINE void App::parse_from_stream(std::istream &input) {
673 if(parsed_ == 0) {
674 _validate();
675 _configure();
676 // set the parent as nullptr as this object should be the top now
677 }
678
679 _parse_stream(input);
680 run_callback();
681}
682
683CLI11_INLINE int App::exit(const Error &e, std::ostream &out, std::ostream &err) const {
684
686 if(e.get_name() == "RuntimeError")
687 return e.get_exit_code();
688
689 if(e.get_name() == "CallForHelp") {
690 out << help();
691 return e.get_exit_code();
692 }
693
694 if(e.get_name() == "CallForAllHelp") {
695 out << help("", AppFormatMode::All);
696 return e.get_exit_code();
697 }
698
699 if(e.get_name() == "CallForVersion") {
700 out << e.what() << '\n';
701 return e.get_exit_code();
702 }
703
704 if(e.get_exit_code() != static_cast<int>(ExitCodes::Success)) {
706 err << failure_message_(this, e) << std::flush;
707 }
708
709 return e.get_exit_code();
710}
711
712CLI11_INLINE std::vector<const App *> App::get_subcommands(const std::function<bool(const App *)> &filter) const {
713 std::vector<const App *> subcomms(subcommands_.size());
714 std::transform(
715 std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) { return v.get(); });
716
717 if(filter) {
718 subcomms.erase(std::remove_if(std::begin(subcomms),
719 std::end(subcomms),
720 [&filter](const App *app) { return !filter(app); }),
721 std::end(subcomms));
722 }
723
724 return subcomms;
725}
726
727CLI11_INLINE std::vector<App *> App::get_subcommands(const std::function<bool(App *)> &filter) {
728 std::vector<App *> subcomms(subcommands_.size());
729 std::transform(
730 std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) { return v.get(); });
731
732 if(filter) {
733 subcomms.erase(
734 std::remove_if(std::begin(subcomms), std::end(subcomms), [&filter](App *app) { return !filter(app); }),
735 std::end(subcomms));
736 }
737
738 return subcomms;
739}
740
741CLI11_INLINE bool App::remove_excludes(Option *opt) {
742 auto iterator = std::find(std::begin(exclude_options_), std::end(exclude_options_), opt);
743 if(iterator == std::end(exclude_options_)) {
744 return false;
745 }
746 exclude_options_.erase(iterator);
747 return true;
748}
749
750CLI11_INLINE bool App::remove_excludes(App *app) {
751 auto iterator = std::find(std::begin(exclude_subcommands_), std::end(exclude_subcommands_), app);
752 if(iterator == std::end(exclude_subcommands_)) {
753 return false;
754 }
755 auto *other_app = *iterator;
756 exclude_subcommands_.erase(iterator);
757 other_app->remove_excludes(this);
758 return true;
760
761CLI11_INLINE bool App::remove_needs(Option *opt) {
762 auto iterator = std::find(std::begin(need_options_), std::end(need_options_), opt);
763 if(iterator == std::end(need_options_)) {
764 return false;
765 }
766 need_options_.erase(iterator);
767 return true;
768}
769
770CLI11_INLINE bool App::remove_needs(App *app) {
771 auto iterator = std::find(std::begin(need_subcommands_), std::end(need_subcommands_), app);
772 if(iterator == std::end(need_subcommands_)) {
773 return false;
774 }
775 need_subcommands_.erase(iterator);
776 return true;
777}
778
779CLI11_NODISCARD CLI11_INLINE std::string App::help(std::string prev, AppFormatMode mode) const {
780 if(prev.empty())
781 prev = get_name();
782 else
783 prev += " " + get_name();
784
785 // Delegate to subcommand if needed
786 auto selected_subcommands = get_subcommands();
787 if(!selected_subcommands.empty()) {
788 return selected_subcommands.back()->help(prev, mode);
789 }
790 return formatter_->make_help(this, prev, mode);
791}
792
793CLI11_NODISCARD CLI11_INLINE std::string App::version() const {
794 std::string val;
795 if(version_ptr_ != nullptr) {
796 // copy the results for reuse later
797 results_t rv = version_ptr_->results();
799 version_ptr_->add_result("true");
800 try {
802 } catch(const CLI::CallForVersion &cfv) {
803 val = cfv.what();
804 }
807 }
808 return val;
809}
810
811CLI11_INLINE std::vector<const Option *> App::get_options(const std::function<bool(const Option *)> filter) const {
812 std::vector<const Option *> options(options_.size());
813 std::transform(
814 std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) { return val.get(); });
815
816 if(filter) {
817 options.erase(std::remove_if(std::begin(options),
818 std::end(options),
819 [&filter](const Option *opt) { return !filter(opt); }),
820 std::end(options));
821 }
822 for(const auto &subcp : subcommands_) {
823 // also check down into nameless subcommands
824 const App *subc = subcp.get();
825 if(subc->get_name().empty() && !subc->get_group().empty() && subc->get_group().front() == '+') {
826 std::vector<const Option *> subcopts = subc->get_options(filter);
827 options.insert(options.end(), subcopts.begin(), subcopts.end());
828 }
829 }
830 return options;
831}
832
833CLI11_INLINE std::vector<Option *> App::get_options(const std::function<bool(Option *)> filter) {
834 std::vector<Option *> options(options_.size());
835 std::transform(
836 std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) { return val.get(); });
837
838 if(filter) {
839 options.erase(
840 std::remove_if(std::begin(options), std::end(options), [&filter](Option *opt) { return !filter(opt); }),
841 std::end(options));
842 }
843 for(auto &subc : subcommands_) {
844 // also check down into nameless subcommands
845 if(subc->get_name().empty() && !subc->get_group().empty() && subc->get_group().front() == '+') {
846 auto subcopts = subc->get_options(filter);
847 options.insert(options.end(), subcopts.begin(), subcopts.end());
848 }
849 }
850 return options;
851}
852
853CLI11_NODISCARD CLI11_INLINE Option *App::get_option_no_throw(std::string option_name) noexcept {
854 for(Option_p &opt : options_) {
855 if(opt->check_name(option_name)) {
856 return opt.get();
857 }
858 }
859 for(auto &subc : subcommands_) {
860 // also check down into nameless subcommands
861 if(subc->get_name().empty()) {
862 auto *opt = subc->get_option_no_throw(option_name);
863 if(opt != nullptr) {
864 return opt;
865 }
866 }
867 }
868 return nullptr;
869}
870
871CLI11_NODISCARD CLI11_INLINE const Option *App::get_option_no_throw(std::string option_name) const noexcept {
872 for(const Option_p &opt : options_) {
873 if(opt->check_name(option_name)) {
874 return opt.get();
875 }
876 }
877 for(const auto &subc : subcommands_) {
878 // also check down into nameless subcommands
879 if(subc->get_name().empty()) {
880 auto *opt = subc->get_option_no_throw(option_name);
881 if(opt != nullptr) {
882 return opt;
883 }
884 }
885 }
886 return nullptr;
887}
888
889CLI11_NODISCARD CLI11_INLINE std::string App::get_display_name(bool with_aliases) const {
890 if(name_.empty()) {
891 return std::string("[Option Group: ") + get_group() + "]";
892 }
893 if(aliases_.empty() || !with_aliases) {
894 return name_;
895 }
896 std::string dispname = name_;
897 for(const auto &lalias : aliases_) {
898 dispname.push_back(',');
899 dispname.push_back(' ');
900 dispname.append(lalias);
901 }
902 return dispname;
903}
904
905CLI11_NODISCARD CLI11_INLINE bool App::check_name(std::string name_to_check) const {
906 auto result = check_name_detail(std::move(name_to_check));
907 return (result != NameMatch::none);
908}
909
910CLI11_NODISCARD CLI11_INLINE App::NameMatch App::check_name_detail(std::string name_to_check) const {
911 std::string local_name = name_;
913 local_name = detail::remove_underscore(name_);
914 name_to_check = detail::remove_underscore(name_to_check);
915 }
916 if(ignore_case_) {
917 local_name = detail::to_lower(name_);
918 name_to_check = detail::to_lower(name_to_check);
919 }
920
921 if(local_name == name_to_check) {
922 return App::NameMatch::exact;
923 }
924 if(allow_prefix_matching_ && name_to_check.size() < local_name.size()) {
925 if(local_name.compare(0, name_to_check.size(), name_to_check) == 0) {
926 return App::NameMatch::prefix;
927 }
928 }
929 for(std::string les : aliases_) { // NOLINT(performance-for-range-copy)
931 les = detail::remove_underscore(les);
932 }
933 if(ignore_case_) {
934 les = detail::to_lower(les);
935 }
936 if(les == name_to_check) {
937 return App::NameMatch::exact;
938 }
939 if(allow_prefix_matching_ && name_to_check.size() < les.size()) {
940 if(les.compare(0, name_to_check.size(), name_to_check) == 0) {
941 return App::NameMatch::prefix;
942 }
943 }
944 }
945 return App::NameMatch::none;
946}
947
948CLI11_NODISCARD CLI11_INLINE std::vector<std::string> App::get_groups() const {
949 std::vector<std::string> groups;
950
951 for(const Option_p &opt : options_) {
952 // Add group if it is not already in there
953 if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
954 groups.push_back(opt->get_group());
955 }
956 }
957
958 return groups;
959}
960
961CLI11_NODISCARD CLI11_INLINE std::vector<std::string> App::remaining(bool recurse) const {
962 std::vector<std::string> miss_list;
963 for(const std::pair<detail::Classifier, std::string> &miss : missing_) {
964 miss_list.push_back(std::get<1>(miss));
965 }
966 // Get from a subcommand that may allow extras
967 if(recurse) {
968 if(!allow_extras_) {
969 for(const auto &sub : subcommands_) {
970 if(sub->name_.empty() && !sub->missing_.empty()) {
971 for(const std::pair<detail::Classifier, std::string> &miss : sub->missing_) {
972 miss_list.push_back(std::get<1>(miss));
973 }
974 }
975 }
976 }
977 // Recurse into subcommands
978
979 for(const App *sub : parsed_subcommands_) {
980 std::vector<std::string> output = sub->remaining(recurse);
981 std::copy(std::begin(output), std::end(output), std::back_inserter(miss_list));
982 }
983 }
984 return miss_list;
985}
986
987CLI11_NODISCARD CLI11_INLINE std::vector<std::string> App::remaining_for_passthrough(bool recurse) const {
988 std::vector<std::string> miss_list = remaining(recurse);
989 std::reverse(std::begin(miss_list), std::end(miss_list));
990 return miss_list;
991}
992
993CLI11_NODISCARD CLI11_INLINE std::size_t App::remaining_size(bool recurse) const {
994 auto remaining_options = static_cast<std::size_t>(std::count_if(
995 std::begin(missing_), std::end(missing_), [](const std::pair<detail::Classifier, std::string> &val) {
996 return val.first != detail::Classifier::POSITIONAL_MARK;
997 }));
998
999 if(recurse) {
1000 for(const App_p &sub : subcommands_) {
1001 remaining_options += sub->remaining_size(recurse);
1002 }
1003 }
1004 return remaining_options;
1005}
1006
1007CLI11_INLINE void App::_validate() const {
1008 // count the number of positional only args
1009 auto pcount = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
1010 return opt->get_items_expected_max() >= detail::expected_max_vector_size && !opt->nonpositional();
1011 });
1012 if(pcount > 1) {
1013 auto pcount_req = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
1014 return opt->get_items_expected_max() >= detail::expected_max_vector_size && !opt->nonpositional() &&
1015 opt->get_required();
1016 });
1017 if(pcount - pcount_req > 1) {
1018 throw InvalidError(name_);
1019 }
1020 }
1021
1022 std::size_t nameless_subs{0};
1023 for(const App_p &app : subcommands_) {
1024 app->_validate();
1025 if(app->get_name().empty())
1026 ++nameless_subs;
1027 }
1028
1029 if(require_option_min_ > 0) {
1030 if(require_option_max_ > 0) {
1032 throw(InvalidError("Required min options greater than required max options", ExitCodes::InvalidError));
1033 }
1034 }
1035 if(require_option_min_ > (options_.size() + nameless_subs)) {
1036 throw(
1037 InvalidError("Required min options greater than number of available options", ExitCodes::InvalidError));
1038 }
1039 }
1040}
1041
1042CLI11_INLINE void App::_configure() {
1043 if(default_startup == startup_mode::enabled) {
1044 disabled_ = false;
1045 } else if(default_startup == startup_mode::disabled) {
1046 disabled_ = true;
1047 }
1048 for(const App_p &app : subcommands_) {
1049 if(app->has_automatic_name_) {
1050 app->name_.clear();
1051 }
1052 if(app->name_.empty()) {
1053 app->fallthrough_ = false; // make sure fallthrough_ is false to prevent infinite loop
1054 app->prefix_command_ = false;
1055 }
1056 // make sure the parent is set to be this object in preparation for parse
1057 app->parent_ = this;
1058 app->_configure();
1059 }
1060}
1061
1062CLI11_INLINE void App::run_callback(bool final_mode, bool suppress_final_callback) {
1063 pre_callback();
1064 // in the main app if immediate_callback_ is set it runs the main callback before the used subcommands
1065 if(!final_mode && parse_complete_callback_) {
1067 }
1068 // run the callbacks for the received subcommands
1069 for(App *subc : get_subcommands()) {
1070 if(subc->parent_ == this) {
1071 subc->run_callback(true, suppress_final_callback);
1072 }
1073 }
1074 // now run callbacks for option_groups
1075 for(auto &subc : subcommands_) {
1076 if(subc->name_.empty() && subc->count_all() > 0) {
1077 subc->run_callback(true, suppress_final_callback);
1078 }
1079 }
1080
1081 // finally run the main callback
1082 if(final_callback_ && (parsed_ > 0) && (!suppress_final_callback)) {
1083 if(!name_.empty() || count_all() > 0 || parent_ == nullptr) {
1085 }
1086 }
1087}
1088
1089CLI11_NODISCARD CLI11_INLINE bool App::_valid_subcommand(const std::string &current, bool ignore_used) const {
1090 // Don't match if max has been reached - but still check parents
1093 return parent_ != nullptr && parent_->_valid_subcommand(current, ignore_used);
1094 }
1095 auto *com = _find_subcommand(current, true, ignore_used);
1096 if(com != nullptr) {
1097 return true;
1098 }
1099 // Check parent if exists, else return false
1101 return parent_ != nullptr && parent_->_valid_subcommand(current, ignore_used);
1102 }
1103 return false;
1104}
1105
1106CLI11_NODISCARD CLI11_INLINE detail::Classifier App::_recognize(const std::string &current,
1107 bool ignore_used_subcommands) const {
1108 std::string dummy1, dummy2;
1109
1110 if(current == "--")
1111 return detail::Classifier::POSITIONAL_MARK;
1112 if(_valid_subcommand(current, ignore_used_subcommands))
1113 return detail::Classifier::SUBCOMMAND;
1114 if(detail::split_long(current, dummy1, dummy2))
1115 return detail::Classifier::LONG;
1116 if(detail::split_short(current, dummy1, dummy2)) {
1117 if((dummy1[0] >= '0' && dummy1[0] <= '9') ||
1118 (dummy1[0] == '.' && !dummy2.empty() && (dummy2[0] >= '0' && dummy2[0] <= '9'))) {
1119 // it looks like a number but check if it could be an option
1120 if(get_option_no_throw(std::string{'-', dummy1[0]}) == nullptr) {
1121 return detail::Classifier::NONE;
1122 }
1123 }
1124 return detail::Classifier::SHORT;
1125 }
1126 if((allow_windows_style_options_) && (detail::split_windows_style(current, dummy1, dummy2)))
1127 return detail::Classifier::WINDOWS_STYLE;
1128 if((current == "++") && !name_.empty() && parent_ != nullptr)
1129 return detail::Classifier::SUBCOMMAND_TERMINATOR;
1130 auto dotloc = current.find_first_of('.');
1131 if(dotloc != std::string::npos) {
1132 auto *cm = _find_subcommand(current.substr(0, dotloc), true, ignore_used_subcommands);
1133 if(cm != nullptr) {
1134 auto res = cm->_recognize(current.substr(dotloc + 1), ignore_used_subcommands);
1135 if(res == detail::Classifier::SUBCOMMAND) {
1136 return res;
1137 }
1138 }
1139 }
1140 return detail::Classifier::NONE;
1141}
1142
1143CLI11_INLINE bool App::_process_config_file(const std::string &config_file, bool throw_error) {
1144 auto path_result = detail::check_path(config_file.c_str());
1145 if(path_result == detail::path_type::file) {
1146 try {
1147 std::vector<ConfigItem> values = config_formatter_->from_file(config_file);
1148 _parse_config(values);
1149 return true;
1150 } catch(const FileError &) {
1151 if(throw_error) {
1152 throw;
1153 }
1154 return false;
1155 }
1156 } else if(throw_error) {
1157 throw FileError::Missing(config_file);
1158 } else {
1159 return false;
1160 }
1161}
1162
1163CLI11_INLINE void App::_process_config_file() {
1164 if(config_ptr_ != nullptr) {
1165 bool config_required = config_ptr_->get_required();
1166 auto file_given = config_ptr_->count() > 0;
1167 if(!(file_given || config_ptr_->envname_.empty())) {
1168 std::string ename_string = detail::get_environment_value(config_ptr_->envname_);
1169 if(!ename_string.empty()) {
1170 config_ptr_->add_result(ename_string);
1171 }
1172 }
1174
1175 auto config_files = config_ptr_->as<std::vector<std::string>>();
1176 bool files_used{file_given};
1177 if(config_files.empty() || config_files.front().empty()) {
1178 if(config_required) {
1179 throw FileError("config file is required but none was given");
1180 }
1181 return;
1182 }
1183 for(const auto &config_file : config_files) {
1184 if(_process_config_file(config_file, config_required || file_given)) {
1185 files_used = true;
1186 }
1187 }
1188 if(!files_used) {
1189 // this is done so the count shows as 0 if no callbacks were processed
1190 config_ptr_->clear();
1191 bool force = config_ptr_->force_callback_;
1195 }
1196 }
1197}
1198
1199CLI11_INLINE void App::_process_env() {
1200 for(const Option_p &opt : options_) {
1201 if(opt->count() == 0 && !opt->envname_.empty()) {
1202 std::string ename_string = detail::get_environment_value(opt->envname_);
1203 if(!ename_string.empty()) {
1204 std::string result = ename_string;
1205 result = opt->_validate(result, 0);
1206 if(result.empty()) {
1207 opt->add_result(ename_string);
1208 }
1209 }
1210 }
1211 }
1212
1213 for(App_p &sub : subcommands_) {
1214 if(sub->get_name().empty() || (sub->count_all() > 0 && !sub->parse_complete_callback_)) {
1215 // only process environment variables if the callback has actually been triggered already
1216 sub->_process_env();
1217 }
1218 }
1219}
1220
1221CLI11_INLINE void App::_process_callbacks() {
1222
1223 for(App_p &sub : subcommands_) {
1224 // process the priority option_groups first
1225 if(sub->get_name().empty() && sub->parse_complete_callback_) {
1226 if(sub->count_all() > 0) {
1227 sub->_process_callbacks();
1228 sub->run_callback();
1229 }
1230 }
1231 }
1232
1233 for(const Option_p &opt : options_) {
1234 if((*opt) && !opt->get_callback_run()) {
1235 opt->run_callback();
1236 }
1237 }
1238 for(App_p &sub : subcommands_) {
1239 if(!sub->parse_complete_callback_) {
1240 sub->_process_callbacks();
1241 }
1242 }
1243}
1244
1245CLI11_INLINE void App::_process_help_flags(bool trigger_help, bool trigger_all_help) const {
1246 const Option *help_ptr = get_help_ptr();
1247 const Option *help_all_ptr = get_help_all_ptr();
1248
1249 if(help_ptr != nullptr && help_ptr->count() > 0)
1250 trigger_help = true;
1251 if(help_all_ptr != nullptr && help_all_ptr->count() > 0)
1252 trigger_all_help = true;
1253
1254 // If there were parsed subcommands, call those. First subcommand wins if there are multiple ones.
1255 if(!parsed_subcommands_.empty()) {
1256 for(const App *sub : parsed_subcommands_)
1257 sub->_process_help_flags(trigger_help, trigger_all_help);
1258
1259 // Only the final subcommand should call for help. All help wins over help.
1260 } else if(trigger_all_help) {
1261 throw CallForAllHelp();
1262 } else if(trigger_help) {
1263 throw CallForHelp();
1264 }
1265}
1266
1267CLI11_INLINE void App::_process_requirements() {
1268 // check excludes
1269 bool excluded{false};
1270 std::string excluder;
1271 for(const auto &opt : exclude_options_) {
1272 if(opt->count() > 0) {
1273 excluded = true;
1274 excluder = opt->get_name();
1275 }
1276 }
1277 for(const auto &subc : exclude_subcommands_) {
1278 if(subc->count_all() > 0) {
1279 excluded = true;
1280 excluder = subc->get_display_name();
1281 }
1282 }
1283 if(excluded) {
1284 if(count_all() > 0) {
1285 throw ExcludesError(get_display_name(), excluder);
1286 }
1287 // if we are excluded but didn't receive anything, just return
1288 return;
1289 }
1290
1291 // check excludes
1292 bool missing_needed{false};
1293 std::string missing_need;
1294 for(const auto &opt : need_options_) {
1295 if(opt->count() == 0) {
1296 missing_needed = true;
1297 missing_need = opt->get_name();
1298 }
1299 }
1300 for(const auto &subc : need_subcommands_) {
1301 if(subc->count_all() == 0) {
1302 missing_needed = true;
1303 missing_need = subc->get_display_name();
1304 }
1305 }
1306 if(missing_needed) {
1307 if(count_all() > 0) {
1308 throw RequiresError(get_display_name(), missing_need);
1309 }
1310 // if we missing something but didn't have any options, just return
1311 return;
1312 }
1313
1314 std::size_t used_options = 0;
1315 for(const Option_p &opt : options_) {
1316
1317 if(opt->count() != 0) {
1318 ++used_options;
1319 }
1320 // Required but empty
1321 if(opt->get_required() && opt->count() == 0) {
1322 throw RequiredError(opt->get_name());
1323 }
1324 // Requires
1325 for(const Option *opt_req : opt->needs_)
1326 if(opt->count() > 0 && opt_req->count() == 0)
1327 throw RequiresError(opt->get_name(), opt_req->get_name());
1328 // Excludes
1329 for(const Option *opt_ex : opt->excludes_)
1330 if(opt->count() > 0 && opt_ex->count() != 0)
1331 throw ExcludesError(opt->get_name(), opt_ex->get_name());
1332 }
1333 // check for the required number of subcommands
1334 if(require_subcommand_min_ > 0) {
1335 auto selected_subcommands = get_subcommands();
1336 if(require_subcommand_min_ > selected_subcommands.size())
1337 throw RequiredError::Subcommand(require_subcommand_min_);
1338 }
1339
1340 // Max error cannot occur, the extra subcommand will parse as an ExtrasError or a remaining item.
1341
1342 // run this loop to check how many unnamed subcommands were actually used since they are considered options
1343 // from the perspective of an App
1344 for(App_p &sub : subcommands_) {
1345 if(sub->disabled_)
1346 continue;
1347 if(sub->name_.empty() && sub->count_all() > 0) {
1348 ++used_options;
1349 }
1350 }
1351
1352 if(require_option_min_ > used_options || (require_option_max_ > 0 && require_option_max_ < used_options)) {
1353 auto option_list = detail::join(options_, [this](const Option_p &ptr) {
1354 if(ptr.get() == help_ptr_ || ptr.get() == help_all_ptr_) {
1355 return std::string{};
1356 }
1357 return ptr->get_name(false, true);
1358 });
1359
1360 auto subc_list = get_subcommands([](App *app) { return ((app->get_name().empty()) && (!app->disabled_)); });
1361 if(!subc_list.empty()) {
1362 option_list += "," + detail::join(subc_list, [](const App *app) { return app->get_display_name(); });
1363 }
1364 throw RequiredError::Option(require_option_min_, require_option_max_, used_options, option_list);
1365 }
1366
1367 // now process the requirements for subcommands if needed
1368 for(App_p &sub : subcommands_) {
1369 if(sub->disabled_)
1370 continue;
1371 if(sub->name_.empty() && sub->required_ == false) {
1372 if(sub->count_all() == 0) {
1373 if(require_option_min_ > 0 && require_option_min_ <= used_options) {
1374 continue;
1375 // if we have met the requirement and there is nothing in this option group skip checking
1376 // requirements
1377 }
1378 if(require_option_max_ > 0 && used_options >= require_option_min_) {
1379 continue;
1380 // if we have met the requirement and there is nothing in this option group skip checking
1381 // requirements
1382 }
1383 }
1384 }
1385 if(sub->count() > 0 || sub->name_.empty()) {
1386 sub->_process_requirements();
1387 }
1388
1389 if(sub->required_ && sub->count_all() == 0) {
1390 throw(CLI::RequiredError(sub->get_display_name()));
1391 }
1392 }
1393}
1394
1395CLI11_INLINE void App::_process() {
1396 // help takes precedence over other potential errors and config and environment shouldn't be processed if help
1397 // throws
1399 try {
1400 // the config file might generate a FileError but that should not be processed until later in the process
1401 // to allow for help, version and other errors to generate first.
1403
1404 // process env shouldn't throw but no reason to process it if config generated an error
1405 _process_env();
1406 } catch(const CLI::FileError &) {
1407 // callbacks can generate exceptions which should take priority
1408 // over the config file error if one exists.
1410 throw;
1411 }
1412
1414
1416}
1417
1418CLI11_INLINE void App::_process_extras() {
1419 if(!(allow_extras_ || prefix_command_)) {
1420 std::size_t num_left_over = remaining_size();
1421 if(num_left_over > 0) {
1422 throw ExtrasError(name_, remaining(false));
1423 }
1424 }
1425
1426 for(App_p &sub : subcommands_) {
1427 if(sub->count() > 0)
1428 sub->_process_extras();
1429 }
1430}
1431
1432CLI11_INLINE void App::_process_extras(std::vector<std::string> &args) {
1433 if(!(allow_extras_ || prefix_command_)) {
1434 std::size_t num_left_over = remaining_size();
1435 if(num_left_over > 0) {
1436 args = remaining(false);
1437 throw ExtrasError(name_, args);
1438 }
1439 }
1440
1441 for(App_p &sub : subcommands_) {
1442 if(sub->count() > 0)
1443 sub->_process_extras(args);
1444 }
1445}
1446
1447CLI11_INLINE void App::increment_parsed() {
1448 ++parsed_;
1449 for(App_p &sub : subcommands_) {
1450 if(sub->get_name().empty())
1451 sub->increment_parsed();
1452 }
1453}
1454
1455CLI11_INLINE void App::_parse(std::vector<std::string> &args) {
1457 _trigger_pre_parse(args.size());
1458 bool positional_only = false;
1459
1460 while(!args.empty()) {
1461 if(!_parse_single(args, positional_only)) {
1462 break;
1463 }
1464 }
1465
1466 if(parent_ == nullptr) {
1467 _process();
1468
1469 // Throw error if any items are left over (depending on settings)
1470 _process_extras(args);
1471
1472 // Convert missing (pairs) to extras (string only) ready for processing in another app
1473 args = remaining_for_passthrough(false);
1474 } else if(parse_complete_callback_) {
1475 _process_env();
1479 run_callback(false, true);
1480 }
1481}
1482
1483CLI11_INLINE void App::_parse(std::vector<std::string> &&args) {
1484 // this can only be called by the top level in which case parent == nullptr by definition
1485 // operation is simplified
1487 _trigger_pre_parse(args.size());
1488 bool positional_only = false;
1489
1490 while(!args.empty()) {
1491 _parse_single(args, positional_only);
1492 }
1493 _process();
1494
1495 // Throw error if any items are left over (depending on settings)
1497}
1498
1499CLI11_INLINE void App::_parse_stream(std::istream &input) {
1500 auto values = config_formatter_->from_config(input);
1501 _parse_config(values);
1503 _trigger_pre_parse(values.size());
1504 _process();
1505
1506 // Throw error if any items are left over (depending on settings)
1508}
1509
1510CLI11_INLINE void App::_parse_config(const std::vector<ConfigItem> &args) {
1511 for(const ConfigItem &item : args) {
1512 if(!_parse_single_config(item) && allow_config_extras_ == config_extras_mode::error)
1513 throw ConfigError::Extras(item.fullname());
1514 }
1515}
1516
1517CLI11_INLINE bool
1518App::_add_flag_like_result(Option *op, const ConfigItem &item, const std::vector<std::string> &inputs) {
1519 if(item.inputs.size() <= 1) {
1520 // Flag parsing
1521 auto res = config_formatter_->to_flag(item);
1522 bool converted{false};
1523 if(op->get_disable_flag_override()) {
1524 auto val = detail::to_flag_value(res);
1525 if(val == 1) {
1526 res = op->get_flag_value(item.name, "{}");
1527 converted = true;
1528 }
1529 }
1530
1531 if(!converted) {
1532 errno = 0;
1533 if(res != "{}" || op->get_expected_max() <= 1) {
1534 res = op->get_flag_value(item.name, res);
1535 }
1536 }
1537
1538 op->add_result(res);
1539 return true;
1540 }
1541 if(static_cast<int>(inputs.size()) > op->get_items_expected_max() &&
1542 op->get_multi_option_policy() != MultiOptionPolicy::TakeAll) {
1543 if(op->get_items_expected_max() > 1) {
1544 throw ArgumentMismatch::AtMost(item.fullname(), op->get_items_expected_max(), inputs.size());
1545 }
1546
1547 if(!op->get_disable_flag_override()) {
1548 throw ConversionError::TooManyInputsFlag(item.fullname());
1549 }
1550 // if the disable flag override is set then we must have the flag values match a known flag value
1551 // this is true regardless of the output value, so an array input is possible and must be accounted for
1552 for(const auto &res : inputs) {
1553 bool valid_value{false};
1554 if(op->default_flag_values_.empty()) {
1555 if(res == "true" || res == "false" || res == "1" || res == "0") {
1556 valid_value = true;
1557 }
1558 } else {
1559 for(const auto &valid_res : op->default_flag_values_) {
1560 if(valid_res.second == res) {
1561 valid_value = true;
1562 break;
1563 }
1564 }
1565 }
1566
1567 if(valid_value) {
1568 op->add_result(res);
1569 } else {
1570 throw InvalidError("invalid flag argument given");
1571 }
1572 }
1573 return true;
1574 }
1575 return false;
1576}
1577
1578CLI11_INLINE bool App::_parse_single_config(const ConfigItem &item, std::size_t level) {
1579
1580 if(level < item.parents.size()) {
1581 auto *subcom = get_subcommand_no_throw(item.parents.at(level));
1582 return (subcom != nullptr) ? subcom->_parse_single_config(item, level + 1) : false;
1583 }
1584 // check for section open
1585 if(item.name == "++") {
1586 if(configurable_) {
1589 if(parent_ != nullptr) {
1590 parent_->parsed_subcommands_.push_back(this);
1591 }
1592 }
1593 return true;
1594 }
1595 // check for section close
1596 if(item.name == "--") {
1600 run_callback();
1601 }
1602 return true;
1603 }
1604 Option *op = get_option_no_throw("--" + item.name);
1605 if(op == nullptr) {
1606 if(item.name.size() == 1) {
1607 op = get_option_no_throw("-" + item.name);
1608 }
1609 if(op == nullptr) {
1610 op = get_option_no_throw(item.name);
1611 } else if(!op->get_configurable()) {
1612 auto *testop = get_option_no_throw(item.name);
1613 if(testop != nullptr && testop->get_configurable()) {
1614 op = testop;
1615 }
1616 }
1617 } else if(!op->get_configurable()) {
1618 if(item.name.size() == 1) {
1619 auto *testop = get_option_no_throw("-" + item.name);
1620 if(testop != nullptr && testop->get_configurable()) {
1621 op = testop;
1622 }
1623 }
1624 if(!op->get_configurable()) {
1625 auto *testop = get_option_no_throw(item.name);
1626 if(testop != nullptr && testop->get_configurable()) {
1627 op = testop;
1628 }
1629 }
1630 }
1631
1632 if(op == nullptr) {
1633 // If the option was not present
1634 if(get_allow_config_extras() == config_extras_mode::capture) {
1635 // Should we worry about classifying the extras properly?
1636 missing_.emplace_back(detail::Classifier::NONE, item.fullname());
1637 for(const auto &input : item.inputs) {
1638 missing_.emplace_back(detail::Classifier::NONE, input);
1639 }
1640 }
1641 return false;
1642 }
1643
1644 if(!op->get_configurable()) {
1645 if(get_allow_config_extras() == config_extras_mode::ignore_all) {
1646 return false;
1647 }
1648 throw ConfigError::NotConfigurable(item.fullname());
1649 }
1650 if(op->empty()) {
1651 std::vector<std::string> buffer; // a buffer to use for copying an modifying inputs in a few cases
1652 bool useBuffer{false};
1653 if(item.multiline) {
1654 if(!op->get_inject_separator()) {
1655 buffer = item.inputs;
1656 buffer.erase(std::remove(buffer.begin(), buffer.end(), "%%"), buffer.end());
1657 useBuffer = true;
1658 }
1659 }
1660 const std::vector<std::string> &inputs = (useBuffer) ? buffer : item.inputs;
1661 if(op->get_expected_min() == 0) {
1662 if(_add_flag_like_result(op, item, inputs)) {
1663 return true;
1664 }
1665 }
1666 op->add_result(inputs);
1667 op->run_callback();
1668 }
1669
1670 return true;
1671}
1672
1673CLI11_INLINE bool App::_parse_single(std::vector<std::string> &args, bool &positional_only) {
1674 bool retval = true;
1675 detail::Classifier classifier = positional_only ? detail::Classifier::NONE : _recognize(args.back());
1676 switch(classifier) {
1677 case detail::Classifier::POSITIONAL_MARK:
1678 args.pop_back();
1679 positional_only = true;
1680 if((!_has_remaining_positionals()) && (parent_ != nullptr)) {
1681 retval = false;
1682 } else {
1683 _move_to_missing(classifier, "--");
1684 }
1685 break;
1686 case detail::Classifier::SUBCOMMAND_TERMINATOR:
1687 // treat this like a positional mark if in the parent app
1688 args.pop_back();
1689 retval = false;
1690 break;
1691 case detail::Classifier::SUBCOMMAND:
1692 retval = _parse_subcommand(args);
1693 break;
1694 case detail::Classifier::LONG:
1695 case detail::Classifier::SHORT:
1696 case detail::Classifier::WINDOWS_STYLE:
1697 // If already parsed a subcommand, don't accept options_
1698 retval = _parse_arg(args, classifier, false);
1699 break;
1700 case detail::Classifier::NONE:
1701 // Probably a positional or something for a parent (sub)command
1702 retval = _parse_positional(args, false);
1703 if(retval && positionals_at_end_) {
1704 positional_only = true;
1705 }
1706 break;
1707 // LCOV_EXCL_START
1708 default:
1709 throw HorribleError("unrecognized classifier (you should not see this!)");
1710 // LCOV_EXCL_STOP
1711 }
1712 return retval;
1713}
1714
1715CLI11_NODISCARD CLI11_INLINE std::size_t App::_count_remaining_positionals(bool required_only) const {
1716 std::size_t retval = 0;
1717 for(const Option_p &opt : options_) {
1718 if(opt->get_positional() && (!required_only || opt->get_required())) {
1719 if(opt->get_items_expected_min() > 0 && static_cast<int>(opt->count()) < opt->get_items_expected_min()) {
1720 retval += static_cast<std::size_t>(opt->get_items_expected_min()) - opt->count();
1721 }
1722 }
1723 }
1724 return retval;
1725}
1726
1727CLI11_NODISCARD CLI11_INLINE bool App::_has_remaining_positionals() const {
1728 for(const Option_p &opt : options_) {
1729 if(opt->get_positional() && ((static_cast<int>(opt->count()) < opt->get_items_expected_min()))) {
1730 return true;
1731 }
1732 }
1733
1734 return false;
1735}
1736
1737CLI11_INLINE bool App::_parse_positional(std::vector<std::string> &args, bool haltOnSubcommand) {
1738
1739 const std::string &positional = args.back();
1740 Option *posOpt{nullptr};
1741
1743 // deal with the case of required arguments at the end which should take precedence over other arguments
1744 auto arg_rem = args.size();
1745 auto remreq = _count_remaining_positionals(true);
1746 if(arg_rem <= remreq) {
1747 for(const Option_p &opt : options_) {
1748 if(opt->get_positional() && opt->required_) {
1749 if(static_cast<int>(opt->count()) < opt->get_items_expected_min()) {
1751 std::string pos = positional;
1752 pos = opt->_validate(pos, 0);
1753 if(!pos.empty()) {
1754 continue;
1755 }
1756 }
1757 posOpt = opt.get();
1758 break;
1759 }
1760 }
1761 }
1762 }
1763 }
1764 if(posOpt == nullptr) {
1765 for(const Option_p &opt : options_) {
1766 // Eat options, one by one, until done
1767 if(opt->get_positional() &&
1768 (static_cast<int>(opt->count()) < opt->get_items_expected_max() || opt->get_allow_extra_args())) {
1770 std::string pos = positional;
1771 pos = opt->_validate(pos, 0);
1772 if(!pos.empty()) {
1773 continue;
1774 }
1775 }
1776 posOpt = opt.get();
1777 break;
1778 }
1779 }
1780 }
1781 if(posOpt != nullptr) {
1782 parse_order_.push_back(posOpt);
1783 if(posOpt->get_inject_separator()) {
1784 if(!posOpt->results().empty() && !posOpt->results().back().empty()) {
1785 posOpt->add_result(std::string{});
1786 }
1787 }
1788 if(posOpt->get_trigger_on_parse() && posOpt->current_option_state_ == Option::option_state::callback_run) {
1789 posOpt->clear();
1790 }
1791 if(posOpt->get_expected_min() == 0) {
1792 ConfigItem item;
1793 item.name = posOpt->pname_;
1794 item.inputs.push_back(positional);
1795 // input is singular guaranteed to return true in that case
1796 _add_flag_like_result(posOpt, item, item.inputs);
1797 } else {
1798 posOpt->add_result(positional);
1799 }
1800
1801 if(posOpt->get_trigger_on_parse()) {
1802 if(!posOpt->empty()) {
1803 posOpt->run_callback();
1804 }
1805 }
1806
1807 args.pop_back();
1808 return true;
1809 }
1810
1811 for(auto &subc : subcommands_) {
1812 if((subc->name_.empty()) && (!subc->disabled_)) {
1813 if(subc->_parse_positional(args, false)) {
1814 if(!subc->pre_parse_called_) {
1815 subc->_trigger_pre_parse(args.size());
1816 }
1817 return true;
1818 }
1819 }
1820 }
1821 // let the parent deal with it if possible
1822 if(parent_ != nullptr && fallthrough_) {
1823 return _get_fallthrough_parent()->_parse_positional(args, static_cast<bool>(parse_complete_callback_));
1824 }
1826 auto *com = _find_subcommand(args.back(), true, false);
1827 if(com != nullptr && (require_subcommand_max_ == 0 || require_subcommand_max_ > parsed_subcommands_.size())) {
1828 if(haltOnSubcommand) {
1829 return false;
1830 }
1831 args.pop_back();
1832 com->_parse(args);
1833 return true;
1834 }
1838 auto *parent_app = (parent_ != nullptr) ? _get_fallthrough_parent() : this;
1839 com = parent_app->_find_subcommand(args.back(), true, false);
1840 if(com != nullptr && (com->parent_->require_subcommand_max_ == 0 ||
1841 com->parent_->require_subcommand_max_ > com->parent_->parsed_subcommands_.size())) {
1842 return false;
1843 }
1844 }
1846 std::vector<std::string> rargs;
1847 rargs.resize(args.size());
1848 std::reverse_copy(args.begin(), args.end(), rargs.begin());
1849 throw CLI::ExtrasError(name_, rargs);
1850 }
1852 if(parent_ != nullptr && name_.empty()) {
1853 return false;
1854 }
1856 _move_to_missing(detail::Classifier::NONE, positional);
1857 args.pop_back();
1858 if(prefix_command_) {
1859 while(!args.empty()) {
1860 _move_to_missing(detail::Classifier::NONE, args.back());
1861 args.pop_back();
1862 }
1863 }
1864
1865 return true;
1866}
1867
1868CLI11_NODISCARD CLI11_INLINE App *
1869App::_find_subcommand(const std::string &subc_name, bool ignore_disabled, bool ignore_used) const noexcept {
1870 App *bcom{nullptr};
1871 for(const App_p &com : subcommands_) {
1872 if(com->disabled_ && ignore_disabled)
1873 continue;
1874 if(com->get_name().empty()) {
1875 auto *subc = com->_find_subcommand(subc_name, ignore_disabled, ignore_used);
1876 if(subc != nullptr) {
1877 if(bcom != nullptr) {
1878 return nullptr;
1879 }
1880 bcom = subc;
1881 if(!allow_prefix_matching_) {
1882 return bcom;
1883 }
1884 }
1885 }
1886 auto res = com->check_name_detail(subc_name);
1887 if(res != NameMatch::none) {
1888 if((!*com) || !ignore_used) {
1889 if(res == NameMatch::exact) {
1890 return com.get();
1891 }
1892 if(bcom != nullptr) {
1893 return nullptr;
1894 }
1895 bcom = com.get();
1896 if(!allow_prefix_matching_) {
1897 return bcom;
1898 }
1899 }
1900 }
1901 }
1902 return bcom;
1903}
1904
1905CLI11_INLINE bool App::_parse_subcommand(std::vector<std::string> &args) {
1906 if(_count_remaining_positionals(/* required */ true) > 0) {
1907 _parse_positional(args, false);
1908 return true;
1909 }
1910 auto *com = _find_subcommand(args.back(), true, true);
1911 if(com == nullptr) {
1912 // the main way to get here is using .notation
1913 auto dotloc = args.back().find_first_of('.');
1914 if(dotloc != std::string::npos) {
1915 com = _find_subcommand(args.back().substr(0, dotloc), true, true);
1916 if(com != nullptr) {
1917 args.back() = args.back().substr(dotloc + 1);
1918 args.push_back(com->get_display_name());
1919 }
1920 }
1921 }
1922 if(com != nullptr) {
1923 args.pop_back();
1924 if(!com->silent_) {
1925 parsed_subcommands_.push_back(com);
1926 }
1927 com->_parse(args);
1928 auto *parent_app = com->parent_;
1929 while(parent_app != this) {
1930 parent_app->_trigger_pre_parse(args.size());
1931 if(!com->silent_) {
1932 parent_app->parsed_subcommands_.push_back(com);
1933 }
1934 parent_app = parent_app->parent_;
1935 }
1936 return true;
1937 }
1938
1939 if(parent_ == nullptr)
1940 throw HorribleError("Subcommand " + args.back() + " missing");
1941 return false;
1942}
1943
1944CLI11_INLINE bool
1945App::_parse_arg(std::vector<std::string> &args, detail::Classifier current_type, bool local_processing_only) {
1946
1947 std::string current = args.back();
1948
1949 std::string arg_name;
1950 std::string value;
1951 std::string rest;
1952
1953 switch(current_type) {
1954 case detail::Classifier::LONG:
1955 if(!detail::split_long(current, arg_name, value))
1956 throw HorribleError("Long parsed but missing (you should not see this):" + args.back());
1957 break;
1958 case detail::Classifier::SHORT:
1959 if(!detail::split_short(current, arg_name, rest))
1960 throw HorribleError("Short parsed but missing! You should not see this");
1961 break;
1962 case detail::Classifier::WINDOWS_STYLE:
1963 if(!detail::split_windows_style(current, arg_name, value))
1964 throw HorribleError("windows option parsed but missing! You should not see this");
1965 break;
1966 case detail::Classifier::SUBCOMMAND:
1967 case detail::Classifier::SUBCOMMAND_TERMINATOR:
1968 case detail::Classifier::POSITIONAL_MARK:
1969 case detail::Classifier::NONE:
1970 default:
1971 throw HorribleError("parsing got called with invalid option! You should not see this");
1972 }
1973
1974 auto op_ptr = std::find_if(std::begin(options_), std::end(options_), [arg_name, current_type](const Option_p &opt) {
1975 if(current_type == detail::Classifier::LONG)
1976 return opt->check_lname(arg_name);
1977 if(current_type == detail::Classifier::SHORT)
1978 return opt->check_sname(arg_name);
1979 // this will only get called for detail::Classifier::WINDOWS_STYLE
1980 return opt->check_lname(arg_name) || opt->check_sname(arg_name);
1981 });
1982
1983 // Option not found
1984 while(op_ptr == std::end(options_)) {
1985 // using while so we can break
1986 for(auto &subc : subcommands_) {
1987 if(subc->name_.empty() && !subc->disabled_) {
1988 if(subc->_parse_arg(args, current_type, local_processing_only)) {
1989 if(!subc->pre_parse_called_) {
1990 subc->_trigger_pre_parse(args.size());
1991 }
1992 return true;
1993 }
1994 }
1995 }
1996 if(allow_non_standard_options_ && current_type == detail::Classifier::SHORT && current.size() > 2) {
1997 std::string narg_name;
1998 std::string nvalue;
1999 detail::split_long(std::string{'-'} + current, narg_name, nvalue);
2000 op_ptr = std::find_if(std::begin(options_), std::end(options_), [narg_name](const Option_p &opt) {
2001 return opt->check_sname(narg_name);
2002 });
2003 if(op_ptr != std::end(options_)) {
2004 arg_name = narg_name;
2005 value = nvalue;
2006 rest.clear();
2007 break;
2008 }
2009 }
2010
2011 // don't capture missing if this is a nameless subcommand and nameless subcommands can't fallthrough
2012 if(parent_ != nullptr && name_.empty()) {
2013 return false;
2014 }
2015
2016 // now check for '.' notation of subcommands
2017 auto dotloc = arg_name.find_first_of('.', 1);
2018 if(dotloc != std::string::npos && dotloc < arg_name.size() - 1) {
2019 // using dot notation is equivalent to single argument subcommand
2020 auto *sub = _find_subcommand(arg_name.substr(0, dotloc), true, false);
2021 if(sub != nullptr) {
2022 std::string v = args.back();
2023 args.pop_back();
2024 arg_name = arg_name.substr(dotloc + 1);
2025 if(arg_name.size() > 1) {
2026 args.push_back(std::string("--") + v.substr(dotloc + 3));
2027 current_type = detail::Classifier::LONG;
2028 } else {
2029 auto nval = v.substr(dotloc + 2);
2030 nval.front() = '-';
2031 if(nval.size() > 2) {
2032 // '=' not allowed in short form arguments
2033 args.push_back(nval.substr(3));
2034 nval.resize(2);
2035 }
2036 args.push_back(nval);
2037 current_type = detail::Classifier::SHORT;
2038 }
2039 std::string dummy1, dummy2;
2040 bool val = false;
2041 if((current_type == detail::Classifier::SHORT && detail::valid_first_char(args.back()[1])) ||
2042 detail::split_long(args.back(), dummy1, dummy2)) {
2043 val = sub->_parse_arg(args, current_type, true);
2044 }
2045
2046 if(val) {
2047 if(!sub->silent_) {
2048 parsed_subcommands_.push_back(sub);
2049 }
2050 // deal with preparsing
2052 _trigger_pre_parse(args.size());
2053 // run the parse complete callback since the subcommand processing is now complete
2054 if(sub->parse_complete_callback_) {
2055 sub->_process_env();
2056 sub->_process_callbacks();
2057 sub->_process_help_flags();
2058 sub->_process_requirements();
2059 sub->run_callback(false, true);
2060 }
2061 return true;
2062 }
2063 args.pop_back();
2064 args.push_back(v);
2065 }
2066 }
2067 if(local_processing_only) {
2068 return false;
2069 }
2070 // If a subcommand, try the main command
2071 if(parent_ != nullptr && fallthrough_)
2072 return _get_fallthrough_parent()->_parse_arg(args, current_type, false);
2073
2074 // Otherwise, add to missing
2075 args.pop_back();
2076 _move_to_missing(current_type, current);
2077 return true;
2078 }
2079
2080 args.pop_back();
2081
2082 // Get a reference to the pointer to make syntax bearable
2083 Option_p &op = *op_ptr;
2085 if(op->get_inject_separator()) {
2086 if(!op->results().empty() && !op->results().back().empty()) {
2087 op->add_result(std::string{});
2088 }
2089 }
2090 if(op->get_trigger_on_parse() && op->current_option_state_ == Option::option_state::callback_run) {
2091 op->clear();
2092 }
2093 int min_num = (std::min)(op->get_type_size_min(), op->get_items_expected_min());
2094 int max_num = op->get_items_expected_max();
2095 // check container like options to limit the argument size to a single type if the allow_extra_flags argument is
2096 // set. 16 is somewhat arbitrary (needs to be at least 4)
2097 if(max_num >= detail::expected_max_vector_size / 16 && !op->get_allow_extra_args()) {
2098 auto tmax = op->get_type_size_max();
2099 max_num = detail::checked_multiply(tmax, op->get_expected_min()) ? tmax : detail::expected_max_vector_size;
2100 }
2101 // Make sure we always eat the minimum for unlimited vectors
2102 int collected = 0; // total number of arguments collected
2103 int result_count = 0; // local variable for number of results in a single arg string
2104 // deal with purely flag like things
2105 if(max_num == 0) {
2106 auto res = op->get_flag_value(arg_name, value);
2107 op->add_result(res);
2108 parse_order_.push_back(op.get());
2109 } else if(!value.empty()) { // --this=value
2110 op->add_result(value, result_count);
2111 parse_order_.push_back(op.get());
2112 collected += result_count;
2113 // -Trest
2114 } else if(!rest.empty()) {
2115 op->add_result(rest, result_count);
2116 parse_order_.push_back(op.get());
2117 rest = "";
2118 collected += result_count;
2119 }
2120
2121 // gather the minimum number of arguments
2122 while(min_num > collected && !args.empty()) {
2123 std::string current_ = args.back();
2124 args.pop_back();
2125 op->add_result(current_, result_count);
2126 parse_order_.push_back(op.get());
2127 collected += result_count;
2128 }
2129
2130 if(min_num > collected) { // if we have run out of arguments and the minimum was not met
2131 throw ArgumentMismatch::TypedAtLeast(op->get_name(), min_num, op->get_type_name());
2132 }
2133
2134 // now check for optional arguments
2135 if(max_num > collected || op->get_allow_extra_args()) { // we allow optional arguments
2136 auto remreqpos = _count_remaining_positionals(true);
2137 // we have met the minimum now optionally check up to the maximum
2138 while((collected < max_num || op->get_allow_extra_args()) && !args.empty() &&
2139 _recognize(args.back(), false) == detail::Classifier::NONE) {
2140 // If any required positionals remain, don't keep eating
2141 if(remreqpos >= args.size()) {
2142 break;
2143 }
2145 std::string arg = args.back();
2146 arg = op->_validate(arg, 0);
2147 if(!arg.empty()) {
2148 break;
2149 }
2150 }
2151 op->add_result(args.back(), result_count);
2152 parse_order_.push_back(op.get());
2153 args.pop_back();
2154 collected += result_count;
2155 }
2156
2157 // Allow -- to end an unlimited list and "eat" it
2158 if(!args.empty() && _recognize(args.back()) == detail::Classifier::POSITIONAL_MARK)
2159 args.pop_back();
2160 // optional flag that didn't receive anything now get the default value
2161 if(min_num == 0 && max_num > 0 && collected == 0) {
2162 auto res = op->get_flag_value(arg_name, std::string{});
2163 op->add_result(res);
2164 parse_order_.push_back(op.get());
2165 }
2166 }
2167 // if we only partially completed a type then add an empty string if allowed for later processing
2168 if(min_num > 0 && (collected % op->get_type_size_max()) != 0) {
2169 if(op->get_type_size_max() != op->get_type_size_min()) {
2170 op->add_result(std::string{});
2171 } else {
2172 throw ArgumentMismatch::PartialType(op->get_name(), op->get_type_size_min(), op->get_type_name());
2173 }
2174 }
2175 if(op->get_trigger_on_parse()) {
2176 op->run_callback();
2177 }
2178 if(!rest.empty()) {
2179 rest = "-" + rest;
2180 args.push_back(rest);
2181 }
2182 return true;
2183}
2184
2185CLI11_INLINE void App::_trigger_pre_parse(std::size_t remaining_args) {
2186 if(!pre_parse_called_) {
2187 pre_parse_called_ = true;
2189 pre_parse_callback_(remaining_args);
2190 }
2191 } else if(immediate_callback_) {
2192 if(!name_.empty()) {
2193 auto pcnt = parsed_;
2194 missing_t extras = std::move(missing_);
2195 clear();
2196 parsed_ = pcnt;
2197 pre_parse_called_ = true;
2198 missing_ = std::move(extras);
2199 }
2200 }
2201}
2202
2204 if(parent_ == nullptr) {
2205 throw(HorribleError("No Valid parent"));
2206 }
2207 auto *fallthrough_parent = parent_;
2208 while((fallthrough_parent->parent_ != nullptr) && (fallthrough_parent->get_name().empty())) {
2209 fallthrough_parent = fallthrough_parent->parent_;
2210 }
2211 return fallthrough_parent;
2212}
2213
2214CLI11_NODISCARD CLI11_INLINE const std::string &App::_compare_subcommand_names(const App &subcom,
2215 const App &base) const {
2216 static const std::string estring;
2217 if(subcom.disabled_) {
2218 return estring;
2219 }
2220 for(const auto &subc : base.subcommands_) {
2221 if(subc.get() != &subcom) {
2222 if(subc->disabled_) {
2223 continue;
2224 }
2225 if(!subcom.get_name().empty()) {
2226 if(subc->check_name(subcom.get_name())) {
2227 return subcom.get_name();
2228 }
2229 }
2230 if(!subc->get_name().empty()) {
2231 if(subcom.check_name(subc->get_name())) {
2232 return subc->get_name();
2233 }
2234 }
2235 for(const auto &les : subcom.aliases_) {
2236 if(subc->check_name(les)) {
2237 return les;
2238 }
2239 }
2240 // this loop is needed in case of ignore_underscore or ignore_case on one but not the other
2241 for(const auto &les : subc->aliases_) {
2242 if(subcom.check_name(les)) {
2243 return les;
2244 }
2245 }
2246 // if the subcommand is an option group we need to check deeper
2247 if(subc->get_name().empty()) {
2248 const auto &cmpres = _compare_subcommand_names(subcom, *subc);
2249 if(!cmpres.empty()) {
2250 return cmpres;
2251 }
2252 }
2253 // if the test subcommand is an option group we need to check deeper
2254 if(subcom.get_name().empty()) {
2255 const auto &cmpres = _compare_subcommand_names(*subc, subcom);
2256 if(!cmpres.empty()) {
2257 return cmpres;
2258 }
2259 }
2260 }
2261 }
2262 return estring;
2263}
2264
2265CLI11_INLINE void App::_move_to_missing(detail::Classifier val_type, const std::string &val) {
2266 if(allow_extras_ || subcommands_.empty()) {
2267 missing_.emplace_back(val_type, val);
2268 return;
2269 }
2270 // allow extra arguments to be places in an option group if it is allowed there
2271 for(auto &subc : subcommands_) {
2272 if(subc->name_.empty() && subc->allow_extras_) {
2273 subc->missing_.emplace_back(val_type, val);
2274 return;
2275 }
2276 }
2277 // if we haven't found any place to put them yet put them in missing
2278 missing_.emplace_back(val_type, val);
2279}
2280
2281CLI11_INLINE void App::_move_option(Option *opt, App *app) {
2282 if(opt == nullptr) {
2283 throw OptionNotFound("the option is NULL");
2284 }
2285 // verify that the give app is actually a subcommand
2286 bool found = false;
2287 for(auto &subc : subcommands_) {
2288 if(app == subc.get()) {
2289 found = true;
2290 }
2291 }
2292 if(!found) {
2293 throw OptionNotFound("The Given app is not a subcommand");
2294 }
2295
2296 if((help_ptr_ == opt) || (help_all_ptr_ == opt))
2297 throw OptionAlreadyAdded("cannot move help options");
2298
2299 if(config_ptr_ == opt)
2300 throw OptionAlreadyAdded("cannot move config file options");
2301
2302 auto iterator =
2303 std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
2304 if(iterator != std::end(options_)) {
2305 const auto &opt_p = *iterator;
2306 if(std::find_if(std::begin(app->options_), std::end(app->options_), [&opt_p](const Option_p &v) {
2307 return (*v == *opt_p);
2308 }) == std::end(app->options_)) {
2309 // only erase after the insertion was successful
2310 app->options_.push_back(std::move(*iterator));
2311 options_.erase(iterator);
2312 } else {
2313 throw OptionAlreadyAdded("option was not located: " + opt->get_name());
2314 }
2315 } else {
2316 throw OptionNotFound("could not locate the given Option");
2317 }
2318}
2319
2320CLI11_INLINE void TriggerOn(App *trigger_app, App *app_to_enable) {
2321 app_to_enable->enabled_by_default(false);
2322 app_to_enable->disabled_by_default();
2323 trigger_app->preparse_callback([app_to_enable](std::size_t) { app_to_enable->disabled(false); });
2324}
2325
2326CLI11_INLINE void TriggerOn(App *trigger_app, std::vector<App *> apps_to_enable) {
2327 for(auto &app : apps_to_enable) {
2328 app->enabled_by_default(false);
2329 app->disabled_by_default();
2330 }
2331
2332 trigger_app->preparse_callback([apps_to_enable](std::size_t) {
2333 for(const auto &app : apps_to_enable) {
2334 app->disabled(false);
2335 }
2336 });
2337}
2338
2339CLI11_INLINE void TriggerOff(App *trigger_app, App *app_to_enable) {
2340 app_to_enable->disabled_by_default(false);
2341 app_to_enable->enabled_by_default();
2342 trigger_app->preparse_callback([app_to_enable](std::size_t) { app_to_enable->disabled(); });
2343}
2344
2345CLI11_INLINE void TriggerOff(App *trigger_app, std::vector<App *> apps_to_enable) {
2346 for(auto &app : apps_to_enable) {
2347 app->disabled_by_default(false);
2348 app->enabled_by_default();
2349 }
2350
2351 trigger_app->preparse_callback([apps_to_enable](std::size_t) {
2352 for(const auto &app : apps_to_enable) {
2353 app->disabled();
2354 }
2355 });
2356}
2357
2358CLI11_INLINE void deprecate_option(Option *opt, const std::string &replacement) {
2359 Validator deprecate_warning{[opt, replacement](std::string &) {
2360 std::cout << opt->get_name() << " is deprecated please use '" << replacement
2361 << "' instead\n";
2362 return std::string();
2363 },
2364 "DEPRECATED"};
2365 deprecate_warning.application_index(0);
2366 opt->check(deprecate_warning);
2367 if(!replacement.empty()) {
2368 opt->description(opt->get_description() + " DEPRECATED: please use '" + replacement + "' instead");
2369 }
2370}
2371
2372CLI11_INLINE void retire_option(App *app, Option *opt) {
2373 App temp;
2374 auto *option_copy = temp.add_option(opt->get_name(false, true))
2375 ->type_size(opt->get_type_size_min(), opt->get_type_size_max())
2376 ->expected(opt->get_expected_min(), opt->get_expected_max())
2377 ->allow_extra_args(opt->get_allow_extra_args());
2378
2379 app->remove_option(opt);
2380 auto *opt2 = app->add_option(option_copy->get_name(false, true), "option has been retired and has no effect");
2381 opt2->type_name("RETIRED")
2382 ->default_str("RETIRED")
2383 ->type_size(option_copy->get_type_size_min(), option_copy->get_type_size_max())
2384 ->expected(option_copy->get_expected_min(), option_copy->get_expected_max())
2385 ->allow_extra_args(option_copy->get_allow_extra_args());
2386
2387 // LCOV_EXCL_START
2388 // something odd with coverage on new compilers
2389 Validator retired_warning{[opt2](std::string &) {
2390 std::cout << "WARNING " << opt2->get_name() << " is retired and has no effect\n";
2391 return std::string();
2392 },
2393 ""};
2394 // LCOV_EXCL_STOP
2395 retired_warning.application_index(0);
2396 opt2->check(retired_warning);
2397}
2398
2399CLI11_INLINE void retire_option(App &app, Option *opt) { retire_option(&app, opt); }
2400
2401CLI11_INLINE void retire_option(App *app, const std::string &option_name) {
2402
2403 auto *opt = app->get_option_no_throw(option_name);
2404 if(opt != nullptr) {
2405 retire_option(app, opt);
2406 return;
2407 }
2408 auto *opt2 = app->add_option(option_name, "option has been retired and has no effect")
2409 ->type_name("RETIRED")
2410 ->expected(0, 1)
2411 ->default_str("RETIRED");
2412 // LCOV_EXCL_START
2413 // something odd with coverage on new compilers
2414 Validator retired_warning{[opt2](std::string &) {
2415 std::cout << "WARNING " << opt2->get_name() << " is retired and has no effect\n";
2416 return std::string();
2417 },
2418 ""};
2419 // LCOV_EXCL_STOP
2420 retired_warning.application_index(0);
2421 opt2->check(retired_warning);
2422}
2423
2424CLI11_INLINE void retire_option(App &app, const std::string &option_name) { retire_option(&app, option_name); }
2425
2426namespace FailureMessage {
2427
2428CLI11_INLINE std::string simple(const App *app, const Error &e) {
2429 std::string header = std::string(e.what()) + "\n";
2430 std::vector<std::string> names;
2431
2432 // Collect names
2433 if(app->get_help_ptr() != nullptr)
2434 names.push_back(app->get_help_ptr()->get_name());
2435
2436 if(app->get_help_all_ptr() != nullptr)
2437 names.push_back(app->get_help_all_ptr()->get_name());
2438
2439 // If any names found, suggest those
2440 if(!names.empty())
2441 header += "Run with " + detail::join(names, " or ") + " for more information.\n";
2442
2443 return header;
2444}
2445
2446CLI11_INLINE std::string help(const App *app, const Error &e) {
2447 std::string header = std::string("ERROR: ") + e.get_name() + ": " + e.what() + "\n";
2448 header += app->help();
2449 return header;
2450}
2451
2452} // namespace FailureMessage
2453
2454// [CLI11:app_inl_hpp:end]
2455} // namespace CLI
Creates a command line program, with very few defaults.
Definition App.hpp:98
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:853
bool subcommand_fallthrough_
Allow subcommands to fallthrough, so that parent commands can trigger other subcommands after subcomm...
Definition App.hpp:240
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:683
CLI11_NODISCARD std::string help(std::string prev="", AppFormatMode mode=AppFormatMode::Normal) const
Definition App_inl.hpp:779
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:993
CLI11_NODISCARD bool _has_remaining_positionals() const
Count the required remaining positional arguments.
Definition App_inl.hpp:1727
CLI11_NODISCARD 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.
Definition App_inl.hpp:1106
App * immediate_callback(bool immediate=true)
Set the subcommand callback to be executed immediately on subcommand completion.
Definition App_inl.hpp:121
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:258
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:2203
bool allow_non_standard_options_
indicator that the subcommand should allow non-standard option arguments, such as -single_dash_flag
Definition App.hpp:272
Option * config_ptr_
Pointer to the config option.
Definition App.hpp:306
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 disable...
Definition App.hpp:421
void _move_to_missing(detail::Classifier val_type, const std::string &val)
Helper function to place extra values in the most appropriate position.
Definition App_inl.hpp:2265
std::size_t require_option_min_
Minimum required options (not inheritable!)
Definition App.hpp:287
NameMatch
enumeration of matching possibilities
Definition App.hpp:1246
App * ignore_underscore(bool value=true)
Ignore underscore. Subcommands inherit value.
Definition App_inl.hpp:147
std::size_t require_subcommand_max_
Max number of subcommands allowed (parsing stops after this number). 0 is unlimited INHERITABLE.
Definition App.hpp:284
std::vector< App_p > subcommands_
Storage for subcommand list.
Definition App.hpp:227
CLI11_NODISCARD std::vector< std::string > remaining(bool recurse=false) const
This returns the missing options from the current subcommand.
Definition App_inl.hpp:961
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:987
std::uint32_t parsed_
Counts the number of times this command/subcommand was parsed.
Definition App.hpp:278
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:535
std::string usage_
Usage to put after program/subcommand description in the help output INHERITABLE.
Definition App.hpp:164
OptionDefaults option_defaults_
The default values for options, customizable and changeable INHERITABLE.
Definition App.hpp:154
void _process_help_flags(bool trigger_help=false, bool trigger_all_help=false) const
Definition App_inl.hpp:1245
void _process_requirements()
Verify required options and cross requirements. Subcommands too (only if selected).
Definition App_inl.hpp:1267
CLI11_NODISCARD std::size_t count_all() const
Definition App_inl.hpp:544
bool disabled_
If set to true the subcommand is disabled and cannot be used, ignored for main app.
Definition App.hpp:131
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:291
bool remove_needs(Option *opt)
Removes an option from the needs list of this subcommand.
Definition App_inl.hpp:761
Option * get_help_ptr()
Get a pointer to the help flag.
Definition App.hpp:1200
void _configure()
Definition App_inl.hpp:1042
CLI11_NODISCARD std::size_t _count_remaining_positionals(bool required_only=false) const
Count the required remaining positional arguments.
Definition App_inl.hpp:1715
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:367
void parse(int argc, const char *const *argv)
Definition App_inl.hpp:573
void _process_config_file()
Read and process a configuration file (main app only)
Definition App_inl.hpp:1163
std::string footer_
Footer to put after all options in the help output INHERITABLE.
Definition App.hpp:170
void increment_parsed()
Internal function to recursively increment the parsed counter on the current app as well unnamed subc...
Definition App_inl.hpp:1447
config_extras_mode allow_config_extras_
Definition App.hpp:119
CLI11_NODISCARD bool check_name(std::string name_to_check) const
Definition App_inl.hpp:905
Option * version_ptr_
A pointer to a version flag if there is one.
Definition App.hpp:182
CLI11_NODISCARD const Option * get_help_all_ptr() const
Get a pointer to the help all flag. (const)
Definition App.hpp:1206
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:465
App * parent_
A pointer to the parent if this is a subcommand.
Definition App.hpp:293
std::set< Option * > exclude_options_
Definition App.hpp:212
void _trigger_pre_parse(std::size_t remaining_args)
Trigger the pre_parse callback if needed.
Definition App_inl.hpp:2185
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:510
std::function< void()> parse_complete_callback_
This is a function that runs when parsing has finished.
Definition App.hpp:144
virtual void pre_callback()
Definition App.hpp:887
Option * add_flag(std::string flag_name)
Add a flag with no description or variable assignment.
Definition App.hpp:655
void _validate() const
Definition App_inl.hpp:1007
std::string name_
Subcommand name or program name (from parser if name is empty)
Definition App.hpp:109
std::vector< App * > parsed_subcommands_
This is a list of the subcommands collected, in order.
Definition App.hpp:205
bool ignore_underscore_
If true, the program should ignore underscores INHERITABLE.
Definition App.hpp:233
missing_t missing_
Definition App.hpp:199
void run_callback(bool final_mode=false, bool suppress_final_callback=false)
Internal function to run (App) callback, bottom up.
Definition App_inl.hpp:1062
bool allow_prefix_matching_
indicator to allow subcommands to match with prefix matching
Definition App.hpp:275
std::size_t require_subcommand_min_
Minimum required subcommands (not inheritable!)
Definition App.hpp:281
CLI11_NODISCARD NameMatch check_name_detail(std::string name_to_check) const
Definition App_inl.hpp:910
void _process_env()
Get envname options if not yet passed. Runs on all subcommands.
Definition App_inl.hpp:1199
std::function< std::string(const App *, const Error &e)> failure_message_
The error message printing function INHERITABLE.
Definition App.hpp:188
void _parse_stream(std::istream &input)
Internal function to parse a stream.
Definition App_inl.hpp:1499
CLI11_NODISCARD std::string get_display_name(bool with_aliases=false) const
Get a display name for an app.
Definition App_inl.hpp:889
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:125
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:2214
void clear()
Reset the parsed data.
Definition App_inl.hpp:558
App * enabled_by_default(bool enable=true)
Definition App.hpp:432
App * get_subcommand(const App *subcom) const
Definition App_inl.hpp:481
CLI11_NODISCARD std::string version() const
Displays a version string.
Definition App_inl.hpp:793
CLI11_NODISCARD App * get_subcommand_no_throw(std::string subcom) const noexcept
Definition App_inl.hpp:497
bool _add_flag_like_result(Option *op, const ConfigItem &item, const std::vector< std::string > &inputs)
store the results for a flag like option
Definition App_inl.hpp:1518
std::vector< Option_p > options_
The list of options, stored locally.
Definition App.hpp:157
Option * help_all_ptr_
A pointer to the help all flag if there is one INHERITABLE.
Definition App.hpp:179
bool validate_optional_arguments_
If set to true optional vector arguments are validated before assigning INHERITABLE.
Definition App.hpp:265
std::function< void()> final_callback_
This is a function that runs when all processing has completed.
Definition App.hpp:147
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:411
App(std::string app_description, std::string app_name, App *parent)
Special private constructor for subcommand.
Definition App_inl.hpp:29
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:434
App * preparse_callback(std::function< void(std::size_t)> pp_callback)
Definition App.hpp:374
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:350
bool positionals_at_end_
specify that positional arguments come at the end of the argument sequence not inheritable
Definition App.hpp:251
void _process()
Process callbacks and such.
Definition App_inl.hpp:1395
bool immediate_callback_
Definition App.hpp:138
bool _parse_single(std::vector< std::string > &args, bool &positional_only)
Definition App_inl.hpp:1673
App * name(std::string app_name="")
Set a name for the app (empty will use parser to set the name)
Definition App_inl.hpp:86
void _move_option(Option *opt, App *app)
function that could be used by subclasses of App to shift options around into subcommands
Definition App_inl.hpp:2281
void _process_extras()
Throw an error if anything is left over and should not be.
Definition App_inl.hpp:1418
CLI11_NODISCARD 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.
Definition App_inl.hpp:1089
bool configurable_
if set to true the subcommand can be triggered via configuration files INHERITABLE
Definition App.hpp:259
CLI11_NODISCARD std::vector< std::string > get_groups() const
Get the groups available directly from this option (in order)
Definition App_inl.hpp:948
void _parse_config(const std::vector< ConfigItem > &args)
Definition App_inl.hpp:1510
std::size_t require_option_max_
Max number of options allowed. 0 is unlimited (not inheritable)
Definition App.hpp:290
std::vector< std::string > aliases_
Alias names for the subcommand.
Definition App.hpp:299
std::set< App * > exclude_subcommands_
this is a list of subcommands that are exclusionary to this one
Definition App.hpp:208
bool _parse_positional(std::vector< std::string > &args, bool haltOnSubcommand)
Definition App_inl.hpp:1737
bool ignore_case_
If true, the program name is not case-sensitive INHERITABLE.
Definition App.hpp:230
CLI11_NODISCARD const std::string & get_group() const
Get the group of this subcommand.
Definition App.hpp:1138
bool _parse_arg(std::vector< std::string > &args, detail::Classifier current_type, bool local_processing_only)
Definition App_inl.hpp:1945
std::function< void(std::size_t)> pre_parse_callback_
This is a function that runs prior to the start of parsing.
Definition App.hpp:141
std::string group_
The group membership INHERITABLE.
Definition App.hpp:296
App * alias(std::string app_name)
Set an alias for the app.
Definition App_inl.hpp:103
bool pre_parse_called_
Flag indicating that the pre_parse_callback has been triggered.
Definition App.hpp:134
void _process_callbacks()
Process callbacks. Runs on all subcommands.
Definition App_inl.hpp:1221
Option * help_ptr_
A pointer to the help flag if there is one INHERITABLE.
Definition App.hpp:176
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:382
App * ignore_case(bool value=true)
Ignore case. Subcommands inherit value.
Definition App_inl.hpp:133
bool remove_excludes(Option *opt)
Removes an option from the excludes list of this subcommand.
Definition App_inl.hpp:741
CLI11_NODISCARD std::vector< App * > get_subcommands() const
Definition App.hpp:938
CLI11_NODISCARD config_extras_mode get_allow_config_extras() const
Get the status of allow extras.
Definition App.hpp:1197
bool _parse_subcommand(std::vector< std::string > &args)
Definition App_inl.hpp:1905
bool fallthrough_
Definition App.hpp:237
std::set< Option * > need_options_
Definition App.hpp:220
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:811
std::set< App * > need_subcommands_
Definition App.hpp:216
bool prefix_command_
If true, cease processing on an unrecognized option (implies allow_extras) INHERITABLE.
Definition App.hpp:122
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:161
std::vector< Option * > parse_order_
This is a list of pointers to options with the original parse order.
Definition App.hpp:202
void _parse(std::vector< std::string > &args)
Internal parse function.
Definition App_inl.hpp:1455
bool validate_positionals_
If set to true positional options are validated before assigning INHERITABLE.
Definition App.hpp:262
bool _parse_single_config(const ConfigItem &item, std::size_t level=0)
Fill in a single config option.
Definition App_inl.hpp:1578
startup_mode default_startup
Definition App.hpp:256
bool allow_extras_
If true, allow extra arguments (ie, don't throw an error). INHERITABLE.
Definition App.hpp:115
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:64
CLI11_NODISCARD App * _find_subcommand(const std::string &subc_name, bool ignore_disabled, bool ignore_used) const noexcept
Definition App_inl.hpp:1869
CLI11_NODISCARD const std::string & get_name() const
Get the name of the current app.
Definition App.hpp:1227
App * disabled(bool disable=true)
Disable the subcommand or option group.
Definition App.hpp:398
std::shared_ptr< FormatterBase > formatter_
This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
Definition App.hpp:185
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:274
bool allow_windows_style_options_
Allow '/' for options for Windows like options. Defaults to true on Windows, false otherwise....
Definition App.hpp:243
std::shared_ptr< Config > config_formatter_
This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
Definition App.hpp:309
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 too many positionals or options are found.
Definition Error.hpp:308
Thrown when parsing an INI file and it is missing.
Definition Error.hpp:198
Definition Error.hpp:343
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
CLI11_NODISCARD MultiOptionPolicy get_multi_option_policy() const
The status of the multi option policy.
Definition Option.hpp:139
CLI11_NODISCARD bool get_configurable() const
The status of configurable.
Definition Option.hpp:127
bool required_
True if this is a required option.
Definition Option.hpp:60
CLI11_NODISCARD bool get_disable_flag_override() const
The status of configurable.
Definition Option.hpp:130
CLI11_NODISCARD const std::string & get_group() const
Get the group of this option.
Definition Option.hpp:115
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:587
CLI11_NODISCARD bool check_name(const std::string &name) const
Check a name. Requires "-" or "--" for short / long, supports positional name.
Definition Option_inl.hpp:354
@ callback_run
the callback has been executed
std::set< Option * > needs_
A list of options that are required with this option.
Definition Option.hpp:297
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
std::set< Option * > excludes_
A list of options that are excluded with this option.
Definition Option.hpp:300
bool force_callback_
flag indicating that the option should force the callback regardless if any results present
Definition Option.hpp:340
CLI11_NODISCARD bool get_callback_run() const
See if the callback has been run already.
Definition Option.hpp:715
std::vector< std::string > fnames_
a list of flag names with specified default values;
Definition Option.hpp:249
CLI11_NODISCARD int get_items_expected_min() const
The total min number of expected string values to be used.
Definition Option.hpp:576
CLI11_NODISCARD const results_t & results() const
Get the current complete results set.
Definition Option.hpp:671
CLI11_NODISCARD int get_items_expected_max() const
Get the maximum number of items expected to be returned and used for the callback.
Definition Option.hpp:579
CLI11_NODISCARD std::size_t count() const
Count the total number of times an option was passed.
Definition Option.hpp:361
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 bool get_inject_separator() const
Return the inject_separator flag.
Definition Option.hpp:529
CLI11_NODISCARD std::string get_flag_value(const std::string &name, std::string input_value) const
Definition Option_inl.hpp:383
CLI11_NODISCARD const std::string & get_description() const
Get the description.
Definition Option.hpp:596
CLI11_NODISCARD bool empty() const
True if the option was not passed.
Definition Option.hpp:364
CLI11_NODISCARD int get_expected_min() const
The number of times the option expects to be included.
Definition Option.hpp:571
void clear()
Clear the parsed results (mostly for testing)
Definition Option.hpp:370
CLI11_NODISCARD int get_expected_max() const
The max number of times the option expects to be included.
Definition Option.hpp:573
Option * default_str(std::string val)
Set the default value string representation (does not change the contained value)
Definition Option.hpp:757
std::string envname_
If given, check the environment for this option.
Definition Option.hpp:255
CLI11_NODISCARD bool get_allow_extra_args() const
Get the current value of allow extra args.
Definition Option.hpp:392
std::vector< std::pair< std::string, std::string > > default_flag_values_
Definition Option.hpp:246
Option * add_result(std::string s)
Puts a result at the end.
Definition Option_inl.hpp:429
CLI11_NODISCARD T as() const
Return the results as the specified type.
Definition Option.hpp:708
Thrown when counting a nonexistent 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
std::vector< std::string > inputs
Listing of inputs.
Definition ConfigFwd.hpp:36
std::string name
This is the name.
Definition ConfigFwd.hpp:34
CLI11_NODISCARD std::string fullname() const
The list of parents and name joined by ".".
Definition ConfigFwd.hpp:40
bool multiline
indicator if a multiline vector separator was inserted
Definition ConfigFwd.hpp:38
std::vector< std::string > parents
This is the list of parents.
Definition ConfigFwd.hpp:31