Merge pull request #71 from lichray/simplify-misc

Simplify a few internals

include/argparse.hpp

@@ -73,11 +73,6 @@ struct is_container<
 template <typename T>
 static constexpr bool is_container_v = is_container<T>::value;
 
-template <typename T>
-struct is_string_like
-    : std::conjunction<std::is_constructible<std::string, T>,
-                       std::is_convertible<T, std::string_view>> {};
-
 template <typename T> constexpr bool standard_signed_integer = false;
 template <> constexpr bool standard_signed_integer<signed char> = true;
 template <> constexpr bool standard_signed_integer<short int> = true;
@@ -271,25 +266,20 @@ class Argument {
       -> std::ostream &;
 
   template <size_t N, size_t... I>
-  explicit Argument(std::string(&&a)[N], std::index_sequence<I...>)
+  explicit Argument(std::string_view(&&a)[N], std::index_sequence<I...>)
       : mIsOptional((is_optional(a[I]) || ...)), mIsRequired(false),
         mIsUsed(false) {
-    ((void)mNames.push_back(std::move(a[I])), ...);
+    ((void)mNames.emplace_back(a[I]), ...);
     std::sort(
         mNames.begin(), mNames.end(), [](const auto &lhs, const auto &rhs) {
           return lhs.size() == rhs.size() ? lhs < rhs : lhs.size() < rhs.size();
         });
   }
 
 public:
-  Argument() = default;
-
-  template <typename... Args,
-            std::enable_if_t<
-                std::conjunction_v<details::is_string_like<Args>...>, int> = 0>
-  explicit Argument(Args &&... args)
-      : Argument({std::string(std::forward<Args>(args))...},
-                 std::make_index_sequence<sizeof...(Args)>{}) {}
+  template <size_t N>
+  explicit Argument(std::string_view(&&a)[N])
+      : Argument(std::move(a), std::make_index_sequence<N>{}) {}
 
   Argument &help(std::string aHelp) {
     mHelp = std::move(aHelp);
@@ -383,12 +373,13 @@ class Argument {
   }
 
   template <typename Iterator>
-  Iterator consume(Iterator start, Iterator end, std::string usedName = {}) {
+  Iterator consume(Iterator start, Iterator end,
+                   std::string_view usedName = {}) {
     if (mIsUsed) {
       throw std::runtime_error("Duplicate argument");
     }
     mIsUsed = true;
-    mUsedName = std::move(usedName);
+    mUsedName = usedName;
     if (mNumArgs == 0) {
       mValues.emplace_back(mImplicitValue);
       return start;
@@ -731,7 +722,7 @@ class Argument {
   }
 
   std::vector<std::string> mNames;
-  std::string mUsedName;
+  std::string_view mUsedName;
   std::string mHelp;
   std::any mDefaultValue;
   std::any mImplicitValue;
@@ -780,8 +771,9 @@ class ArgumentParser {
   // Parameter packing
   // Call add_argument with variadic number of string arguments
   template <typename... Targs> Argument &add_argument(Targs... Fargs) {
+    using array_of_sv = std::string_view[sizeof...(Targs)];
     auto tArgument = mOptionalArguments.emplace(cend(mOptionalArguments),
-                                                std::move(Fargs)...);
+                                                array_of_sv{Fargs...});
 
     if (!tArgument->mIsOptional)
       mPositionalArguments.splice(cend(mPositionalArguments),
@@ -941,7 +933,7 @@ class ArgumentParser {
           std::exit(0);
         }
 
-        it = tArgument->consume(std::next(it), end, tCurrentArgument);
+        it = tArgument->consume(std::next(it), end, tIterator->first);
       } else if (const auto &tCompoundArgument = tCurrentArgument;
                  tCompoundArgument.size() > 1 && tCompoundArgument[0] == '-' &&
                  tCompoundArgument[1] != '-') {
@@ -951,7 +943,7 @@ class ArgumentParser {
           auto tIterator2 = mArgumentMap.find(tHypotheticalArgument);
           if (tIterator2 != mArgumentMap.end()) {
             auto tArgument = tIterator2->second;
-            it = tArgument->consume(it, end, tHypotheticalArgument);
+            it = tArgument->consume(it, end, tIterator2->first);
           } else {
             throw std::runtime_error("Unknown argument");
           }