Removed debugging and add NaiveSearch instead of BoyerMoore

Author: linkdotnet

logo.png

@@ -0,0 +1,43 @@
+namespace LinkDotNet.StringBuilder;
+
+internal static class NaiveSearch
+{
+    /// <summary>
+    /// Finds all occurence of <paramref name="word"/> in <paramref name="text"/>.
+    /// </summary>
+    /// <param name="text">The text to look for.</param>
+    /// <param name="word">The word which should be found in <paramref name="word"/>.</param>
+    /// <returns>Array of indexes where <paramref name="word"/> was found.</returns>
+    public static ReadOnlySpan<int> FindAll(ReadOnlySpan<char> text, ReadOnlySpan<char> word)
+    {
+        if (text.IsEmpty || word.IsEmpty)
+        {
+            return Array.Empty<int>();
+        }
+
+        if (text.Length < word.Length)
+        {
+            return Array.Empty<int>();
+        }
+
+        var hits = new TypedSpanList<int>();
+
+        for (var i = 0; i < text.Length; i++)
+        {
+            for (var j = 0; j < word.Length; j++)
+            {
+                if (text[i + j] != word[j])
+                {
+                    break;
+                }
+
+                if (j == word.Length - 1)
+                {
+                    hits.Add(i);
+                }
+            }
+        }
+
+        return hits.AsSpan;
+    }
+}

src/LinkDotNet.StringBuilder/BoyerMooreSearch.cs

@@ -46,7 +46,8 @@ public void Replace(char oldValue, char newValue, int startIndex, int count)
     /// If <paramref name="newValue"/> is <c>empty</c>, instances of <paramref name="oldValue"/>
     /// are removed from this builder.
     /// </remarks>
-    public void Replace(ReadOnlySpan<char> oldValue, ReadOnlySpan<char> newValue) => Replace(oldValue, newValue, 0, Length);
+    public void Replace(ReadOnlySpan<char> oldValue, ReadOnlySpan<char> newValue)
+        => Replace(oldValue, newValue, 0, Length);
 
     /// <summary>
     /// Replaces all instances of one string with another in this builder.
@@ -64,8 +65,12 @@ public void Replace(ReadOnlySpan<char> oldValue, ReadOnlySpan<char> newValue, in
         var length = startIndex + count;
         var slice = buffer[startIndex..length];
 
-        // We might want to check if for very small strings we go with a naive approach
-        var hits = BoyerMooreSearch.FindAll(slice, oldValue);
+        // We might want to check whether or not we want to introduce different
+        // string search algorithms for longer strings.
+        // I had checked initially with Boyer-Moore but it didn't make that much sense as we
+        // don't expect very long strings and then the performance is literally the same. So I went with the easier solution.
+        var hits = NaiveSearch.FindAll(slice, oldValue);
+
         if (hits.IsEmpty)
         {
             return;
@@ -75,13 +80,9 @@ public void Replace(ReadOnlySpan<char> oldValue, ReadOnlySpan<char> newValue, in
 
         for (var i = 0; i < hits.Length; i++)
         {
-            var index = startIndex + hits[0] + (delta * i);
+            var index = startIndex + hits[i] + (delta * i);
             Remove(index, oldValue.Length);
-            var debug = ToString();
-            Console.WriteLine(debug);
             Insert(index, newValue);
-            debug = ToString();
-            Console.WriteLine(debug);
         }
     }
 }

src/LinkDotNet.StringBuilder/NaiveSearch.cs

@@ -34,4 +34,26 @@ public void ShouldReplaceAllText()
 
         builder.ToString().Should().Be("Hallöchen World. How are you doing. Hallöchen world examples are always fun.");
     }
+
+    [Fact]
+    public void ShouldNotAlterIfNotFound()
+    {
+        var builder = new ValueStringBuilder();
+        builder.Append("Hello");
+
+        builder.Replace("Test", "Not");
+
+        builder.ToString().Should().Be("Hello");
+    }
+
+    [Fact]
+    public void ShouldReplaceInSpan()
+    {
+        var builder = new ValueStringBuilder();
+        builder.Append("Hello World. How are you doing. Hello world examples are always fun.");
+
+        builder.Replace("Hello", "Hallöchen", 0, 10);
+
+        builder.ToString().Should().Be("Hallöchen World. How are you doing. Hello world examples are always fun.");
+    }
 }