Updating to newest release

Author: LinkDotNet Bot

CHANGELOG.md

@@ -6,6 +6,17 @@ All notable changes to **ValueStringBuilder** will be documented in this file. T
 
 ## [Unreleased]
 
+## [2.2.0] - 2025-01-25
+
+### Added
+
+- Added `TrimPrefix(ReadOnlySpan<char>, StringComparison)` (by yours truly (@Joy-less) in #226)
+- Added `TrimSuffix(ReadOnlySpan<char>, StringComparison)` (also by yours truly (@Joy-less) in #226)
+- Added `Insert(int, char)` overload (by yours truly (@Joy-less) in #225)
+- Added `Insert(int, Rune)` overload (again by yours truly (@Joy-less) in #225)
+- Added `Replace(Rune, Rune)` overload (see yours truly (@Joy-less) in #225)
+- Improved `Replace(scoped ReadOnlySpan<char>, scoped ReadOnlySpan<char>, int, int)` fallback (achieved by yours truly (@Joy-less) in #225)
+
 ## [2.1.0] - 2025-01-14
 
 ### Added
@@ -445,7 +456,8 @@ This release brings extensions to the `ValueStringBuilder` API. For `v1.0` the `
 
 - Initial release
 
-[unreleased]: https://github.com/linkdotnet/StringBuilder/compare/2.1.0...HEAD
+[unreleased]: https://github.com/linkdotnet/StringBuilder/compare/2.2.0...HEAD
+[2.2.0]: https://github.com/linkdotnet/StringBuilder/compare/2.1.0...2.2.0
 [2.1.0]: https://github.com/linkdotnet/StringBuilder/compare/2.0.0...2.1.0
 [2.0.0]: https://github.com/linkdotnet/StringBuilder/compare/1.22.0...2.0.0
 [1.22.0]: https://github.com/linkdotnet/StringBuilder/compare/1.21.1...1.22.0

Directory.Build.props

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 	<ItemGroup>
-      <PackageReference Include="SonarAnalyzer.CSharp" Version="10.4.0.108396">
+      <PackageReference Include="SonarAnalyzer.CSharp" Version="10.5.0.109200">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>

src/LinkDotNet.StringBuilder/IntegerSpanList.cs

@@ -31,15 +31,15 @@ public void Add(int value)
     {
         if (count >= buffer.Length)
         {
-            Grow();
+            EnsureCapacity();
         }
 
         buffer[count] = value;
         count++;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void Grow(int capacity = 0)
+    private void EnsureCapacity(int capacity = 0)
     {
         var currentSize = buffer.Length;
         var newSize = capacity > 0 ? capacity : currentSize * 2;

src/LinkDotNet.StringBuilder/LinkDotNet.StringBuilder.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
@@ -33,16 +33,16 @@
       </None>
     </ItemGroup>
 
-	<PropertyGroup Label="Analyzer settings">
-		<AnalysisMode>AllEnabledByDefault</AnalysisMode>
-		<EnableNETAnalyzers>true</EnableNETAnalyzers>
-		<AnalysisLevel>8</AnalysisLevel>
-		<EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
-		<PackageLicenseExpression>MIT</PackageLicenseExpression>
-	</PropertyGroup>
+    <PropertyGroup Label="Analyzer settings">
+        <AnalysisMode>AllEnabledByDefault</AnalysisMode>
+        <EnableNETAnalyzers>true</EnableNETAnalyzers>
+        <AnalysisLevel>8</AnalysisLevel>
+        <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Meziantou.Analyzer" Version="2.0.184">
+      <PackageReference Include="Meziantou.Analyzer" Version="2.0.186">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>

src/LinkDotNet.StringBuilder/ValueStringBuilder.Append.cs

@@ -20,7 +20,7 @@ public unsafe void Append(bool value)
 
         if (newSize > buffer.Length)
         {
-            Grow(newSize);
+            EnsureCapacity(newSize);
         }
 
         fixed (char* dest = &buffer[bufferPosition])
@@ -67,7 +67,7 @@ public void Append(scoped ReadOnlySpan<char> str)
         var newSize = str.Length + bufferPosition;
         if (newSize > buffer.Length)
         {
-            Grow(newSize);
+            EnsureCapacity(newSize);
         }
 
         ref var strRef = ref MemoryMarshal.GetReference(str);
@@ -111,7 +111,7 @@ public void Append(char value)
         var newSize = bufferPosition + 1;
         if (newSize > buffer.Length)
         {
-            Grow(newSize);
+            EnsureCapacity(newSize);
         }
 
         buffer[bufferPosition] = value;
@@ -126,14 +126,14 @@ public void Append(char value)
     public void Append(Rune value)
     {
         Span<char> valueChars = stackalloc char[2];
-        int valueCharsWritten = value.EncodeToUtf16(valueChars);
-        ReadOnlySpan<char> valueCharsReadOnly = valueChars[..valueCharsWritten];
+        var valueCharsWritten = value.EncodeToUtf16(valueChars);
+        ReadOnlySpan<char> valueCharsSlice = valueChars[..valueCharsWritten];
 
-        Append(valueCharsReadOnly);
+        Append(valueCharsSlice);
     }
 
     /// <summary>
-    /// Adds the default new line separator.
+    /// Appends <see cref="Environment.NewLine"/>.
     /// </summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void AppendLine()
@@ -142,7 +142,7 @@ public void AppendLine()
     }
 
     /// <summary>
-    /// Calls <see cref="Append(ReadOnlySpan{char})"/> and appends a newline.
+    /// Calls <see cref="Append(ReadOnlySpan{char})"/> and appends <see cref="Environment.NewLine"/>.
     /// </summary>
     /// <param name="str">String to be added to this builder.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -163,7 +163,7 @@ public Span<char> AppendSpan(int length)
         var origPos = bufferPosition;
         if (origPos > buffer.Length - length)
         {
-            Grow(length);
+            EnsureCapacity(length);
         }
 
         bufferPosition = origPos + length;
@@ -177,7 +177,7 @@ private void AppendSpanFormattable<T>(T value, ReadOnlySpan<char> format = defau
         var newSize = bufferSize + bufferPosition;
         if (newSize >= Capacity)
         {
-            Grow(newSize);
+            EnsureCapacity(newSize);
         }
 
         if (!value.TryFormat(buffer[bufferPosition..], out var written, format, null))

src/LinkDotNet.StringBuilder/ValueStringBuilder.EnsureCapacity.cs

@@ -0,0 +1,57 @@
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace LinkDotNet.StringBuilder;
+
+public ref partial struct ValueStringBuilder
+{
+    /// <summary>
+    /// Ensures the builder's buffer size is at least <paramref name="newCapacity"/>, renting a larger buffer if not.
+    /// </summary>
+    /// <param name="newCapacity">New capacity for the builder.</param>
+    /// <remarks>
+    /// If <see cref="Length"/> is already &gt;= <paramref name="newCapacity"/>, nothing is done.
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void EnsureCapacity(int newCapacity)
+    {
+        if (Length >= newCapacity)
+        {
+            return;
+        }
+
+        var newSize = FindSmallestPowerOf2Above(newCapacity);
+
+        var rented = ArrayPool<char>.Shared.Rent(newSize);
+
+        if (bufferPosition > 0)
+        {
+            ref var sourceRef = ref MemoryMarshal.GetReference(buffer);
+            ref var destinationRef = ref MemoryMarshal.GetReference(rented.AsSpan());
+
+            Unsafe.CopyBlock(
+                ref Unsafe.As<char, byte>(ref destinationRef),
+                ref Unsafe.As<char, byte>(ref sourceRef),
+                (uint)bufferPosition * sizeof(char));
+        }
+
+        if (arrayFromPool is not null)
+        {
+            ArrayPool<char>.Shared.Return(arrayFromPool);
+        }
+
+        buffer = rented;
+        arrayFromPool = rented;
+    }
+
+    /// <summary>
+    /// Finds the smallest power of 2 which is greater than or equal to <paramref name="minimum"/>.
+    /// </summary>
+    /// <param name="minimum">The value the result should be greater than or equal to.</param>
+    /// <returns>The smallest power of 2 >= <paramref name="minimum"/>.</returns>
+    private static int FindSmallestPowerOf2Above(int minimum)
+    {
+        return 1 << (int)Math.Ceiling(Math.Log2(minimum));
+    }
+}

src/LinkDotNet.StringBuilder/ValueStringBuilder.Insert.cs

@@ -1,4 +1,5 @@
 using System.Runtime.CompilerServices;
+using System.Text;
 
 namespace LinkDotNet.StringBuilder;
 
@@ -12,6 +13,29 @@ public ref partial struct ValueStringBuilder
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Insert(int index, bool value) => Insert(index, value.ToString());
 
+    /// <summary>
+    /// Insert the string representation of the character to the builder at the given index.
+    /// </summary>
+    /// <param name="index">Index where <paramref name="value"/> should be inserted.</param>
+    /// <param name="value">Character to insert into this builder.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Insert(int index, char value) => Insert(index, [value]);
+
+    /// <summary>
+    /// Insert the string representation of the rune to the builder at the given index.
+    /// </summary>
+    /// <param name="index">Index where <paramref name="value"/> should be inserted.</param>
+    /// <param name="value">Rune to insert into this builder.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Insert(int index, Rune value)
+    {
+        Span<char> valueChars = stackalloc char[2];
+        var valueCharsWritten = value.EncodeToUtf16(valueChars);
+        ReadOnlySpan<char> valueCharsSlice = valueChars[..valueCharsWritten];
+
+        Insert(index, valueCharsSlice);
+    }
+
     /// <summary>
     /// Insert the string representation of the char to the builder at the given index.
     /// </summary>
@@ -45,7 +69,7 @@ public void Insert(int index, scoped ReadOnlySpan<char> value)
         var newLength = bufferPosition + value.Length;
         if (newLength > buffer.Length)
         {
-            Grow(newLength);
+            EnsureCapacity(newLength);
         }
 
         bufferPosition = newLength;
@@ -79,7 +103,7 @@ private void InsertSpanFormattable<T>(int index, T value, scoped ReadOnlySpan<ch
             var newLength = bufferPosition + written;
             if (newLength > buffer.Length)
             {
-                Grow(newLength);
+                EnsureCapacity(newLength);
             }
 
             bufferPosition = newLength;

src/LinkDotNet.StringBuilder/ValueStringBuilder.Replace.cs

@@ -13,17 +13,6 @@ public ref partial struct ValueStringBuilder
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly void Replace(char oldValue, char newValue) => Replace(oldValue, newValue, 0, Length);
 
-    /// <summary>
-    /// Replaces all instances of one rune with another in this builder.
-    /// </summary>
-    /// <param name="oldValue">The rune to replace.</param>
-    /// <param name="newValue">The rune to replace <paramref name="oldValue"/> with.</param>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void Replace(Rune oldValue, Rune newValue)
-    {
-        Replace(oldValue, newValue, 0, Length);
-    }
-
     /// <summary>
     /// Replaces all instances of one character with another in this builder.
     /// </summary>
@@ -34,15 +23,8 @@ public void Replace(Rune oldValue, Rune newValue)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly void Replace(char oldValue, char newValue, int startIndex, int count)
     {
-        if (startIndex < 0)
-        {
-            throw new ArgumentOutOfRangeException(nameof(startIndex), "Start index can't be smaller than 0.");
-        }
-
-        if (count > bufferPosition)
-        {
-            throw new ArgumentOutOfRangeException(nameof(count), $"Count: {count} is bigger than the current size {bufferPosition}.");
-        }
+        ArgumentOutOfRangeException.ThrowIfLessThan(startIndex, 0);
+        ArgumentOutOfRangeException.ThrowIfGreaterThan(startIndex + count, Length);
 
         for (var i = startIndex; i < startIndex + count; i++)
         {
@@ -53,6 +35,14 @@ public readonly void Replace(char oldValue, char newValue, int startIndex, int c
         }
     }
 
+    /// <summary>
+    /// Replaces all instances of one rune with another in this builder.
+    /// </summary>
+    /// <param name="oldValue">The rune to replace.</param>
+    /// <param name="newValue">The rune to replace <paramref name="oldValue"/> with.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Replace(Rune oldValue, Rune newValue) => Replace(oldValue, newValue, 0, Length);
+
     /// <summary>
     /// Replaces all instances of one rune with another in this builder.
     /// </summary>
@@ -64,14 +54,14 @@ public readonly void Replace(char oldValue, char newValue, int startIndex, int c
     public void Replace(Rune oldValue, Rune newValue, int startIndex, int count)
     {
         Span<char> oldValueChars = stackalloc char[2];
-        int oldValueCharsWritten = oldValue.EncodeToUtf16(oldValueChars);
-        ReadOnlySpan<char> oldValueCharsReadOnly = oldValueChars[..oldValueCharsWritten];
+        var oldValueCharsWritten = oldValue.EncodeToUtf16(oldValueChars);
+        ReadOnlySpan<char> oldValueCharsSlice = oldValueChars[..oldValueCharsWritten];
 
         Span<char> newValueChars = stackalloc char[2];
-        int newValueCharsWritten = newValue.EncodeToUtf16(newValueChars);
-        ReadOnlySpan<char> newValueCharsReadOnly = newValueChars[..newValueCharsWritten];
+        var newValueCharsWritten = newValue.EncodeToUtf16(newValueChars);
+        ReadOnlySpan<char> newValueCharsSlice = newValueChars[..newValueCharsWritten];
 
-        Replace(oldValueCharsReadOnly, newValueCharsReadOnly, startIndex, count);
+        Replace(oldValueCharsSlice, newValueCharsSlice, startIndex, count);
     }
 
     /// <summary>
@@ -99,6 +89,9 @@ public void Replace(scoped ReadOnlySpan<char> oldValue, scoped ReadOnlySpan<char
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Replace(scoped ReadOnlySpan<char> oldValue, scoped ReadOnlySpan<char> newValue, int startIndex, int count)
     {
+        ArgumentOutOfRangeException.ThrowIfLessThan(startIndex, 0);
+        ArgumentOutOfRangeException.ThrowIfGreaterThan(startIndex + count, Length);
+
         var length = startIndex + count;
         var slice = buffer[startIndex..length];
 
@@ -188,7 +181,7 @@ public void ReplaceGeneric<T>(ReadOnlySpan<char> oldValue, T newValue, int start
         }
         else
         {
-            Replace(oldValue, (ReadOnlySpan<char>)newValue?.ToString(), startIndex, count);
+            Replace(oldValue, (newValue?.ToString() ?? string.Empty).AsSpan(), startIndex, count);
         }
     }
 }