COMMON: StringUtils: introduce a XrdOucString equivalent replace_all

This function would replace all src patterns within the string with a
target. When the target replacement is larger than source
the output string is likely going to be a larger string, in this case
we do an optimisation pass to determine the total size we'd grow to
and reserve the string. This allows for string::replace function calls
to never realloc while maintaining the similar memmove/memcpy
patterns that'd be eventually called with std::string::replace functions

Signed-off-by: Abhishek Lekshmanan <abhishek.lekshmanan@cern.ch>

Author: theanalyst

common/StringUtils.hh

@@ -30,6 +30,7 @@
 #include <string>
 #include <charconv>
 #include <cstdint>
+#include <cstddef>
 #include <string_view>
 
 #include "common/Namespace.hh"
@@ -259,6 +260,100 @@ auto StringToNumeric(const StrT& key, NumT& value,
   return true;
 }
 
-#endif
+#endif // __cpp_lib_to_chars
+
+
+// an XrdOucString inspired replace function that replaces
+// all occurences of s1 with s2 for a given str, in place
+// The Original function returned the signed size of total
+// length modification, however this doesn't really tell
+// us if any replacement happened since s1.size() == s2.size()
+// would mean the str size remains the same regardless of replacement
+// so we don't really return the difference.
+static inline void replace_all(std::string& str,
+                 std::string_view s1, std::string_view s2,
+                 size_t from=0, size_t to=std::string::npos)
+{
+  const size_t orig_str_size = str.size();
+  if (str.empty() || s1.empty() || from >= orig_str_size || from > to) {
+    return;
+  }
+
+  to = std::min(to, str.size() - 1);
+
+  // Run 2 passes of the replace function, the first pass
+  // determines the total delta, this allows to calculate
+  // upfront our target size and hence reduce regrowing the
+  // string at every interval
+  const size_t l1 = s1.size();
+  const size_t l2 = s2.size();
+
+  if (l1 > to - from + 1) {
+    return;
+  }
+
+  // Check if the orig string will need to be expanded, this occurs
+  // when the replacement target is bigger. We'd need to reallocate
+  // do this once!
+  if (l2 > l1) {
+    size_t match_count {0};
+    size_t pos {from};
+    size_t end_pos {to - l1 + 1};
+    size_t delta_per {l2 - l1};
+    while (pos <= end_pos) {
+      pos = str.find(s1, pos);
+      if (pos == std::string::npos || pos > end_pos) {
+        break;
+      }
+      ++match_count;
+      pos += l1;
+    }
+
+    if (match_count == 0) {
+      return;
+    }
+
+    str.reserve(orig_str_size + (match_count * delta_per));
+  }
+
+
+  size_t end_pos {to - l1 + 1};
+  size_t curr_pos {from};
+  const std::ptrdiff_t delta_per = static_cast<std::ptrdiff_t>(l2) - static_cast<std::ptrdiff_t>(l1);
+  while (curr_pos != std::string::npos) {
+    size_t match_pos = str.find(s1, curr_pos);
+
+    if (match_pos == std::string::npos || match_pos > end_pos) {
+      return;
+    }
+
+    str.replace(match_pos, l1, s2);
+
+    if (delta_per != 0) {
+      if (delta_per > 0) {
+        to += static_cast<size_t>(delta_per);
+      } else {
+        const size_t abs_diff = static_cast<size_t>(-delta_per);
+        if (abs_diff <= to) {
+          to -= abs_diff;
+        } else {
+          // Clamp to 0 if the contraction exceeds the 'to' index
+          to = 0;
+        }
+      }
+
+      if (to < l1) {
+        break;
+      }
+
+      end_pos = to - l1 + 1;
+
+    }
+    curr_pos = match_pos + l2;
+  }
+
+}
+
+
 
 EOSCOMMONNAMESPACE_END

unit_tests/common/StringUtilsTests.cc

@@ -120,4 +120,218 @@ TEST(StringUtils, StringToNumericErrorMessage)
   ASSERT_TRUE(!err_msg.empty());
   EXPECT_EQ(err_msg,
             "\"msg=Failed Numeric conversion\" key=128 error_msg=Numerical result out of range");
-}
+}
+
+using eos::common::replace_all;
+
+TEST(StringUtils, ReplaceAllEmpty) {
+  std::string str = "the quick brown fox jumps over the lazy dog";
+  std::string orig_str {str};
+
+  replace_all(orig_str, "","");
+  EXPECT_EQ(orig_str, str);
+
+  replace_all(orig_str, "", "foo");
+  EXPECT_EQ(orig_str, str);
+
+  replace_all(orig_str, "fox", "charlie", 1000,2000);
+  EXPECT_EQ(orig_str, str);
+
+  replace_all(orig_str, "fox", "charlie", 10,5);
+  EXPECT_EQ(orig_str, str);
+
+}
+
+TEST(StringUtils, ReplaceAllBasic) {
+  std::string str = "the quick brown fox jumps over the lazy dog";
+
+  replace_all(str, "fox", "charlie");
+  EXPECT_EQ(str, "the quick brown charlie jumps over the lazy dog");
+
+  str = "the quick brown fox jumps over the lazy dog";
+  replace_all(str, "the", "a");
+  EXPECT_EQ(str, "a quick brown fox jumps over a lazy dog");
+
+  str = "the quick brown fox jumps over the lazy dog";
+  replace_all(str, "o", "O");
+  EXPECT_EQ(str, "the quick brOwn fOx jumps Over the lazy dOg");
+
+  str = "the quick brown fox jumps over the lazy dog";
+  replace_all(str, " ", "_");
+  EXPECT_EQ(str, "the_quick_brown_fox_jumps_over_the_lazy_dog");
+
+  str = "the quick brown fox jumps over the lazy dog";
+  replace_all(str, "the", "a", 10, 43);
+  EXPECT_EQ(str, "the quick brown fox jumps over a lazy dog");
+
+  str = "the quick brown fox jumps over the lazy dog";
+  replace_all(str, "o", "O", 12, 25);
+  EXPECT_EQ(str, "the quick brOwn fOx jumps over the lazy dog");
+}
+
+TEST(StringUtils, ReplaceAllReduce) {
+  std::string str = "aaaaaa";
+  replace_all(str, "aa", "b");
+  EXPECT_EQ(str, "bbb");
+
+  str = "aaaaa";
+  replace_all(str, "aa","b");
+  EXPECT_EQ(str, "bba");
+}
+
+TEST(StringUtils, ReplaceAllEmptyIn) {
+  std::string str = "hello world";
+  replace_all(str, "hello","");
+  EXPECT_EQ(str, " world");
+}
+
+// Test with 'from' parameter
+TEST(StringUtils, ReplaceAllFromParameter) {
+    std::string str = "abc def abc ghi abc";
+    replace_all(str, "abc", "xyz", 4); // Start from position 4
+    EXPECT_EQ(str, "abc def xyz ghi xyz");
+}
+
+// Test with 'to' parameter
+TEST(StringUtils, ReplaceAllToParameter) {
+    std::string str = "abc def abc ghi abc";
+    replace_all(str, "abc", "xyz", 0, 10); // Only replace up to position 10
+    EXPECT_EQ(str, "xyz def xyz ghi abc");
+}
+
+// Test with both 'from' and 'to' parameters
+TEST(StringUtils, ReplaceAllFromAndToParameters) {
+    std::string str = "abc def abc ghi abc jkl abc";
+    replace_all(str, "abc", "xyz", 4, 15); // Replace from pos 4 to pos 15
+    EXPECT_EQ(str, "abc def xyz ghi abc jkl abc");
+}
+
+// Test invalid range parameters
+TEST(StringUtils, ReplaceAllInvalidRangeParameters) {
+    std::string str = "hello world hello";
+    std::string original = str;
+
+    // from >= string size
+    replace_all(str, "hello", "hi", 20);
+    EXPECT_EQ(str, original);
+
+    // from > to
+    std::string str2 = "hello world hello";
+    replace_all(str2, "hello", "hi", 10, 5);
+    EXPECT_EQ(str2, original);
+}
+
+// Test overlapping patterns
+TEST(StringUtils, ReplaceAllOverlappingPatterns) {
+    std::string str = "aaaa";
+    replace_all(str, "aa", "b");
+    // Should replace non-overlapping occurrences: "aaaa" -> "bb"
+    EXPECT_EQ(str, "bb");
+}
+
+// Test single character replacement
+TEST(StringUtils, ReplaceAllSingleCharacterReplacement) {
+    std::string str = "a b a c a";
+    replace_all(str, "a", "x");
+    EXPECT_EQ(str, "x b x c x");
+}
+
+// Test replacement at string boundaries
+TEST(StringUtils, ReplaceAllBoundaryReplacement) {
+    // At beginning
+    std::string str1 = "hello world";
+    replace_all(str1, "hello", "hi");
+    EXPECT_EQ(str1, "hi world");
+
+    // At end
+    std::string str2 = "world hello";
+    replace_all(str2, "hello", "hi");
+    EXPECT_EQ(str2, "world hi");
+
+    // Entire string
+    std::string str3 = "hello";
+    replace_all(str3, "hello", "hi");
+    EXPECT_EQ(str3, "hi");
+}
+
+// Test with special characters
+TEST(StringUtils, ReplaceAllSpecialCharacters) {
+    std::string str = "a\nb\ta\nc";
+    replace_all(str, "a", "x");
+    EXPECT_EQ(str, "x\nb\tx\nc");
+}
+
+// Test case sensitivity
+TEST(StringUtils, ReplaceAllCaseSensitivity) {
+    std::string str = "Hello world HELLO";
+    replace_all(str, "Hello", "Hi");
+    EXPECT_EQ(str, "Hi world HELLO"); // Should not replace "HELLO"
+}
+
+// Test with long strings and patterns
+TEST(StringUtils, ReplaceAllLongStringsAndPatterns) {
+    std::string str = "this is a long pattern and this is another long pattern";
+    replace_all(str, "long pattern", "short");
+    EXPECT_EQ(str, "this is a short and this is another short");
+}
+
+// Test performance with many replacements
+TEST(StringUtils, ReplaceAllManyReplacements) {
+    std::string str;
+    for (int i = 0; i < 1000; ++i) {
+        str += "a ";
+    }
+    replace_all(str, "a", "bb");
+
+    // Verify the result
+    std::string expected;
+    for (int i = 0; i < 1000; ++i) {
+        expected += "bb ";
+    }
+    EXPECT_EQ(str, expected);
+}
+
+// Test with substring that appears within the replacement
+TEST(StringUtils, ReplaceAllSubstringInReplacement) {
+    std::string str = "abc abc abc";
+    replace_all(str, "abc", "abcdef");
+    EXPECT_EQ(str, "abcdef abcdef abcdef");
+}
+
+// Test edge case where search pattern is larger than available range
+TEST(StringUtils, ReplaceAllSearchPatternLargerThanRange) {
+    std::string str = "hello world";
+    std::string original = str;
+    replace_all(str, "hello world!", "hi", 0, 5); // Pattern longer than range
+    EXPECT_EQ(str, original); // Should not change
+}
+
+// Test replacement with exact range boundaries
+TEST(StringUtils, ReplaceAllExactRangeBoundaries) {
+    std::string str = "abcdefabc";
+    replace_all(str, "abc", "x", 0, 2); // Range exactly matches first "abc"
+    EXPECT_EQ(str, "xdefabc");
+}
+
+// Test string_view parameters
+TEST(StringUtils, ReplaceAllStringViewParameters) {
+    std::string str = "hello world hello";
+    std::string_view search = "hello";
+    std::string_view replacement = "hi";
+    replace_all(str, search, replacement);
+    EXPECT_EQ(str, "hi world hi");
+}
+
+// Test with to parameter as string::npos (default)
+TEST(StringUtils, ReplaceAllDefaultToParameter) {
+    std::string str = "abc def abc ghi abc";
+    replace_all(str, "abc", "xyz", 4, std::string::npos);
+    EXPECT_EQ(str, "abc def xyz ghi xyz");
+}
+
+// Test contraction that would make 'to' go below search pattern length
+TEST(StringUtils, ReplaceAllContractionBelowPatternLength) {
+    std::string str = "abcabcabc";
+    replace_all(str, "abc", "x", 0, 8); // This should handle the contraction properly
+    EXPECT_EQ(str, "xxx");
+}