Initial work

Author: linkdotnet

src/LinkDotNet.StringBuilder/BoyerMooreSearch.cs

@@ -0,0 +1,87 @@
+namespace LinkDotNet.StringBuilder;
+
+/// <summary>
+/// Taken from here: https://github.com/linkdotnet/StringOperations and adopted to work with ReadOnlySpan's
+/// </summary>
+internal static class BoyerMooreSearch
+{
+    private const int AlphabetSize = 256;
+
+    /// <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 badCharacterTable = GetBadCharacterTable(word);
+        var shift = 0;
+        var hits = new TypedSpanList<int>();
+        while (shift <= text.Length - word.Length)
+        {
+            var index = word.Length - 1;
+
+            index = ReduceIndexWhileMatchAtShift(text, word, index, shift);
+
+            if (index < 0)
+            {
+                hits.Add(shift);
+
+                shift = ShiftPatternToNextCharacterWithLastOccurrenceOfPattern(text, shift, word.Length, badCharacterTable);
+            }
+            else
+            {
+                shift = ShiftPatternAfterBadCharacter(text, shift, index, badCharacterTable);
+            }
+        }
+
+        return hits.AsSpan;
+    }
+
+    private static ReadOnlySpan<int> GetBadCharacterTable(ReadOnlySpan<char> text)
+    {
+        Span<int> table = new int[AlphabetSize];
+        table.Fill(-1);
+
+        for (var i = 0; i < text.Length; i++)
+        {
+            table[text[i]] = i;
+        }
+
+        return table;
+    }
+
+    private static int ReduceIndexWhileMatchAtShift(ReadOnlySpan<char> text, ReadOnlySpan<char> word, int index, int shift)
+    {
+        while (index >= 0 && text[shift + index] == word[index])
+        {
+            index--;
+        }
+
+        return index;
+    }
+
+    private static int ShiftPatternToNextCharacterWithLastOccurrenceOfPattern(ReadOnlySpan<char> text, int shift, int wordLength, ReadOnlySpan<int> badCharacterTable)
+    {
+        return shift + (shift + wordLength < text.Length
+            ? wordLength - badCharacterTable[text[shift + wordLength]]
+            : 1);
+    }
+
+    private static int ShiftPatternAfterBadCharacter(ReadOnlySpan<char> text, int shift, int index,  ReadOnlySpan<int> badCharacterTable)
+    {
+        var character = text[shift + index];
+        return shift + Math.Max(1, index - badCharacterTable[character]);
+    }
+}

src/LinkDotNet.StringBuilder/TypedSpanList.cs

@@ -0,0 +1,46 @@
+using System.Buffers;
+
+namespace LinkDotNet.StringBuilder;
+
+/// <summary>
+/// Represents a List based on the <see cref="Span{T}"/> type.
+/// </summary>
+/// <typeparam name="T">Any struct.</typeparam>
+internal ref struct TypedSpanList<T>
+    where T : struct
+{
+    private Span<T> buffer;
+    private int count;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TypedSpanList{T}"/> struct.
+    /// </summary>
+    public TypedSpanList()
+    {
+        buffer = new T[32];
+        count = 0;
+    }
+
+    public ReadOnlySpan<T> AsSpan => buffer[..count];
+
+    public void Add(T value)
+    {
+        if (count >= buffer.Length)
+        {
+            Grow();
+        }
+
+        buffer[count] = value;
+        count++;
+    }
+
+    private void Grow(int capacity = 0)
+    {
+        var currentSize = buffer.Length;
+        var newSize = capacity > 0 ? capacity : currentSize * 2;
+        var rented = ArrayPool<T>.Shared.Rent(newSize);
+        buffer.CopyTo(rented);
+        buffer = rented;
+        ArrayPool<T>.Shared.Return(rented);
+    }
+}

src/LinkDotNet.StringBuilder/ValueStringBuilder.Replace.cs

@@ -0,0 +1,87 @@
+namespace LinkDotNet.StringBuilder;
+
+public ref partial struct ValueStringBuilder
+{
+    /// <summary>
+    /// Replaces all instances of one character with another in this builder.
+    /// </summary>
+    /// <param name="oldValue">The character to replace.</param>
+    /// <param name="newValue">The character to replace <paramref name="oldValue"/> with.</param>
+    public void Replace(char oldValue, char newValue) => Replace(oldValue, newValue, 0, Length);
+
+    /// <summary>
+    /// Replaces all instances of one character with another in this builder.
+    /// </summary>
+    /// <param name="oldValue">The character to replace.</param>
+    /// <param name="newValue">The character to replace <paramref name="oldValue"/> with.</param>
+    /// <param name="startIndex">The index to start in this builder.</param>
+    /// <param name="count">The number of characters to read in this builder.</param>
+    public void Replace(char oldValue, char newValue, int startIndex, int count)
+    {
+        if (startIndex < 0)
+        {
+            throw new ArgumentException("Start index can't be smaller than 0.", nameof(startIndex));
+        }
+
+        if (count > bufferPosition)
+        {
+            throw new ArgumentException($"Count: {count} is bigger than the current size {bufferPosition}.", nameof(count));
+        }
+
+        for (var i = startIndex; i < startIndex + count; i++)
+        {
+            if (buffer[i] == oldValue)
+            {
+                buffer[i] = newValue;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Replaces all instances of one string with another in this builder.
+    /// </summary>
+    /// <param name="oldValue">The string to replace.</param>
+    /// <param name="newValue">The string to replace <paramref name="oldValue"/> with.</param>
+    /// <remarks>
+    /// 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);
+
+    /// <summary>
+    /// Replaces all instances of one string with another in this builder.
+    /// </summary>
+    /// <param name="oldValue">The string to replace.</param>
+    /// <param name="newValue">The string to replace <paramref name="oldValue"/> with.</param>
+    /// <param name="startIndex">The index to start in this builder.</param>
+    /// <param name="count">The number of characters to read in this builder.</param>
+    /// <remarks>
+    /// 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, int startIndex, int count)
+    {
+        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);
+        if (hits.IsEmpty)
+        {
+            return;
+        }
+
+        var delta = newValue.Length - oldValue.Length;
+
+        for (var i = 0; i < hits.Length; i++)
+        {
+            var index = startIndex + hits[0] + (delta * i);
+            Remove(index, oldValue.Length);
+            var debug = ToString();
+            Console.WriteLine(debug);
+            Insert(index, newValue);
+            debug = ToString();
+            Console.WriteLine(debug);
+        }
+    }
+}

tests/LinkDotNet.StringBuilder.UnitTests/ValueStringBuilder.Replace.Tests.cs

@@ -0,0 +1,37 @@
+namespace LinkDotNet.StringBuilder.UnitTests;
+
+public class ValueStringBuilderReplaceTests
+{
+    [Fact]
+    public void ShouldReplaceAllCharacters()
+    {
+        var builder = new ValueStringBuilder();
+        builder.Append("CCCC");
+
+        builder.Replace('C', 'B');
+
+        builder.ToString().Should().Be("BBBB");
+    }
+
+    [Fact]
+    public void ShouldReplaceAllCharactersInGivenSpan()
+    {
+        var builder = new ValueStringBuilder();
+        builder.Append("CCCC");
+
+        builder.Replace('C', 'B', 1, 2);
+
+        builder.ToString().Should().Be("CBBC");
+    }
+
+    [Fact]
+    public void ShouldReplaceAllText()
+    {
+        var builder = new ValueStringBuilder();
+        builder.Append("Hello World. How are you doing. Hello world examples are always fun.");
+
+        builder.Replace("Hello", "Hallöchen");
+
+        builder.ToString().Should().Be("Hallöchen World. How are you doing. Hallöchen world examples are always fun.");
+    }
+}