From 5e0abb3e0d0ad513cc6e90ac2386f04a749be185 Mon Sep 17 00:00:00 2001 From: "Taylor C. Richberger" Date: Tue, 10 May 2016 09:02:00 -0600 Subject: switch everything to args::get --- README.md | 26 +++++++-------- args.hxx | 108 ++++++++++++++++++++++++++++++++++++++++++++++++-------------- test.cxx | 68 +++++++++++++++++++++++++++------------ 3 files changed, 144 insertions(+), 58 deletions(-) diff --git a/README.md b/README.md index da4b9d7..1246367 100644 --- a/README.md +++ b/README.md @@ -176,9 +176,9 @@ int main() args::ArgFlagList characters(parser, "characters", "The character flag", args::Matcher{'c', "char"}); args::PosArgList numbers(parser, "numbers", "The numbers position list"); parser.ParseArgs(arguments); - const int i = integer.value; - const std::vector c(characters.values); - const std::vector n(numbers.values); + const int i = args::get(integer); + const std::vector c(args::get(characters)); + const std::vector n(args::get(numbers)); assert(i == 7); assert(c[0] == 'a'); assert(c[1] == 'b'); @@ -432,10 +432,10 @@ int main(int argc, char **argv) std::cerr << parser; return 1; } - if (integer) { std::cout << "i: " << integer.value << std::endl; } - if (characters) { for (const auto ch: characters.values) { std::cout << "c: " << ch << std::endl; } } - if (foo) { std::cout << "f: " << foo.value << std::endl; } - if (numbers) { for (const auto nm: numbers.values) { std::cout << "n: " << nm << std::endl; } } + if (integer) { std::cout << "i: " << args::get(integer) << std::endl; } + if (characters) { for (const auto ch: args::get(characters)) { std::cout << "c: " << ch << std::endl; } } + if (foo) { std::cout << "f: " << args::get(foo) << std::endl; } + if (numbers) { for (const auto nm: args::get(numbers)) { std::cout << "n: " << nm << std::endl; } } return 0; } ``` @@ -528,11 +528,11 @@ int main(int argc, char **argv) } if (ints) { - std::cout << "ints found: " << std::get<0>(ints.value) << " and " << std::get<1>(ints.value) << std::endl; + std::cout << "ints found: " << std::get<0>(args::get(ints)) << " and " << std::get<1>(args::get(ints)) << std::endl; } if (doubles) { - std::cout << "doubles found: " << std::get<0>(doubles.value) << " and " << std::get<1>(doubles.value) << std::endl; + std::cout << "doubles found: " << std::get<0>(args::get(doubles)) << " and " << std::get<1>(args::get(doubles)) << std::endl; } return 0; } @@ -720,10 +720,10 @@ int main(int argc, char **argv) std::cerr << parser; return 1; } - std::cout << "bs = " << bs.value << std::endl; - std::cout << "skip = " << skip.value << std::endl; - if (input) { std::cout << "if = " << input.value << std::endl; } - if (output) { std::cout << "of = " << output.value << std::endl; } + std::cout << "bs = " << args::get(bs) << std::endl; + std::cout << "skip = " << args::get(skip) << std::endl; + if (input) { std::cout << "if = " << args::get(input) << std::endl; } + if (output) { std::cout << "of = " << args::get(output) << std::endl; } return 0; } ``` diff --git a/args.hxx b/args.hxx index 5aee038..22f1170 100644 --- a/args.hxx +++ b/args.hxx @@ -27,9 +27,18 @@ #include #include #include +#include namespace args { + /** Getter to grab the value reference + */ + template + auto get(Arg &arg) -> decltype(arg.Get()) + { + return arg.Get(); + } + /** (INTERNAL) Count UTF-8 glyphs * * This is not reliable, and will fail for combinatory glyphs, but it's @@ -613,6 +622,13 @@ namespace args return validator(*this); } + /** Get validation + */ + bool Get() const + { + return Matched(); + } + /** Get all the child descriptions for help generation */ std::vector> GetChildDescriptions(const std::string &shortPrefix, const std::string &longPrefix, const std::string &shortSeparator, const std::string &longSeparator, unsigned int indent = 0) const @@ -1199,6 +1215,13 @@ namespace args } virtual ~Flag() {} + + /** Get whether this was matched + */ + bool Get() const + { + return Matched(); + } }; /** Help flag class @@ -1229,17 +1252,25 @@ namespace args } return nullptr; } + + /** Get whether this was matched + */ + bool Get() const noexcept + { + return Matched(); + } }; /** A flag class that simply counts the number of times it's matched */ class Counter : public Flag { - public: - /** The public count variable. Can be changed at will, but probably shouldn't be. - */ + friend int get(Counter &); + + private: int count; + public: Counter(Group &group, const std::string &name, const std::string &help, Matcher &&matcher, const int startcount = 0): Flag(group, name, help, std::move(matcher)), count(startcount) {} virtual ~Counter() {} @@ -1263,6 +1294,13 @@ namespace args } return me; } + + /** Get the count + */ + int &Get() noexcept + { + return count; + } }; /** A default Reader function for argument classes @@ -1303,13 +1341,13 @@ namespace args template > class ArgFlag : public ArgFlagBase { - public: - /** The publicly accessible value member - * - * You can change this, but you probably shouldn't. - */ + friend T &get(ArgFlag &); + + private: T value; + public: + ArgFlag(Group &group, const std::string &name, const std::string &help, Matcher &&matcher, const T &defaultValue = T()): ArgFlagBase(name, help, std::move(matcher)), value(defaultValue) { group.Add(*this); @@ -1321,6 +1359,13 @@ namespace args { Reader(name, value, this->value); } + + /** Get the value + */ + T &Get() noexcept + { + return value; + } }; /** An argument-accepting flag class that pushes the found values into a list @@ -1335,13 +1380,12 @@ namespace args void (*Reader)(const std::string &, const std::string &, T&) = ArgReader> class ArgFlagList : public ArgFlagBase { - public: - /** The publicly accessible value member list - * - * You can change this, but you probably shouldn't. - */ + friend List &get(ArgFlagList &); + private: List values; + public: + ArgFlagList(Group &group, const std::string &name, const std::string &help, Matcher &&matcher, const List &defaultValues = List()): ArgFlagBase(name, help, std::move(matcher)), values(defaultValues) { group.Add(*this); @@ -1354,6 +1398,13 @@ namespace args values.emplace_back(); Reader(name, value, values.back()); } + + /** Get the values + */ + List &Get() noexcept + { + return values; + } }; /** A positional argument class @@ -1364,13 +1415,10 @@ namespace args template > class PosArg : public PosBase { - public: - /** The publicly accessible value member - * - * You can change this, but you probably shouldn't. - */ + friend T &get(PosArg &); + private: T value; - + public: PosArg(Group &group, const std::string &name, const std::string &help, const T &defaultValue = T()): PosBase(name, help), value(defaultValue) { group.Add(*this); @@ -1384,6 +1432,13 @@ namespace args ready = false; matched = true; } + + /** Get the value + */ + T &Get() noexcept + { + return value; + } }; /** A positional argument class that pushes the found values into a list @@ -1398,13 +1453,11 @@ namespace args void (*Reader)(const std::string &, const std::string &, T&) = ArgReader> class PosArgList : public PosBase { - public: - /** The publicly accessible value member list - * - * You can change this, but you probably shouldn't. - */ + friend List &get(PosArgList &); + private: List values; + public: PosArgList(Group &group, const std::string &name, const std::string &help, const List &defaultValues = List()): PosBase(name, help), values(defaultValues) { group.Add(*this); @@ -1423,5 +1476,12 @@ namespace args { return name + std::string("..."); } + + /** Get the values + */ + List &Get() noexcept + { + return values; + } }; } diff --git a/test.cxx b/test.cxx index 4816691..c5ab1b3 100644 --- a/test.cxx +++ b/test.cxx @@ -49,6 +49,21 @@ TEST_CASE("Boolean flags work as expected, with clustering", "[args]") REQUIRE_FALSE(bix); } +TEST_CASE("Count flag works as expected", "[args]") +{ + args::ArgumentParser parser("This is a test program.", "This goes after the options."); + args::Counter foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); + args::Counter bar(parser, "BAR", "test flag", args::Matcher{'b', "bar"}, 7); + args::Counter baz(parser, "BAZ", "test flag", args::Matcher{'z', "baz"}, 7); + parser.ParseArgs(std::vector{"--foo", "-fb", "--bar", "-b", "-f", "--foo"}); + REQUIRE(foo); + REQUIRE(bar); + REQUIRE_FALSE(baz); + REQUIRE(args::get(foo) == 4); + REQUIRE(args::get(bar) == 10); + REQUIRE(args::get(baz) == 7); +} + TEST_CASE("Argument flags work as expected, with clustering", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); @@ -59,12 +74,12 @@ TEST_CASE("Argument flags work as expected, with clustering", "[args]") args::Flag bix(parser, "BAZ", "test flag", args::Matcher{'x', "bix"}); parser.ParseArgs(std::vector{"-bftest", "--baz=7.555e2", "--bim", "c"}); REQUIRE(foo); - REQUIRE(foo.value == "test"); + REQUIRE(args::get(foo) == "test"); REQUIRE(bar); REQUIRE(baz); - REQUIRE((baz.value > 755.49 && baz.value < 755.51)); + REQUIRE((args::get(baz) > 755.49 && args::get(baz) < 755.51)); REQUIRE(bim); - REQUIRE(bim.value == 'c'); + REQUIRE(args::get(bim) == 'c'); REQUIRE_FALSE(bix); } @@ -85,15 +100,26 @@ TEST_CASE("Unified argument lists for match work", "[args]") args::Flag bix(parser, "BAZ", "test flag", args::Matcher{"bix"}); parser.ParseArgs(std::vector{"-bftest", "--baz=7.555e2", "--bim", "c"}); REQUIRE(foo); - REQUIRE(foo.value == "test"); + REQUIRE(args::get(foo) == "test"); REQUIRE(bar); REQUIRE(baz); - REQUIRE((baz.value > 755.49 && baz.value < 755.51)); + REQUIRE((args::get(baz) > 755.49 && args::get(baz) < 755.51)); REQUIRE(bim); - REQUIRE(bim.value == 'c'); + REQUIRE(args::get(bim) == 'c'); REQUIRE_FALSE(bix); } +TEST_CASE("Get can be assigned to for non-reference types", "[args]") +{ + args::ArgumentParser parser("This is a test program.", "This goes after the options."); + args::ArgFlag foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); + parser.ParseArgs(std::vector{"--foo=test"}); + REQUIRE(foo); + REQUIRE(args::get(foo) == "test"); + args::get(foo) = "bar"; + REQUIRE(args::get(foo) == "bar"); +} + TEST_CASE("Invalid argument parsing throws parsing exceptions", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); @@ -108,7 +134,7 @@ TEST_CASE("Argument flag lists work as expected", "[args]") args::ArgumentParser parser("This is a test program.", "This goes after the options."); args::ArgFlagList foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); parser.ParseArgs(std::vector{"--foo=7", "-f2", "-f", "9", "--foo", "42"}); - REQUIRE((foo.values == std::vector{7, 2, 9, 42})); + REQUIRE((args::get(foo) == std::vector{7, 2, 9, 42})); } TEST_CASE("Positional arguments and positional argument lists work as expected", "[args]") @@ -119,11 +145,11 @@ TEST_CASE("Positional arguments and positional argument lists work as expected", args::PosArgList baz(parser, "BAZ", "test flag"); parser.ParseArgs(std::vector{"this is a test flag", "0", "a", "b", "c", "x", "y", "z"}); REQUIRE(foo); - REQUIRE((foo.value == "this is a test flag")); + REQUIRE((args::get(foo) == "this is a test flag")); REQUIRE(bar); - REQUIRE(!bar.value); + REQUIRE(!args::get(bar)); REQUIRE(baz); - REQUIRE((baz.values == std::vector{'a', 'b', 'c', 'x', 'y', 'z'})); + REQUIRE((args::get(baz) == std::vector{'a', 'b', 'c', 'x', 'y', 'z'})); } TEST_CASE("Positionals that are unspecified evaluate false", "[args]") @@ -134,7 +160,7 @@ TEST_CASE("Positionals that are unspecified evaluate false", "[args]") args::PosArgList baz(parser, "BAZ", "test flag"); parser.ParseArgs(std::vector{"this is a test flag again"}); REQUIRE(foo); - REQUIRE((foo.value == "this is a test flag again")); + REQUIRE((args::get(foo) == "this is a test flag again")); REQUIRE_FALSE(bar); REQUIRE_FALSE(baz); } @@ -225,10 +251,10 @@ TEST_CASE("Custom types work", "[args]") args::PosArg> ints(parser, "INTS", "This takes a pair of integers."); args::PosArg, DoublesReader> doubles(parser, "DOUBLES", "This takes a pair of doubles."); parser.ParseArgs(std::vector{"1,2", "3.8,4"}); - REQUIRE(std::get<0>(ints.value) == 1); - REQUIRE(std::get<1>(ints.value) == 2); - REQUIRE((std::get<0>(doubles.value) > 3.79 && std::get<0>(doubles.value) < 3.81)); - REQUIRE((std::get<1>(doubles.value) > 3.99 && std::get<1>(doubles.value) < 4.01)); + REQUIRE(std::get<0>(args::get(ints)) == 1); + REQUIRE(std::get<1>(args::get(ints)) == 2); + REQUIRE((std::get<0>(args::get(doubles)) > 3.79 && std::get<0>(args::get(doubles)) < 3.81)); + REQUIRE((std::get<1>(args::get(doubles)) > 3.99 && std::get<1>(args::get(doubles)) < 4.01)); } TEST_CASE("Custom parser prefixes (dd-style)", "[args]") @@ -243,11 +269,11 @@ TEST_CASE("Custom parser prefixes (dd-style)", "[args]") args::ArgFlag output(parser, "BLOCK SIZE", "Block size", args::Matcher({"of"})); parser.ParseArgs(std::vector{"skip=8", "if=/dev/null"}); REQUIRE_FALSE(bs); - REQUIRE(bs.value == 512); + REQUIRE(args::get(bs) == 512); REQUIRE(skip); - REQUIRE(skip.value == 8); + REQUIRE(args::get(skip) == 8); REQUIRE(input); - REQUIRE(input.value == "/dev/null"); + REQUIRE(args::get(input) == "/dev/null"); REQUIRE_FALSE(output); } @@ -263,11 +289,11 @@ TEST_CASE("Custom parser prefixes (Some Windows styles)", "[args]") args::ArgFlag output(parser, "BLOCK SIZE", "Block size", args::Matcher({"of"})); parser.ParseArgs(std::vector{"/skip:8", "/if:/dev/null"}); REQUIRE_FALSE(bs); - REQUIRE(bs.value == 512); + REQUIRE(args::get(bs) == 512); REQUIRE(skip); - REQUIRE(skip.value == 8); + REQUIRE(args::get(skip) == 8); REQUIRE(input); - REQUIRE(input.value == "/dev/null"); + REQUIRE(args::get(input) == "/dev/null"); REQUIRE_FALSE(output); } -- cgit v1.2.1