KeqingMoe/argparse
1
0
Fork 0
mirror of https://github.com/KeqingMoe/argparse.git synced 2025-07-04 07:04:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Default value is now just an std::any instead of a lambda function

Browse Source
This commit is contained in:
Pranav Srinivas Kumar 2019-03-30 19:42:05 -04:00
parent 0ceeeb353f
commit 2e1683d7cb
2 changed files with 19 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
src/argparse.hpp
View File

@ -35,7 +35,7 @@ bool upsert(std::map<KeyType, ElementType>& aMap, KeyType const& aKey, ElementTy
struct Argument {
std::vector<std::string> mNames;
std::string mHelp;
std::function<std::any()> mDefaultValue;
std::any mDefaultValue;
std::function<std::any(const std::string&)> mAction;
std::vector<std::any> mValues;
std::vector<std::string> mRawValues;
@ -44,7 +44,6 @@ struct Argument {
Argument() :
mNames({}),
mHelp(""),
mDefaultValue(nullptr),
mAction([](const std::string& aValue) { return aValue; }),
mValues({}),
mRawValues({}),
@ -55,7 +54,7 @@ struct Argument {
return *this;
}
Argument& default_value(std::function<std::any()> aDefaultValue) {
Argument& default_value(std::any aDefaultValue) {
mDefaultValue = aDefaultValue;
return *this;
}
@ -73,8 +72,8 @@ struct Argument {
template <typename T>
T get() {
if (mValues.size() == 0) {
if (mDefaultValue != nullptr) {
return std::any_cast<T>(mDefaultValue());
if (mDefaultValue.has_value()) {
return std::any_cast<T>(mDefaultValue);
}
else
return T();
@ -83,8 +82,8 @@ struct Argument {
if (mRawValues.size() > 0)
return std::any_cast<T>(mValues[0]);
else {
if (mDefaultValue != nullptr)
return std::any_cast<T>(mDefaultValue());
if (mDefaultValue.has_value())
return std::any_cast<T>(mDefaultValue);
else
return T();
}
@ -95,8 +94,8 @@ struct Argument {
T get_vector() {
T tResult;
if (mValues.size() == 0) {
if (mDefaultValue != nullptr) {
std::any tDefaultValueLambdaResult = mDefaultValue();
if (mDefaultValue.has_value()) {
std::any tDefaultValueLambdaResult = mDefaultValue;
T tDefaultValues = std::any_cast<T>(tDefaultValueLambdaResult);
for (size_t i = 0; i < tDefaultValues.size(); i++) {
tResult.push_back(std::any_cast<typename T::value_type>(tDefaultValues[i]));
@ -114,8 +113,8 @@ struct Argument {
return tResult;
}
else {
if (mDefaultValue != nullptr) {
std::any tDefaultValueLambdaResult = mDefaultValue();
if (mDefaultValue.has_value()) {
std::any tDefaultValueLambdaResult = mDefaultValue;
std::vector<T> tDefaultValues = std::any_cast<std::vector<T>>(tDefaultValueLambdaResult);
for (size_t i = 0; i < tDefaultValues.size(); i++) {
tResult.push_back(std::any_cast<typename T::value_type>(tDefaultValues[i]));
@ -140,8 +139,8 @@ class ArgumentParser {
std::shared_ptr<Argument> tArgument = std::make_shared<Argument>();
tArgument->mNames.push_back(value);
add_argument_internal(tArgument, Fargs...);
mArguments.push_back(tArgument);
for (auto& mName : tArgument->mNames) {
mPositionalArguments.push_back(tArgument); // TODO: check if argument is positional before push_back
for (auto& mName : tArgument->mNames) {
upsert(mArgumentMap, mName, tArgument);
}
return *tArgument;
@ -169,8 +168,8 @@ class ArgumentParser {
if (tArgument->mAction != nullptr)
tArgument->mValues.push_back(tArgument->mAction(argv[i]));
else {
if (tArgument->mDefaultValue != nullptr)
tArgument->mValues.push_back(tArgument->mDefaultValue());
if (tArgument->mDefaultValue.has_value())
tArgument->mValues.push_back(tArgument->mDefaultValue);
else
tArgument->mValues.push_back(std::string(argv[i]));
}
@ -181,15 +180,6 @@ class ArgumentParser {
}
}
Argument& operator[](const char * key) {
for (auto& tArgument : mArguments) {
auto tIndex = std::find(tArgument->mNames.begin(), tArgument->mNames.end(), key);
if (tIndex != tArgument->mNames.end()) {
return *tArgument;
}
}
}
template <typename T = std::string>
typename std::enable_if<is_specialization<T, std::vector>::value == false, T>::type
get(const char * aArgumentName) {
@ -227,7 +217,7 @@ class ArgumentParser {
}
std::string mProgramName;
std::vector<std::shared_ptr<Argument>> mArguments;
std::vector<std::shared_ptr<Argument>> mPositionalArguments;
std::map<std::string, std::shared_ptr<Argument>> mArgumentMap;
};

8
tests/test_parse_args.hpp
View File

@ -14,7 +14,7 @@ TEST_CASE("Parse a string argument with value", "[parse_args]") {
TEST_CASE("Parse a string argument with default value", "[parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--config")
.default_value([]() { return std::string("foo.yml"); });
.default_value(std::string("foo.yml"));
program.parse_args({ "test", "--config" });
auto arguments = program.get_arguments();
REQUIRE(arguments.size() == 1);
@ -34,7 +34,7 @@ TEST_CASE("Parse an int argument with value", "[parse_args]") {
TEST_CASE("Parse an int argument with default value", "[parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--count")
.default_value([]() { return 2; })
.default_value(2)
.action([](const std::string& value) { return std::stoi(value); });
program.parse_args({ "test", "--count" });
auto arguments = program.get_arguments();
@ -55,7 +55,7 @@ TEST_CASE("Parse a float argument with value", "[parse_args]") {
TEST_CASE("Parse a float argument with default value", "[parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--ratio")
.default_value([]() { return 3.14f; })
.default_value(3.14f)
.action([](const std::string& value) { return std::stof(value); });
program.parse_args({ "test", "--ratio" });
auto arguments = program.get_arguments();
@ -76,7 +76,7 @@ TEST_CASE("Parse a double argument with value", "[parse_args]") {
TEST_CASE("Parse a double argument with default value", "[parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--ratio")
.default_value([]() { return 3.14; })
.default_value(3.14)
.action([](const std::string& value) { return std::stod(value); });
program.parse_args({ "test", "--ratio" });
auto arguments = program.get_arguments();