KeqingMoe/argparse
1
0
Fork 0
mirror of https://github.com/KeqingMoe/argparse.git synced 2025-07-03 22:54: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 { struct Argument {
std::vector<std::string> mNames; std::vector<std::string> mNames;
std::string mHelp; std::string mHelp;
std::function<std::any()> mDefaultValue; std::any mDefaultValue;
std::function<std::any(const std::string&)> mAction; std::function<std::any(const std::string&)> mAction;
std::vector<std::any> mValues; std::vector<std::any> mValues;
std::vector<std::string> mRawValues; std::vector<std::string> mRawValues;
@ -44,7 +44,6 @@ struct Argument {
Argument() : Argument() :
mNames({}), mNames({}),
mHelp(""), mHelp(""),
mDefaultValue(nullptr),
mAction([](const std::string& aValue) { return aValue; }), mAction([](const std::string& aValue) { return aValue; }),
mValues({}), mValues({}),
mRawValues({}), mRawValues({}),
@ -55,7 +54,7 @@ struct Argument {
return *this; return *this;
} }
Argument& default_value(std::function<std::any()> aDefaultValue) { Argument& default_value(std::any aDefaultValue) {
mDefaultValue = aDefaultValue; mDefaultValue = aDefaultValue;
return *this; return *this;
} }
@ -73,8 +72,8 @@ struct Argument {
template <typename T> template <typename T>
T get() { T get() {
if (mValues.size() == 0) { if (mValues.size() == 0) {
if (mDefaultValue != nullptr) { if (mDefaultValue.has_value()) {
return std::any_cast<T>(mDefaultValue()); return std::any_cast<T>(mDefaultValue);
} }
else else
return T(); return T();
@ -83,8 +82,8 @@ struct Argument {
if (mRawValues.size() > 0) if (mRawValues.size() > 0)
return std::any_cast<T>(mValues[0]); return std::any_cast<T>(mValues[0]);
else { else {
if (mDefaultValue != nullptr) if (mDefaultValue.has_value())
return std::any_cast<T>(mDefaultValue()); return std::any_cast<T>(mDefaultValue);
else else
return T(); return T();
} }
@ -95,8 +94,8 @@ struct Argument {
T get_vector() { T get_vector() {
T tResult; T tResult;
if (mValues.size() == 0) { if (mValues.size() == 0) {
if (mDefaultValue != nullptr) { if (mDefaultValue.has_value()) {
std::any tDefaultValueLambdaResult = mDefaultValue(); std::any tDefaultValueLambdaResult = mDefaultValue;
T tDefaultValues = std::any_cast<T>(tDefaultValueLambdaResult); T tDefaultValues = std::any_cast<T>(tDefaultValueLambdaResult);
for (size_t i = 0; i < tDefaultValues.size(); i++) { for (size_t i = 0; i < tDefaultValues.size(); i++) {
tResult.push_back(std::any_cast<typename T::value_type>(tDefaultValues[i])); tResult.push_back(std::any_cast<typename T::value_type>(tDefaultValues[i]));
@ -114,8 +113,8 @@ struct Argument {
return tResult; return tResult;
} }
else { else {
if (mDefaultValue != nullptr) { if (mDefaultValue.has_value()) {
std::any tDefaultValueLambdaResult = mDefaultValue(); std::any tDefaultValueLambdaResult = mDefaultValue;
std::vector<T> tDefaultValues = std::any_cast<std::vector<T>>(tDefaultValueLambdaResult); std::vector<T> tDefaultValues = std::any_cast<std::vector<T>>(tDefaultValueLambdaResult);
for (size_t i = 0; i < tDefaultValues.size(); i++) { for (size_t i = 0; i < tDefaultValues.size(); i++) {
tResult.push_back(std::any_cast<typename T::value_type>(tDefaultValues[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>(); std::shared_ptr<Argument> tArgument = std::make_shared<Argument>();
tArgument->mNames.push_back(value); tArgument->mNames.push_back(value);
add_argument_internal(tArgument, Fargs...); add_argument_internal(tArgument, Fargs...);
mArguments.push_back(tArgument); mPositionalArguments.push_back(tArgument); // TODO: check if argument is positional before push_back
for (auto& mName : tArgument->mNames) { for (auto& mName : tArgument->mNames) {
upsert(mArgumentMap, mName, tArgument); upsert(mArgumentMap, mName, tArgument);
} }
return *tArgument; return *tArgument;
@ -169,8 +168,8 @@ class ArgumentParser {
if (tArgument->mAction != nullptr) if (tArgument->mAction != nullptr)
tArgument->mValues.push_back(tArgument->mAction(argv[i])); tArgument->mValues.push_back(tArgument->mAction(argv[i]));
else { else {
if (tArgument->mDefaultValue != nullptr) if (tArgument->mDefaultValue.has_value())
tArgument->mValues.push_back(tArgument->mDefaultValue()); tArgument->mValues.push_back(tArgument->mDefaultValue);
else else
tArgument->mValues.push_back(std::string(argv[i])); 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> template <typename T = std::string>
typename std::enable_if<is_specialization<T, std::vector>::value == false, T>::type typename std::enable_if<is_specialization<T, std::vector>::value == false, T>::type
get(const char * aArgumentName) { get(const char * aArgumentName) {
@ -227,7 +217,7 @@ class ArgumentParser {
} }
std::string mProgramName; 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; 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]") { TEST_CASE("Parse a string argument with default value", "[parse_args]") {
argparse::ArgumentParser program("test"); argparse::ArgumentParser program("test");
program.add_argument("--config") program.add_argument("--config")
.default_value([]() { return std::string("foo.yml"); }); .default_value(std::string("foo.yml"));
program.parse_args({ "test", "--config" }); program.parse_args({ "test", "--config" });
auto arguments = program.get_arguments(); auto arguments = program.get_arguments();
REQUIRE(arguments.size() == 1); 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]") { TEST_CASE("Parse an int argument with default value", "[parse_args]") {
argparse::ArgumentParser program("test"); argparse::ArgumentParser program("test");
program.add_argument("--count") program.add_argument("--count")
.default_value([]() { return 2; }) .default_value(2)
.action([](const std::string& value) { return std::stoi(value); }); .action([](const std::string& value) { return std::stoi(value); });
program.parse_args({ "test", "--count" }); program.parse_args({ "test", "--count" });
auto arguments = program.get_arguments(); 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]") { TEST_CASE("Parse a float argument with default value", "[parse_args]") {
argparse::ArgumentParser program("test"); argparse::ArgumentParser program("test");
program.add_argument("--ratio") program.add_argument("--ratio")
.default_value([]() { return 3.14f; }) .default_value(3.14f)
.action([](const std::string& value) { return std::stof(value); }); .action([](const std::string& value) { return std::stof(value); });
program.parse_args({ "test", "--ratio" }); program.parse_args({ "test", "--ratio" });
auto arguments = program.get_arguments(); 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]") { TEST_CASE("Parse a double argument with default value", "[parse_args]") {
argparse::ArgumentParser program("test"); argparse::ArgumentParser program("test");
program.add_argument("--ratio") program.add_argument("--ratio")
.default_value([]() { return 3.14; }) .default_value(3.14)
.action([](const std::string& value) { return std::stod(value); }); .action([](const std::string& value) { return std::stod(value); });
program.parse_args({ "test", "--ratio" }); program.parse_args({ "test", "--ratio" });
auto arguments = program.get_arguments(); auto arguments = program.get_arguments();