170 const auto StartsWith = [](std::string_view string, std::string_view prefix) {
171 return string.size() >= prefix.size() &&
string.substr(0, prefix.size()) == prefix;
181 }
else if (flag.fName ==
name) {
203 std::vector<std::pair<std::size_t, std::string>> res;
204 res.reserve(
fArgs.size());
205 for (std::size_t i = 0; i <
fArgs.size(); ++i) {
218 for (
const auto &err :
fErrors)
219 stream << err <<
"\n";
247 std::string_view help =
"", std::uint32_t flagOpts = 0)
249 const auto IsPrefixOf = [](std::string_view
a, std::string_view
b) {
250 return a.size() <
b.size() && std::equal(
a.begin(),
a.end(),
b.begin());
253 if (aliases.size() == 0)
254 throw std::invalid_argument(
"AddFlag must receive at least 1 name for the flag!");
257 throw std::invalid_argument(
"Flag `" + std::string(*aliases.begin()) +
258 "` has option kFlagPrefixArg but it's a Switch, so the option makes no sense.");
260 std::vector<RExpectedFlag> flagsToBeAdded;
261 flagsToBeAdded.reserve(aliases.size());
265 for (
auto f : aliases) {
266 auto prefixLen =
f.find_first_not_of(
'-');
267 if (prefixLen != 1 && prefixLen != 2)
268 throw std::invalid_argument(std::string(
"Invalid flag `") + std::string(
f) +
269 "`: flags must start with '-' or '--'");
270 if (
f.size() == prefixLen)
271 throw std::invalid_argument(
"Flag name cannot be empty");
273 auto flagName =
f.substr(prefixLen);
280 if (expFlag.fName == flagName) {
281 throw std::invalid_argument(
282 "Flag `" + std::string(flagName) +
283 "` was added multiple times. Note that adding flags with the same name but different number of `-` "
284 "can only be done as aliases of the same call to AddFlag().");
291 if (((expFlag.fOpts &
kFlagPrefixArg) && IsPrefixOf(expFlag.fName, flagName)) ||
292 ((flagOpts &
kFlagPrefixArg) && IsPrefixOf(flagName, expFlag.fName))) {
293 throw std::invalid_argument(
"Flags `" + expFlag.AsStr() +
"` and `" + std::string(
f) +
294 "` have a common prefix. This causes ambiguity because at least one of them "
295 "is marked with kFlagPrefixArg.");
302 for (
const auto &expFlag : flagsToBeAdded) {
303 if (expFlag.AsStr() ==
f)
304 throw std::invalid_argument(
"The same flag `" + expFlag.AsStr() +
305 "` was passed multiple times to AddFlag().");
308 bool disallowsGrouping = (prefixLen == 1 && (
f.size() > 2 || (flagOpts &
kFlagPrefixArg)));
309 if (disallowsGrouping) {
313 throw std::invalid_argument(
314 std::string(
"Flags starting with a single dash must be 1 character long when `FlagTreatment == "
315 "EFlagTreatment::kGrouped'! Cannot accept given flag `") +
316 std::string(
f) +
"`");
322 expected.
fName = flagName;
323 expected.
fHelp = help;
324 expected.
fAlias = aliasIdx;
325 expected.
fShort = prefixLen == 1;
326 expected.
fOpts = flagOpts;
327 flagsToBeAdded.push_back(expected);
329 aliasIdx = nCurrentFlags + flagsToBeAdded.size() - 1;
342 throw std::invalid_argument(std::string(
"Flag `") + std::string(
name) +
"` is not expected");
344 throw std::invalid_argument(std::string(
"Flag `") + std::string(
name) +
"` is not a switch");
346 std::string_view lookedUpName =
name;
347 if (exp->fAlias >= 0)
352 n +=
f.fName == lookedUpName;
362 return values.empty() ?
"" : values[0];
372 throw std::invalid_argument(std::string(
"Flag `") + std::string(
name) +
"` is not expected");
374 throw std::invalid_argument(std::string(
"Flag `") + std::string(
name) +
"` is a switch, use GetSwitch()");
376 std::string_view lookedUpName =
name;
377 if (exp->fAlias >= 0)
380 std::vector<std::string_view> values;
382 if (
f.fName == lookedUpName)
383 values.push_back(
f.fValue);
394 template <
typename T>
397 auto values = GetFlagValuesAs<T>(
name);
398 return values.empty() ? std::nullopt : std::make_optional(values[0]);
406 template <
typename T>
409 static_assert(std::is_integral_v<T> || std::is_floating_point_v<T>);
411 std::vector<T> values;
417#if __cplusplus >= 202002L && !defined(__APPLE__)
419 auto res = std::from_chars(val.data(), val.data() + val.size(), converted);
420 if (res.ptr == val.data() + val.size() && res.ec == std::errc{}) {
421 values.push_back(converted);
423 std::stringstream err;
424 err <<
"Failed to parse flag `" <<
name <<
"` with value `" << val <<
"`";
425 if constexpr (std::is_integral_v<T>)
426 err <<
" as an integer.\n";
428 err <<
" as a floating point number.\n";
430 throw std::runtime_error(err.str());
433 std::conditional_t<std::is_integral_v<T>,
long long,
long double> converted = 0;
434 std::size_t unconvertedPos = 0;
436 if constexpr (std::is_integral_v<T>) {
437 converted = std::stoll(std::string(val), &unconvertedPos);
439 converted = std::stold(std::string(val), &unconvertedPos);
445 if (unconvertedPos != val.size() || converted > std::numeric_limits<T>::max()) {
446 std::stringstream err;
447 err <<
"Failed to parse flag `" <<
name <<
"` with value `" << val <<
"`";
448 if constexpr (std::is_integral_v<T>)
449 err <<
" as an integer.\n";
451 err <<
" as a floating point number.\n";
453 throw std::runtime_error(err.str());
456 values.push_back(converted);
463 void Parse(
const char *
const *
const args, std::size_t nArgs)
465 bool forcePositional =
false;
474 std::vector<std::string_view> argStr;
476 for (std::size_t argIndex = 0; argIndex < nArgs &&
fErrors.empty(); ++argIndex) {
477 const char *arg = args[argIndex];
478 const char *
const argOrig = arg;
479 const auto argIndexOrig = argIndex;
481 if (strcmp(arg,
"--") == 0 && !forcePositional) {
482 forcePositional =
true;
486 bool isFlag = !forcePositional && arg[0] ==
'-';
491 fArgs.push_back(arg);
502 std::string_view nxtArgStr;
504 bool nxtArgIsTentative =
true;
511 const auto argLen = strlen(arg);
513 if ((flag.fOpts &
kFlagPrefixArg) && flag.fName.size() < argLen &&
514 strncmp(arg, flag.fName.c_str(), flag.fName.size()) == 0) {
515 argStr.push_back(std::string_view(arg, flag.fName.size()));
516 nxtArgStr = std::string_view(arg + flag.fName.size(), argLen - flag.fName.size());
521 if (argStr.empty()) {
522 const char *eq = strchr(arg,
'=');
524 argStr.push_back(std::string_view(arg, eq - arg));
525 nxtArgStr = std::string_view(eq + 1);
526 nxtArgIsTentative =
false;
528 argStr.push_back(std::string_view(arg));
529 if (argIndex < nArgs - 1 && args[argIndex + 1][0] !=
'-') {
530 nxtArgStr = args[argIndex + 1];
538 auto argLen = strlen(arg);
540 argStr.push_back(std::string_view{arg, 1});
544 argStr.push_back(std::string_view(arg));
545 if (argIndex < nArgs - 1 && args[argIndex + 1][0] !=
'-') {
546 nxtArgStr = args[argIndex + 1];
553 for (
auto j = 0u; j < argStr.size(); ++j) {
554 std::string_view argS = argStr[j];
562 fErrors.push_back(std::string(
"Unknown flag: ") + argOrig);
574 if ((exp->fOpts &
kFlagPrefixArg) && argS.size() > exp->fName.size()) {
575 if (nxtArgIsTentative) {
576 argIndex -= !nxtArgStr.empty();
577 nxtArgStr = argS.substr(exp->fName.size());
578 nxtArgIsTentative =
false;
583 fErrors.push_back(std::string(
"Unknown flag: ") + argOrig);
587 assert(exp->fName.size() == argS.size());
590 std::string_view nxtArg = (j == argStr.size() - 1) ? nxtArgStr :
"";
593 flag.
fIndex = argIndexOrig;
594 flag.
fHelp = exp->fHelp;
598 flag.
fName = exp->fName;
605 std::find_if(
fFlags.begin(),
fFlags.end(), [&flag](
const auto &
f) { return f.fName == flag.fName; });
606 if (existingIt !=
fFlags.end()) {
607 std::string err = std::string(
"Flag ") + exp->AsStr() +
" appeared more than once";
609 err +=
" with the value: " + existingIt->fValue;
617 if (!nxtArg.empty()) {
620 fErrors.push_back(
"Missing argument for flag " + exp->AsStr());
623 if (!nxtArg.empty()) {
624 if (nxtArgIsTentative)
627 fErrors.push_back(
"Flag " + exp->AsStr() +
" does not expect an argument");
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Small utility to parse cmdline options.
std::vector< RFlag > fFlags
Flags, in order of appearance.
@ kSimple
-abc will always be treated as the single flag "-abc"
@ kDefault
Will result to kGrouped if you don't define any short flag longer than 1 character,...
@ kGrouped
-abc will be treated as "-a -b -c".
const RExpectedFlag * GetExpectedFlag(std::string_view name) const
void AddFlag(std::initializer_list< std::string_view > aliases, EFlagType type=EFlagType::kSwitch, std::string_view help="", std::uint32_t flagOpts=0)
Defines a new flag (either a switch or a flag with argument).
void Parse(const char *const *const args, std::size_t nArgs)
Parses the given arguments, allowing for their retrieval via GetSwitch, GetFlagValue,...
const std::vector< std::string > & GetErrors() const
Returns all parsing errors.
int GetSwitch(std::string_view name) const
If name refers to a previously-defined switch (i.e.
std::vector< std::size_t > fArgIndices
const std::vector< std::string > & GetArgs() const
Retrieves all positional arguments.
std::vector< T > GetFlagValuesAs(std::string_view name) const
Tries to retrieve the flag values as a type T.
const std::vector< std::size_t > & GetUnprocessedArgsIndices() const
Returns a list of the indices of all args passed to Parse() that were not parsed.
std::string_view GetFlagValue(std::string_view name) const
If name refers to a previously-defined non-switch flag, gets its value.
std::vector< RExpectedFlag > fExpectedFlags
const std::vector< RFlag > & GetFlags() const
Retrieves all parsed flags.
std::vector< std::size_t > fUnprocessedArgsIndices
Indices of all args passed to Parse() that were skipped.
std::vector< std::string > fArgs
Positional arguments, in order of appearance.
std::vector< std::string_view > GetFlagValues(std::string_view name) const
If name refers to a previously-defined non-switch flag, gets its values.
std::optional< std::size_t > GetFirstPostDashDashArg() const
Returns the index of the first positional argument that appeared after --.
bool ReportErrors(std::ostream &stream=std::cerr) const
Conveniency method to print any errors to stream.
RCmdLineOpts(RSettings settings={})
std::optional< T > GetFlagValueAs(std::string_view name) const
Tries to retrieve the flag value as a type T.
@ kFlagPrefixArg
Flag argument can appear right after this flag without a space or equal sign in between.
@ kFlagAllowMultiple
Flag is allowed to appear multiple times (default: it's an error to see the same flag twice)
const RSettings & GetSettings() const
std::vector< std::pair< std::size_t, std::string > > GetArgsWithIndices() const
Retrieves all positional arguments alongside their original position in the given args array.
std::optional< std::size_t > fFirstPostDashDashArg
Index of the first element in fArgs that appeared after --.
std::vector< std::string > fErrors
bool StartsWith(std::string_view string, std::string_view prefix)
std::string AsStr() const
EFlagTreatment fFlagTreatment
Affects how flags are parsed (.