Pass string by value to Parser

fintarin · Mar 27, 2024 · adafd6e · adafd6e
1 parent 1e3d3f0
commit adafd6e
Show file tree

Hide file tree

Showing 2 changed files with 13 additions and 21 deletions.
diff --git a/include/fintamath/core/MathObjectBody.hpp b/include/fintamath/core/MathObjectBody.hpp
@@ -22,13 +22,12 @@ private:                                                        \
   static Class##Parser &getParser();                            \
                                                                 \
 public:                                                         \
-  template <std::convertible_to<std::string> String>            \
-  static auto parse(String &&str) {                             \
-    return getParser().parse(std::forward<String>(str));        \
+  static auto parse(std::string str) {                          \
+    return getParser().parse(std::move(str));                   \
   }                                                             \
                                                                 \
-  static auto parseFirst(const std::string &str) {              \
-    return getParser().parseFirst(str);                         \
+  static auto parseFirst(std::string str) {                     \
+    return getParser().parseFirst(std::move(str));              \
   }                                                             \
                                                                 \
   template <std::derived_from<Class> T>                         \

diff --git a/include/fintamath/core/Parser.hpp b/include/fintamath/core/Parser.hpp
@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -37,12 +38,12 @@ class Parser final {
 
   using StringToConstructorsMap = std::unordered_map<std::string, std::vector<Constructor>>;
 
-  using GeneratorConstructor = std::function<Generator(const std::string &)>;
+  using GeneratorConstructor = std::function<Generator(std::string)>;
 
   using GeneratorConstructorVector = std::vector<GeneratorConstructor>;
 
 public:
-  Generator parse(const std::string &str) const {
+  Generator parse(std::string str) const {
     if (const auto stringToConstructors = stringToConstructorsMap.find(str); stringToConstructors != stringToConstructorsMap.end()) {
       for (const auto &constructor : stringToConstructors->second) {
         co_yield constructor();
@@ -56,16 +57,8 @@ class Parser final {
     }
   }
 
-  Generator parse(std::string &&str) const {
-    return [](const Parser &parser, const std::string localStr) -> Generator {
-      for (auto &value : parser.parse(localStr)) {
-        co_yield std::move(value);
-      }
-    }(*this, std::move(str));
-  }
-
-  std::optional<Return> parseFirst(const std::string &str) const {
-    auto gener = parse(str);
+  std::optional<Return> parseFirst(std::string str) const {
+    auto gener = parse(std::move(str));
 
     if (auto iter = gener.begin(); iter != gener.end()) {
       return std::move(*iter);
@@ -89,9 +82,9 @@ class Parser final {
   template <typename Type>
     requires(!std::is_abstract_v<Type> && StringConstructable<Type>)
   void registerType() {
-    generatorConstructors.emplace_back([](const std::string &str) -> Generator {
+    generatorConstructors.emplace_back([](std::string str) -> Generator {
       try {
-        co_yield std::make_unique<Type>(str);
+        co_yield std::make_unique<Type>(std::move(str));
       }
       catch (const InvalidInputException &) {
         // Go to the next constructor
@@ -102,8 +95,8 @@ class Parser final {
   template <typename Type>
     requires(std::is_abstract_v<Type>)
   void registerType() {
-    generatorConstructors.emplace_back([](const std::string &str) -> Generator {
-      for (auto &value : Type::parse(str)) {
+    generatorConstructors.emplace_back([](std::string str) -> Generator {
+      for (auto &value : Type::parse(std::move(str))) {
         co_yield std::move(value);
       }
     });