Updating to newest release

Author: LinkDotNet Bot

CHANGELOG.md

@@ -6,6 +6,22 @@ All notable changes to **ValueStringBuilder** will be documented in this file. T
 
 ## [Unreleased]
 
+## [2.4.0] - 2025-02-21
+
+### Added
+
+- Added `ToString(int)` (by @Joy-less in #239)
+- Added `AsSpan(int)`, `AsSpan(int, int)`, `AsSpan(Range)` (by @Joy-less in #239)
+
+### Changed
+
+- Optimized and simplified `Replace` (by @Joy-less in #238)
+- Simplified `IndexOf` and `LastIndexOf` (by @Joy-less in #238)
+
+### Fixed
+
+- Fixed `IndexOf` and `LastIndexOf` allowing out-of-bounds index when the string to find is empty (by @Joy-less in #238)
+
 ## [2.3.1] - 2025-02-20
 
 ### Changed
@@ -473,7 +489,8 @@ This release brings extensions to the `ValueStringBuilder` API. For `v1.0` the `
 
 - Initial release
 
-[unreleased]: https://github.com/linkdotnet/StringBuilder/compare/2.3.1...HEAD
+[unreleased]: https://github.com/linkdotnet/StringBuilder/compare/2.4.0...HEAD
+[2.4.0]: https://github.com/linkdotnet/StringBuilder/compare/2.3.1...2.4.0
 [2.3.1]: https://github.com/linkdotnet/StringBuilder/compare/2.3.0...2.3.1
 [2.3.0]: https://github.com/linkdotnet/StringBuilder/compare/2.2.0...2.3.0
 [2.2.0]: https://github.com/linkdotnet/StringBuilder/compare/2.1.0...2.2.0

src/LinkDotNet.StringBuilder/IntegerSpanList.cs

@@ -92,53 +92,45 @@ public void Replace(scoped ReadOnlySpan<char> oldValue, scoped ReadOnlySpan<char
         ArgumentOutOfRangeException.ThrowIfLessThan(startIndex, 0);
         ArgumentOutOfRangeException.ThrowIfGreaterThan(startIndex + count, Length);
 
-        var length = startIndex + count;
-        var slice = buffer[startIndex..length];
-
-        if (oldValue.SequenceEqual(newValue))
+        if (oldValue.IsEmpty || oldValue.Equals(newValue, StringComparison.Ordinal))
         {
             return;
         }
 
-        // 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);
+        var index = startIndex;
+        var remainingChars = count;
 
-        if (hits.IsEmpty)
+        while (remainingChars > 0)
         {
-            return;
-        }
-
-        var delta = newValue.Length - oldValue.Length;
+            var foundSubIndex = buffer.Slice(index, remainingChars).IndexOf(oldValue, StringComparison.Ordinal);
+            if (foundSubIndex < 0)
+            {
+                break;
+            }
 
-        for (var i = 0; i < hits.Length; i++)
-        {
-            var index = startIndex + hits[i] + (delta * i);
+            index += foundSubIndex;
+            remainingChars -= foundSubIndex;
 
-            // newValue is smaller than old value
-            // We can insert the slice and remove the overhead
-            if (delta < 0)
+            if (newValue.Length == oldValue.Length)
             {
+                // Just replace the old slice
                 newValue.CopyTo(buffer[index..]);
-                Remove(index + newValue.Length, -delta);
             }
-
-            // Same length -> We can just replace the memory slice
-            else if (delta == 0)
+            else if (newValue.Length < oldValue.Length)
             {
+                // Replace the old slice and trim the unused slice
                 newValue.CopyTo(buffer[index..]);
+                Remove(index + newValue.Length, oldValue.Length - newValue.Length);
             }
-
-            // newValue is larger than the old value
-            // First add until the old memory region
-            // and insert afterwards the rest
             else
             {
+                // Replace the old slice and append the extra slice
                 newValue[..oldValue.Length].CopyTo(buffer[index..]);
                 Insert(index + oldValue.Length, newValue[oldValue.Length..]);
             }
+
+            index += newValue.Length;
+            remainingChars -= oldValue.Length;
         }
     }
 
@@ -153,7 +145,7 @@ public void Replace(scoped ReadOnlySpan<char> oldValue, scoped ReadOnlySpan<char
     /// </remarks>
     /// /// <typeparam name="T">Any type.</typeparam>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ReplaceGeneric<T>(ReadOnlySpan<char> oldValue, T newValue)
+    public void ReplaceGeneric<T>(scoped ReadOnlySpan<char> oldValue, T newValue)
         => ReplaceGeneric(oldValue, newValue, 0, Length);
 
     /// <summary>
@@ -164,24 +156,23 @@ public void ReplaceGeneric<T>(ReadOnlySpan<char> oldValue, T newValue)
     /// <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 from type <see cref="ISpanFormattable"/> an optimized version is taken.
-    /// Otherwise the ToString method is called.
+    /// If <paramref name="newValue"/> is <see cref="ISpanFormattable"/>, <c>TryFormat</c> is used.
+    /// Otherwise, <c>ToString</c> is used.
     /// </remarks>
     /// /// <typeparam name="T">Any type.</typeparam>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ReplaceGeneric<T>(ReadOnlySpan<char> oldValue, T newValue, int startIndex, int count)
+    public void ReplaceGeneric<T>(scoped ReadOnlySpan<char> oldValue, T newValue, int startIndex, int count)
     {
         if (newValue is ISpanFormattable spanFormattable)
         {
-            Span<char> tempBuffer = stackalloc char[24];
+            Span<char> tempBuffer = stackalloc char[128];
             if (spanFormattable.TryFormat(tempBuffer, out var written, default, null))
             {
                 Replace(oldValue, tempBuffer[..written], startIndex, count);
+                return;
             }
         }
-        else
-        {
-            Replace(oldValue, (newValue?.ToString() ?? string.Empty).AsSpan(), startIndex, count);
-        }
+
+        Replace(oldValue, newValue?.ToString() ?? string.Empty, startIndex, count);
     }
 }