utils.h: added helpers for efficient string concatination [skip ci]

Author: firewave

lib/tokenize.cpp

@@ -2418,8 +2418,7 @@ namespace {
             while (scope && scope->parent) {
                 if (scope->name.empty())
                     break;
-                fullName.insert(0, " :: ");
-                fullName.insert(0, scope->name);
+                utils::string::prepend(fullName, scope->name, " :: ");
                 scope = scope->parent;
             }
         }

lib/utils.h

@@ -436,6 +436,57 @@ namespace utils {
             return result;
         };
     }
+
+    namespace string
+    {
+        template<size_t size>
+        void concat(std::string &str, const char (&data)[size])
+        {
+            str.append(data, size-1);
+        }
+
+        inline void concat(std::string &str, char c)
+        {
+            str.append(1, c);
+        }
+
+        template<typename T>
+        void concat(std::string &str, T t)
+        {
+            str.append(t);
+        }
+
+        template<typename T, typename... Args>
+        void concat(std::string& str, T t, Args... args)
+        {
+            concat(str, t);
+            concat(str, args...);
+        }
+
+        template<size_t size>
+        void prepend(std::string &str, const char (&data)[size])
+        {
+            str.insert(0, data, size-1);
+        }
+
+        inline void prepend(std::string &str, char c)
+        {
+            str.insert(0, 1, c);
+        }
+
+        template<typename T>
+        void prepend(std::string &str, T t)
+        {
+            str.insert(0, t);
+        }
+
+        template<typename T, typename... Args>
+        void prepend(std::string& str, T t, Args... args)
+        {
+            prepend(str, args...);
+            prepend(str, t);
+        }
+    }
 }
 
 #endif

test/testutils.cpp

@@ -45,6 +45,8 @@ class TestUtils : public TestFixture {
         TEST_CASE(as_const);
         TEST_CASE(memoize);
         TEST_CASE(endsWith);
+        TEST_CASE(stringConcat);
+        TEST_CASE(stringPrepend);
     }
 
     void isValidGlobPattern() const {
@@ -575,6 +577,126 @@ class TestUtils : public TestFixture {
         ASSERT(!::endsWith("tes", "test"));
         ASSERT(!::endsWith("2test", "2"));
     }
+
+    void stringConcat() const
+    {
+        {
+            std::string s = "0";
+            utils::string::concat(s, "a");
+            utils::string::concat(s, "b");
+            utils::string::concat(s, "c");
+            ASSERT_EQUALS("0abc", s);
+        }
+        {
+            std::string s = "0";
+            utils::string::concat(s, "a", "b", "c");
+            ASSERT_EQUALS("0abc", s);
+        }
+        {
+            const std::string a_str = "a";
+            const std::string b_str = "b";
+            const std::string c_str = "c";
+            {
+                std::string s = "0";
+                utils::string::concat(s, a_str);
+                utils::string::concat(s, b_str);
+                utils::string::concat(s, c_str);
+                ASSERT_EQUALS("0abc", s);
+            }
+            {
+                std::string s = "0";
+                utils::string::concat(s, a_str, b_str, c_str);
+                ASSERT_EQUALS("0abc", s);
+            }
+        }
+        {
+            std::string s = "0";
+            utils::string::concat(s, 'a');
+            utils::string::concat(s, 'b');
+            utils::string::concat(s, 'c');
+            ASSERT_EQUALS("0abc", s);
+        }
+        {
+            std::string s = "0";
+            utils::string::concat(s, 'a', 'b', 'c');
+            ASSERT_EQUALS("0abc", s);
+        }
+        {
+            const std::string a_str = "a";
+            {
+                std::string s = "0";
+                utils::string::concat(s, a_str);
+                utils::string::concat(s, 'b');
+                utils::string::concat(s, "c");
+                ASSERT_EQUALS("0abc", s);
+            }
+            {
+                std::string s = "0";
+                utils::string::concat(s, a_str, 'b', "c");
+                ASSERT_EQUALS("0abc", s);
+            }
+        }
+    }
+
+    void stringPrepend() const
+    {
+        {
+            std::string s = "0";
+            utils::string::prepend(s, "a");
+            utils::string::prepend(s, "b");
+            utils::string::prepend(s, "c");
+            ASSERT_EQUALS("cba0", s);
+        }
+        {
+            std::string s = "0";
+            utils::string::prepend(s, "a", "b", "c");
+            ASSERT_EQUALS("abc0", s);
+        }
+        {
+            const std::string a_str = "a";
+            const std::string b_str = "b";
+            const std::string c_str = "c";
+            {
+                std::string s = "0";
+                utils::string::prepend(s, a_str);
+                utils::string::prepend(s, b_str);
+                utils::string::prepend(s, c_str);
+                ASSERT_EQUALS("cba0", s);
+            }
+            {
+                std::string s = "0";
+                utils::string::prepend(s, a_str, b_str, c_str);
+                ASSERT_EQUALS("abc0", s);
+            }
+        }
+        {
+            std::string s = "0";
+            utils::string::prepend(s, 'a');
+            utils::string::prepend(s, 'b');
+            utils::string::prepend(s, 'c');
+            ASSERT_EQUALS("cba0", s);
+        }
+        {
+            std::string s = "0";
+            utils::string::prepend(s, 'a', 'b', 'c');
+            ASSERT_EQUALS("abc0", s);
+        }
+        {
+            const std::string a_str = "a";
+            {
+                std::string s = "0";
+                utils::string::prepend(s, a_str);
+                utils::string::prepend(s, 'b');
+                utils::string::prepend(s, "c");
+                ASSERT_EQUALS("cba0", s);
+            }
+            {
+                std::string s = "0";
+                utils::string::prepend(s, a_str, 'b', "c");
+                ASSERT_EQUALS("abc0", s);
+            }
+        }
+    }
 };
 
 REGISTER_TEST(TestUtils)