Make the replace_all stuff work for c++11

Author: jeremy-rifkin

src/formatting.cpp

@@ -33,21 +33,21 @@ namespace cpptrace {
         // this brings it in-line with other compilers and prevents any tokenization/highlighting issues
         static const std::regex msvc_anonymous_namespace("`anonymous namespace'");
         detail::replace_all(symbol, msvc_anonymous_namespace, "(anonymous namespace)");
-        // rules to replace std::basic_string -> std::string and std::basic_string_view -> std::string_view
+        // rules to replace std::basic_string -> std::string and std::basic_string_view -> std::string
         // rule to replace ", std::allocator<whatever>"
-        static const std::pair<std::regex, std::string_view> basic_string = {
+        static const std::pair<std::regex, std::string> basic_string = {
             std::regex(R"(std(::[a-zA-Z0-9_]+)?::basic_string<char)"), "std::string"
         };
         detail::replace_all_template(symbol, basic_string);
-        static const std::pair<std::regex, std::string_view> basic_string_view = {
+        static const std::pair<std::regex, std::string> basic_string_view = {
             std::regex(R"(std(::[a-zA-Z0-9_]+)?::basic_string_view<char)"), "std::string_view"
         };
         detail::replace_all_template(symbol, basic_string_view);
-        static const std::pair<std::regex, std::string_view> allocator = {
+        static const std::pair<std::regex, std::string> allocator = {
             std::regex(R"(,\s*std(::[a-zA-Z0-9_]+)?::allocator<)"), ""
         };
         detail::replace_all_template(symbol, allocator);
-        static const std::pair<std::regex, std::string_view> default_delete = {
+        static const std::pair<std::regex, std::string> default_delete = {
             std::regex(R"(,\s*std(::[a-zA-Z0-9_]+)?::default_delete<)"), ""
         };
         detail::replace_all_template(symbol, default_delete);

src/utils/replace_all.cpp

@@ -2,34 +2,34 @@
 
 namespace cpptrace {
 namespace detail {
-    void replace_all(std::string& str, std::string_view substr, std::string_view replacement) {
+    void replace_all(std::string& str, string_view substr, string_view replacement) {
         std::string::size_type pos = 0;
-        while((pos = str.find(substr.data(), pos, substr.length())) != std::string::npos) {
-            str.replace(pos, substr.length(), replacement.data(), replacement.length());
-            pos += replacement.length();
+        while((pos = str.find(substr.data(), pos, substr.size())) != std::string::npos) {
+            str.replace(pos, substr.size(), replacement.data(), replacement.size());
+            pos += replacement.size();
         }
     }
 
-    void replace_all(std::string& str, const std::regex& re, std::string_view replacement) {
+    void replace_all(std::string& str, const std::regex& re, string_view replacement) {
         std::smatch match;
         std::size_t i = 0;
         while(std::regex_search(str.cbegin() + i, str.cend(), match, re)) {
-            str.replace(i + match.position(), match.length(), replacement);
-            i += match.position() + replacement.length();
+            str.replace(i + match.position(), match.length(), replacement.data(), replacement.size());
+            i += match.position() + replacement.size();
         }
     }
 
-    void replace_all_dynamic(std::string& str, std::string_view substr, std::string_view replacement) {
+    void replace_all_dynamic(std::string& str, string_view substr, string_view replacement) {
         std::string::size_type pos = 0;
-        while((pos = str.find(substr.data(), pos, substr.length())) != std::string::npos) {
-            str.replace(pos, substr.length(), replacement.data(), replacement.length());
+        while((pos = str.find(substr.data(), pos, substr.size())) != std::string::npos) {
+            str.replace(pos, substr.size(), replacement.data(), replacement.size());
             // advancing by one rather than replacement.length() in case replacement leads to
             // another replacement opportunity, e.g. folding > > > to >> > then >>>
             pos++;
         }
     }
 
-    void replace_all_template(std::string& str, const std::pair<std::regex, std::string_view>& rule) {
+    void replace_all_template(std::string& str, const std::pair<std::regex, string_view>& rule) {
         const auto& [re, replacement] = rule;
         std::smatch match;
         std::size_t cursor = 0;
@@ -45,8 +45,8 @@ namespace detail {
                 }
             }
             // make the replacement
-            str.replace(match_begin, end - match_begin, replacement);
-            cursor = match_begin + replacement.length();
+            str.replace(match_begin, end - match_begin, replacement.data(), replacement.size());
+            cursor = match_begin + replacement.size();
         }
     }
 }

src/utils/replace_all.hpp

@@ -4,19 +4,21 @@
 #include <string>
 #include <regex>
 
+#include "utils/string_view.hpp"
+
 namespace cpptrace {
 namespace detail {
     // replace all instances of substr with the replacement
-    void replace_all(std::string& str, std::string_view substr, std::string_view replacement);
+    void replace_all(std::string& str, string_view substr, string_view replacement);
 
     // replace all regex matches with the replacement
-    void replace_all(std::string& str, const std::regex& re, std::string_view replacement);
+    void replace_all(std::string& str, const std::regex& re, string_view replacement);
 
     // replace all instances of substr with the replacement, including new instances introduced by the replacement
-    void replace_all_dynamic(std::string& str, std::string_view substr, std::string_view replacement);
+    void replace_all_dynamic(std::string& str, string_view substr, string_view replacement);
 
     // replace all matches of a regex including template parameters
-    void replace_all_template(std::string& str, const std::pair<std::regex, std::string_view>& rule);
+    void replace_all_template(std::string& str, const std::pair<std::regex, string_view>& rule);
 }
 }