mirror of
https://github.com/KeqingMoe/argparse.git
synced 2025-07-04 07:04:39 +00:00
Updated formatting
This commit is contained in:
Pranav Srinivas Kumar
parent
8df0a878ac
commit
cb04248cfa
@ -28,46 +28,45 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
*/
|
||||
#pragma once
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
#include <functional>
|
||||
#include <any>
|
||||
#include <memory>
|
||||
#include <type_traits>
|
||||
#include <algorithm>
|
||||
#include <any>
|
||||
#include <functional>
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <iterator>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <numeric>
|
||||
#include <sstream>
|
||||
#include <stdexcept>
|
||||
#include <numeric>
|
||||
#include <iomanip>
|
||||
#include <iterator>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
#include <vector>
|
||||
|
||||
namespace argparse {
|
||||
|
||||
namespace { // anonymous namespace for helper methods - not visible outside this header file
|
||||
namespace { // anonymous namespace for helper methods - not visible outside this
|
||||
// header file
|
||||
|
||||
template<typename... Ts>
|
||||
struct is_container_helper {};
|
||||
template <typename... Ts> struct is_container_helper {};
|
||||
|
||||
template<typename T, typename _ = void>
|
||||
template <typename T, typename _ = void>
|
||||
struct is_container : std::false_type {};
|
||||
|
||||
template<>
|
||||
struct is_container<std::string> : std::false_type {};
|
||||
template <> struct is_container<std::string> : std::false_type {};
|
||||
|
||||
template<typename T>
|
||||
struct is_container<T, std::conditional_t<
|
||||
false, is_container_helper<
|
||||
typename T::value_type,
|
||||
template <typename T>
|
||||
struct is_container<
|
||||
T,
|
||||
std::conditional_t<false,
|
||||
is_container_helper<typename T::value_type,
|
||||
decltype(std::declval<T>().begin()),
|
||||
decltype(std::declval<T>().end()),
|
||||
decltype(std::declval<T>().size())
|
||||
>, void>> : public std::true_type {
|
||||
};
|
||||
decltype(std::declval<T>().size())>,
|
||||
void>> : public std::true_type {};
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
static constexpr bool is_container_v = is_container<T>::value;
|
||||
|
||||
template <typename T>
|
||||
@ -75,50 +74,50 @@ using enable_if_container = std::enable_if_t<is_container_v<T>, T>;
|
||||
|
||||
template <typename T>
|
||||
using enable_if_not_container = std::enable_if_t<!is_container_v<T>, T>;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
class Argument {
|
||||
friend class ArgumentParser;
|
||||
|
||||
public:
|
||||
Argument() = default;
|
||||
|
||||
template <typename ...Args>
|
||||
template <typename... Args>
|
||||
explicit Argument(Args... args)
|
||||
: mNames({std::move(args)...})
|
||||
, mIsOptional((is_optional(args) || ...))
|
||||
{
|
||||
std::sort(mNames.begin(), mNames.end(), [](const auto& lhs, const auto& rhs) {
|
||||
: mNames({std::move(args)...}), mIsOptional((is_optional(args) || ...)) {
|
||||
std::sort(
|
||||
mNames.begin(), mNames.end(), [](const auto &lhs, const auto &rhs) {
|
||||
return lhs.size() == rhs.size() ? lhs < rhs : lhs.size() < rhs.size();
|
||||
});
|
||||
}
|
||||
|
||||
Argument& help(std::string aHelp) {
|
||||
Argument &help(std::string aHelp) {
|
||||
mHelp = std::move(aHelp);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Argument& default_value(std::any aDefaultValue) {
|
||||
Argument &default_value(std::any aDefaultValue) {
|
||||
mDefaultValue = std::move(aDefaultValue);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Argument& required() {
|
||||
Argument &required() {
|
||||
mIsRequired = true;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Argument& implicit_value(std::any aImplicitValue) {
|
||||
Argument &implicit_value(std::any aImplicitValue) {
|
||||
mImplicitValue = std::move(aImplicitValue);
|
||||
mNumArgs = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Argument& action(std::function<std::any(const std::string&)> aAction) {
|
||||
Argument &action(std::function<std::any(const std::string &)> aAction) {
|
||||
mAction = std::move(aAction);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Argument& nargs(size_t aNumArgs) {
|
||||
Argument &nargs(size_t aNumArgs) {
|
||||
mNumArgs = aNumArgs;
|
||||
return *this;
|
||||
}
|
||||
@ -133,19 +132,16 @@ public:
|
||||
if (mNumArgs == 0) {
|
||||
mValues.emplace_back(mImplicitValue);
|
||||
return start;
|
||||
}
|
||||
else if (mNumArgs <= static_cast<size_t>(std::distance(start, end))) {
|
||||
} else if (mNumArgs <= static_cast<size_t>(std::distance(start, end))) {
|
||||
end = std::next(start, mNumArgs);
|
||||
if (std::any_of(start, end, Argument::is_optional)) {
|
||||
throw std::runtime_error("optional argument in parameter sequence");
|
||||
}
|
||||
std::transform(start, end, std::back_inserter(mValues), mAction);
|
||||
return end;
|
||||
}
|
||||
else if (mDefaultValue.has_value()) {
|
||||
} else if (mDefaultValue.has_value()) {
|
||||
return start;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
throw std::runtime_error("Too few arguments");
|
||||
}
|
||||
}
|
||||
@ -157,11 +153,10 @@ public:
|
||||
if (mIsOptional) {
|
||||
if (mIsUsed && mValues.size() != mNumArgs && !mDefaultValue.has_value()) {
|
||||
std::stringstream stream;
|
||||
stream << "error: " << mUsedName << ": expected " << mNumArgs << " argument(s). "
|
||||
<< mValues.size() << " provided.";
|
||||
stream << "error: " << mUsedName << ": expected " << mNumArgs
|
||||
<< " argument(s). " << mValues.size() << " provided.";
|
||||
throw std::runtime_error(stream.str());
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
// TODO: check if an implicit value was programmed for this argument
|
||||
if (!mIsUsed && !mDefaultValue.has_value() && mIsRequired) {
|
||||
std::stringstream stream;
|
||||
@ -174,26 +169,29 @@ public:
|
||||
throw std::runtime_error(stream.str());
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
if (mValues.size() != mNumArgs && !mDefaultValue.has_value()) {
|
||||
std::stringstream stream;
|
||||
stream << "error: " << mUsedName << ": expected " << mNumArgs << " argument(s). "
|
||||
<< mValues.size() << " provided.";
|
||||
stream << "error: " << mUsedName << ": expected " << mNumArgs
|
||||
<< " argument(s). " << mValues.size() << " provided.";
|
||||
throw std::runtime_error(stream.str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
size_t get_arguments_length() const {
|
||||
return std::accumulate(std::begin(mNames), std::end(mNames), size_t(0), [](const auto& sum, const auto& s) {
|
||||
return sum + s.size() + 1; // +1 for space between names
|
||||
return std::accumulate(std::begin(mNames), std::end(mNames), size_t(0),
|
||||
[](const auto &sum, const auto &s) {
|
||||
return sum + s.size() +
|
||||
1; // +1 for space between names
|
||||
});
|
||||
}
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& stream, const Argument& argument) {
|
||||
friend std::ostream &operator<<(std::ostream &stream,
|
||||
const Argument &argument) {
|
||||
std::stringstream nameStream;
|
||||
std::copy(std::begin(argument.mNames), std::end(argument.mNames), std::ostream_iterator<std::string>(nameStream, " "));
|
||||
std::copy(std::begin(argument.mNames), std::end(argument.mNames),
|
||||
std::ostream_iterator<std::string>(nameStream, " "));
|
||||
stream << nameStream.str() << "\t" << argument.mHelp;
|
||||
if (argument.mIsRequired)
|
||||
stream << "[Required]";
|
||||
@ -201,9 +199,7 @@ public:
|
||||
return stream;
|
||||
}
|
||||
|
||||
|
||||
template <typename T>
|
||||
bool operator!=(const T& aRhs) const {
|
||||
template <typename T> bool operator!=(const T &aRhs) const {
|
||||
return !(*this == aRhs);
|
||||
}
|
||||
|
||||
@ -212,8 +208,7 @@ public:
|
||||
* @throws std::logic_error in case of incompatible types
|
||||
*/
|
||||
template <typename T>
|
||||
std::enable_if_t <!is_container_v<T>, bool>
|
||||
operator==(const T& aRhs) const {
|
||||
std::enable_if_t<!is_container_v<T>, bool> operator==(const T &aRhs) const {
|
||||
return get<T>() == aRhs;
|
||||
}
|
||||
|
||||
@ -222,31 +217,30 @@ public:
|
||||
* @throws std::logic_error in case of incompatible types
|
||||
*/
|
||||
template <typename T>
|
||||
std::enable_if_t <is_container_v<T>, bool>
|
||||
operator==(const T& aRhs) const {
|
||||
std::enable_if_t<is_container_v<T>, bool> operator==(const T &aRhs) const {
|
||||
using ValueType = typename T::value_type;
|
||||
auto tLhs = get<T>();
|
||||
if (tLhs.size() != aRhs.size())
|
||||
return false;
|
||||
else {
|
||||
return std::equal(std::begin(tLhs), std::end(tLhs), std::begin(aRhs), [](const auto& lhs, const auto& rhs) {
|
||||
return std::any_cast<const ValueType&>(lhs) == rhs;
|
||||
return std::equal(std::begin(tLhs), std::end(tLhs), std::begin(aRhs),
|
||||
[](const auto &lhs, const auto &rhs) {
|
||||
return std::any_cast<const ValueType &>(lhs) == rhs;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
static bool is_integer(const std::string& aValue) {
|
||||
if(aValue.empty() ||
|
||||
private:
|
||||
static bool is_integer(const std::string &aValue) {
|
||||
if (aValue.empty() ||
|
||||
((!isdigit(aValue[0])) && (aValue[0] != '-') && (aValue[0] != '+')))
|
||||
return false;
|
||||
char * tPtr;
|
||||
char *tPtr;
|
||||
strtol(aValue.c_str(), &tPtr, 10);
|
||||
return (*tPtr == 0);
|
||||
}
|
||||
|
||||
static bool is_float(const std::string& aValue) {
|
||||
static bool is_float(const std::string &aValue) {
|
||||
std::istringstream tStream(aValue);
|
||||
float tFloat;
|
||||
// noskipws considers leading whitespace invalid
|
||||
@ -257,12 +251,12 @@ public:
|
||||
}
|
||||
|
||||
// If an argument starts with "-" or "--", then it's optional
|
||||
static bool is_optional(const std::string& aName) {
|
||||
return (!aName.empty() && aName[0] == '-' &&
|
||||
!is_integer(aName) && !is_float(aName));
|
||||
static bool is_optional(const std::string &aName) {
|
||||
return (!aName.empty() && aName[0] == '-' && !is_integer(aName) &&
|
||||
!is_float(aName));
|
||||
}
|
||||
|
||||
static bool is_positional(const std::string& aName) {
|
||||
static bool is_positional(const std::string &aName) {
|
||||
return !is_optional(aName);
|
||||
}
|
||||
|
||||
@ -270,9 +264,7 @@ public:
|
||||
* Getter for template non-container types
|
||||
* @throws std::logic_error in case of incompatible types
|
||||
*/
|
||||
template <typename T>
|
||||
enable_if_not_container<T>
|
||||
get() const {
|
||||
template <typename T> enable_if_not_container<T> get() const {
|
||||
if (!mValues.empty()) {
|
||||
return std::any_cast<T>(mValues.front());
|
||||
}
|
||||
@ -286,20 +278,20 @@ public:
|
||||
* Getter for container types
|
||||
* @throws std::logic_error in case of incompatible types
|
||||
*/
|
||||
template <typename CONTAINER>
|
||||
enable_if_container<CONTAINER>
|
||||
get() const {
|
||||
template <typename CONTAINER> enable_if_container<CONTAINER> get() const {
|
||||
using ValueType = typename CONTAINER::value_type;
|
||||
CONTAINER tResult;
|
||||
if (!mValues.empty()) {
|
||||
std::transform(std::begin(mValues), std::end(mValues), std::back_inserter(tResult), [](const auto & value) {
|
||||
return std::any_cast<ValueType>(value);
|
||||
});
|
||||
std::transform(
|
||||
std::begin(mValues), std::end(mValues), std::back_inserter(tResult),
|
||||
[](const auto &value) { return std::any_cast<ValueType>(value); });
|
||||
return tResult;
|
||||
}
|
||||
if (mDefaultValue.has_value()) {
|
||||
const auto& tDefaultValues = std::any_cast<const CONTAINER&>(mDefaultValue);
|
||||
std::transform(std::begin(tDefaultValues), std::end(tDefaultValues), std::back_inserter(tResult), [](const auto & value) {
|
||||
const auto &tDefaultValues =
|
||||
std::any_cast<const CONTAINER &>(mDefaultValue);
|
||||
std::transform(std::begin(tDefaultValues), std::end(tDefaultValues),
|
||||
std::back_inserter(tResult), [](const auto &value) {
|
||||
return std::any_cast<ValueType>(value);
|
||||
});
|
||||
return tResult;
|
||||
@ -312,7 +304,8 @@ public:
|
||||
std::string mHelp;
|
||||
std::any mDefaultValue;
|
||||
std::any mImplicitValue;
|
||||
std::function<std::any(const std::string&)> mAction = [](const std::string& aValue) { return aValue; };
|
||||
std::function<std::any(const std::string &)> mAction =
|
||||
[](const std::string &aValue) { return aValue; };
|
||||
std::vector<std::any> mValues;
|
||||
std::vector<std::string> mRawValues;
|
||||
size_t mNumArgs = 1;
|
||||
@ -320,16 +313,15 @@ public:
|
||||
bool mIsRequired = false;
|
||||
bool mIsUsed = false; // relevant for optional arguments. True if used by user
|
||||
|
||||
public:
|
||||
public:
|
||||
static constexpr auto mHelpOption = "-h";
|
||||
static constexpr auto mHelpOptionLong = "--help";
|
||||
};
|
||||
|
||||
class ArgumentParser {
|
||||
public:
|
||||
explicit ArgumentParser(std::string aProgramName = {}) :
|
||||
mProgramName(std::move(aProgramName))
|
||||
{
|
||||
public:
|
||||
explicit ArgumentParser(std::string aProgramName = {})
|
||||
: mProgramName(std::move(aProgramName)) {
|
||||
add_argument(Argument::mHelpOption, Argument::mHelpOptionLong)
|
||||
.help("show this help message and exit")
|
||||
.nargs(0)
|
||||
@ -339,16 +331,16 @@ class ArgumentParser {
|
||||
|
||||
// Parameter packing
|
||||
// Call add_argument with variadic number of string arguments
|
||||
template<typename... Targs>
|
||||
Argument& add_argument(Targs... Fargs) {
|
||||
std::shared_ptr<Argument> tArgument = std::make_shared<Argument>(std::move(Fargs)...);
|
||||
template <typename... Targs> Argument &add_argument(Targs... Fargs) {
|
||||
std::shared_ptr<Argument> tArgument =
|
||||
std::make_shared<Argument>(std::move(Fargs)...);
|
||||
|
||||
if (tArgument->mIsOptional)
|
||||
mOptionalArguments.emplace_back(tArgument);
|
||||
else
|
||||
mPositionalArguments.emplace_back(tArgument);
|
||||
|
||||
for (const auto& mName : tArgument->mNames) {
|
||||
for (const auto &mName : tArgument->mNames) {
|
||||
mArgumentMap.insert_or_assign(mName, tArgument);
|
||||
}
|
||||
return *tArgument;
|
||||
@ -356,22 +348,25 @@ class ArgumentParser {
|
||||
|
||||
// Parameter packed add_parents method
|
||||
// Accepts a variadic number of ArgumentParser objects
|
||||
template<typename... Targs>
|
||||
void add_parents(Targs... Fargs) {
|
||||
template <typename... Targs> void add_parents(Targs... Fargs) {
|
||||
const auto tNewParentParsers = {Fargs...};
|
||||
for (const auto& tParentParser : tNewParentParsers) {
|
||||
const auto& tPositionalArguments = tParentParser.mPositionalArguments;
|
||||
std::copy(std::begin(tPositionalArguments), std::end(tPositionalArguments), std::back_inserter(mPositionalArguments));
|
||||
for (const auto &tParentParser : tNewParentParsers) {
|
||||
const auto &tPositionalArguments = tParentParser.mPositionalArguments;
|
||||
std::copy(std::begin(tPositionalArguments),
|
||||
std::end(tPositionalArguments),
|
||||
std::back_inserter(mPositionalArguments));
|
||||
|
||||
const auto& tOptionalArguments = tParentParser.mOptionalArguments;
|
||||
std::copy(std::begin(tOptionalArguments), std::end(tOptionalArguments), std::back_inserter(mOptionalArguments));
|
||||
const auto &tOptionalArguments = tParentParser.mOptionalArguments;
|
||||
std::copy(std::begin(tOptionalArguments), std::end(tOptionalArguments),
|
||||
std::back_inserter(mOptionalArguments));
|
||||
|
||||
const auto& tArgumentMap = tParentParser.mArgumentMap;
|
||||
for (const auto&[tKey, tValue] : tArgumentMap) {
|
||||
const auto &tArgumentMap = tParentParser.mArgumentMap;
|
||||
for (const auto &[tKey, tValue] : tArgumentMap) {
|
||||
mArgumentMap.insert_or_assign(tKey, tValue);
|
||||
}
|
||||
}
|
||||
std::move(std::begin(tNewParentParsers), std::end(tNewParentParsers), std::back_inserter(mParentParsers));
|
||||
std::move(std::begin(tNewParentParsers), std::end(tNewParentParsers),
|
||||
std::back_inserter(mParentParsers));
|
||||
}
|
||||
|
||||
/* Call parse_args_internal - which does all the work
|
||||
@ -379,15 +374,16 @@ class ArgumentParser {
|
||||
* This variant is used mainly for testing
|
||||
* @throws std::runtime_error in case of any invalid argument
|
||||
*/
|
||||
void parse_args(const std::vector<std::string>& aArguments) {
|
||||
void parse_args(const std::vector<std::string> &aArguments) {
|
||||
parse_args_internal(aArguments);
|
||||
parse_args_validate();
|
||||
}
|
||||
|
||||
/* Main entry point for parsing command-line arguments using this ArgumentParser
|
||||
/* Main entry point for parsing command-line arguments using this
|
||||
* ArgumentParser
|
||||
* @throws std::runtime_error in case of any invalid argument
|
||||
*/
|
||||
void parse_args(int argc, const char * const argv[]) {
|
||||
void parse_args(int argc, const char *const argv[]) {
|
||||
std::vector<std::string> arguments;
|
||||
std::copy(argv, argv + argc, std::back_inserter(arguments));
|
||||
parse_args(arguments);
|
||||
@ -397,8 +393,7 @@ class ArgumentParser {
|
||||
* @throws std::logic_error in case of an invalid argument name
|
||||
* @throws std::logic_error in case of incompatible types
|
||||
*/
|
||||
template <typename T = std::string>
|
||||
T get(const std::string& aArgumentName) {
|
||||
template <typename T = std::string> T get(const std::string &aArgumentName) {
|
||||
auto tIterator = mArgumentMap.find(aArgumentName);
|
||||
if (tIterator != mArgumentMap.end()) {
|
||||
return tIterator->second->get<T>();
|
||||
@ -410,7 +405,7 @@ class ArgumentParser {
|
||||
* Used in conjuction with Argument.operator== e.g., parser["foo"] == true
|
||||
* @throws std::logic_error in case of an invalid argument name
|
||||
*/
|
||||
Argument& operator[](const std::string& aArgumentName) {
|
||||
Argument &operator[](const std::string &aArgumentName) {
|
||||
auto tIterator = mArgumentMap.find(aArgumentName);
|
||||
if (tIterator != mArgumentMap.end()) {
|
||||
return *(tIterator->second);
|
||||
@ -427,7 +422,7 @@ class ArgumentParser {
|
||||
stream << "Usage: " << mProgramName << " [options] ";
|
||||
size_t tLongestArgumentLength = get_length_of_longest_argument();
|
||||
|
||||
for (const auto& argument : mPositionalArguments) {
|
||||
for (const auto &argument : mPositionalArguments) {
|
||||
stream << argument->mNames.front() << " ";
|
||||
}
|
||||
stream << "\n\n";
|
||||
@ -435,15 +430,16 @@ class ArgumentParser {
|
||||
if (!mPositionalArguments.empty())
|
||||
stream << "Positional arguments:\n";
|
||||
|
||||
for (const auto& mPositionalArgument : mPositionalArguments) {
|
||||
for (const auto &mPositionalArgument : mPositionalArguments) {
|
||||
stream.width(tLongestArgumentLength);
|
||||
stream << *mPositionalArgument;
|
||||
}
|
||||
|
||||
if (!mOptionalArguments.empty())
|
||||
stream << (mPositionalArguments.empty() ? "" : "\n") << "Optional arguments:\n";
|
||||
stream << (mPositionalArguments.empty() ? "" : "\n")
|
||||
<< "Optional arguments:\n";
|
||||
|
||||
for (const auto & mOptionalArgument : mOptionalArguments) {
|
||||
for (const auto &mOptionalArgument : mOptionalArguments) {
|
||||
stream.width(tLongestArgumentLength);
|
||||
stream << *mOptionalArgument;
|
||||
}
|
||||
@ -452,49 +448,48 @@ class ArgumentParser {
|
||||
return stream.str();
|
||||
}
|
||||
|
||||
private:
|
||||
private:
|
||||
/*
|
||||
* @throws std::runtime_error in case of any invalid argument
|
||||
*/
|
||||
void parse_args_internal(const std::vector<std::string>& aArguments) {
|
||||
void parse_args_internal(const std::vector<std::string> &aArguments) {
|
||||
if (mProgramName.empty() && !aArguments.empty()) {
|
||||
mProgramName = aArguments.front();
|
||||
}
|
||||
auto end = std::end(aArguments);
|
||||
auto positionalArgumentIt = std::begin(mPositionalArguments);
|
||||
for (auto it = std::next(std::begin(aArguments)); it != end;) {
|
||||
const auto& tCurrentArgument = *it;
|
||||
if (tCurrentArgument == Argument::mHelpOption || tCurrentArgument == Argument::mHelpOptionLong) {
|
||||
const auto &tCurrentArgument = *it;
|
||||
if (tCurrentArgument == Argument::mHelpOption ||
|
||||
tCurrentArgument == Argument::mHelpOptionLong) {
|
||||
throw std::runtime_error("help called");
|
||||
}
|
||||
if (Argument::is_positional(tCurrentArgument)) {
|
||||
if (positionalArgumentIt == std::end(mPositionalArguments)) {
|
||||
throw std::runtime_error("Maximum number of positional arguments exceeded");
|
||||
throw std::runtime_error(
|
||||
"Maximum number of positional arguments exceeded");
|
||||
}
|
||||
auto tArgument = *(positionalArgumentIt++);
|
||||
it = tArgument->consume(it, end);
|
||||
}
|
||||
else if (auto tIterator = mArgumentMap.find(tCurrentArgument); tIterator != mArgumentMap.end()) {
|
||||
} else if (auto tIterator = mArgumentMap.find(tCurrentArgument);
|
||||
tIterator != mArgumentMap.end()) {
|
||||
auto tArgument = tIterator->second;
|
||||
it = tArgument->consume(std::next(it), end, tCurrentArgument);
|
||||
}
|
||||
else if (const auto& tCompoundArgument = tCurrentArgument;
|
||||
tCompoundArgument.size() > 1 &&
|
||||
tCompoundArgument[0] == '-' &&
|
||||
} else if (const auto &tCompoundArgument = tCurrentArgument;
|
||||
tCompoundArgument.size() > 1 && tCompoundArgument[0] == '-' &&
|
||||
tCompoundArgument[1] != '-') {
|
||||
++it;
|
||||
for (size_t j = 1; j < tCompoundArgument.size(); j++) {
|
||||
auto tCurrentArgument = std::string{'-', tCompoundArgument[j]};
|
||||
if (auto tIterator = mArgumentMap.find(tCurrentArgument); tIterator != mArgumentMap.end()) {
|
||||
if (auto tIterator = mArgumentMap.find(tCurrentArgument);
|
||||
tIterator != mArgumentMap.end()) {
|
||||
auto tArgument = tIterator->second;
|
||||
it = tArgument->consume(it, end, tCurrentArgument);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
throw std::runtime_error("Unknown argument");
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
throw std::runtime_error("Unknown argument");
|
||||
}
|
||||
}
|
||||
@ -506,8 +501,8 @@ class ArgumentParser {
|
||||
void parse_args_validate() {
|
||||
// Check if all arguments are parsed
|
||||
std::for_each(std::begin(mArgumentMap), std::end(mArgumentMap),
|
||||
[](const auto& argPair) {
|
||||
const auto& tArgument = argPair.second;
|
||||
[](const auto &argPair) {
|
||||
const auto &tArgument = argPair.second;
|
||||
tArgument->validate();
|
||||
});
|
||||
}
|
||||
@ -518,8 +513,8 @@ class ArgumentParser {
|
||||
return 0;
|
||||
std::vector<size_t> argumentLengths(mArgumentMap.size());
|
||||
std::transform(std::begin(mArgumentMap), std::end(mArgumentMap),
|
||||
std::begin(argumentLengths), [](const auto& argPair) {
|
||||
const auto& tArgument = argPair.second;
|
||||
std::begin(argumentLengths), [](const auto &argPair) {
|
||||
const auto &tArgument = argPair.second;
|
||||
return tArgument->get_arguments_length();
|
||||
});
|
||||
return *std::max_element(std::begin(argumentLengths),
|
||||
@ -534,12 +529,12 @@ class ArgumentParser {
|
||||
};
|
||||
|
||||
#define PARSE_ARGS(parser, argc, argv) \
|
||||
try { \
|
||||
try { \
|
||||
parser.parse_args(argc, argv); \
|
||||
} catch (const std::runtime_error& err) { \
|
||||
} catch (const std::runtime_error &err) { \
|
||||
std::cout << err.what() << std::endl; \
|
||||
parser.print_help(); \
|
||||
exit(0); \
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace argparse
|
||||
|
||||
Loading…
Reference in New Issue
Block a user