netcore/System.Private.CoreLib/shared/System/Text/ValueStringBuilder.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 #nullable enable
   6 using System.Buffers;
   7 using System.Diagnostics;
   8 using System.Runtime.CompilerServices;
   9 using System.Runtime.InteropServices;
  10
  11 namespace System.Text
  12 {
  13     internal ref partial struct ValueStringBuilder
  14     {
  15         private char[]? _arrayToReturnToPool;
  16         private Span<char> _chars;
  17         private int _pos;
  18
  19         public ValueStringBuilder(Span<char> initialBuffer)
  20         {
  21             _arrayToReturnToPool = null;
  22             _chars = initialBuffer;
  23             _pos = 0;
  24         }
  25
  26         public ValueStringBuilder(int initialCapacity)
  27         {
  28             _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);
  29             _chars = _arrayToReturnToPool;
  30             _pos = 0;
  31         }
  32
  33         public int Length
  34         {
  35             get => _pos;
  36             set
  37             {
  38                 Debug.Assert(value >= 0);
  39                 Debug.Assert(value <= _chars.Length);
  40                 _pos = value;
  41             }
  42         }
  43
  44         public int Capacity => _chars.Length;
  45
  46         public void EnsureCapacity(int capacity)
  47         {
  48             if (capacity > _chars.Length)
  49                 Grow(capacity - _pos);
  50         }
  51
  52         /// <summary>
  53         /// Get a pinnable reference to the builder.
  54         /// Does not ensure there is a null char after <see cref="Length"/>
  55         /// This overload is pattern matched in the C# 7.3+ compiler so you can omit
  56         /// the explicit method call, and write eg "fixed (char* c = builder)"
  57         /// </summary>
  58         public ref char GetPinnableReference()
  59         {
  60             return ref MemoryMarshal.GetReference(_chars);
  61         }
  62
  63         /// <summary>
  64         /// Get a pinnable reference to the builder.
  65         /// </summary>
  66         /// <param name="terminate">Ensures that the builder has a null char after <see cref="Length"/></param>
  67         public ref char GetPinnableReference(bool terminate)
  68         {
  69             if (terminate)
  70             {
  71                 EnsureCapacity(Length + 1);
  72                 _chars[Length] = '\0';
  73             }
  74             return ref MemoryMarshal.GetReference(_chars);
  75         }
  76
  77         public ref char this[int index]
  78         {
  79             get
  80             {
  81                 Debug.Assert(index < _pos);
  82                 return ref _chars[index];
  83             }
  84         }
  85
  86         public override string ToString()
  87         {
  88             string s = _chars.Slice(0, _pos).ToString();
  89             Dispose();
  90             return s;
  91         }
  92
  93         /// <summary>Returns the underlying storage of the builder.</summary>
  94         public Span<char> RawChars => _chars;
  95
  96         /// <summary>
  97         /// Returns a span around the contents of the builder.
  98         /// </summary>
  99         /// <param name="terminate">Ensures that the builder has a null char after <see cref="Length"/></param>
 100         public ReadOnlySpan<char> AsSpan(bool terminate)
 101         {
 102             if (terminate)
 103             {
 104                 EnsureCapacity(Length + 1);
 105                 _chars[Length] = '\0';
 106             }
 107             return _chars.Slice(0, _pos);
 108         }
 109
 110         public ReadOnlySpan<char> AsSpan() => _chars.Slice(0, _pos);
 111         public ReadOnlySpan<char> AsSpan(int start) => _chars.Slice(start, _pos - start);
 112         public ReadOnlySpan<char> AsSpan(int start, int length) => _chars.Slice(start, length);
 113
 114         public bool TryCopyTo(Span<char> destination, out int charsWritten)
 115         {
 116             if (_chars.Slice(0, _pos).TryCopyTo(destination))
 117             {
 118                 charsWritten = _pos;
 119                 Dispose();
 120                 return true;
 121             }
 122             else
 123             {
 124                 charsWritten = 0;
 125                 Dispose();
 126                 return false;
 127             }
 128         }
 129
 130         public void Insert(int index, char value, int count)
 131         {
 132             if (_pos > _chars.Length - count)
 133             {
 134                 Grow(count);
 135             }
 136
 137             int remaining = _pos - index;
 138             _chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count));
 139             _chars.Slice(index, count).Fill(value);
 140             _pos += count;
 141         }
 142
 143         public void Insert(int index, string? s)
 144         {
 145             if (s == null)
 146             {
 147                 return;
 148             }
 149
 150             int count = s.Length;
 151
 152             if (_pos > (_chars.Length - count))
 153             {
 154                 Grow(count);
 155             }
 156
 157             int remaining = _pos - index;
 158             _chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count));
 159             s.AsSpan().CopyTo(_chars.Slice(index));
 160             _pos += count;
 161         }
 162
 163         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 164         public void Append(char c)
 165         {
 166             int pos = _pos;
 167             if ((uint)pos < (uint)_chars.Length)
 168             {
 169                 _chars[pos] = c;
 170                 _pos = pos + 1;
 171             }
 172             else
 173             {
 174                 GrowAndAppend(c);
 175             }
 176         }
 177
 178         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 179         public void Append(string? s)
 180         {
 181             if (s == null)
 182             {
 183                 return;
 184             }
 185
 186             int pos = _pos;
 187             if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc.
 188             {
 189                 _chars[pos] = s[0];
 190                 _pos = pos + 1;
 191             }
 192             else
 193             {
 194                 AppendSlow(s);
 195             }
 196         }
 197
 198         private void AppendSlow(string s)
 199         {
 200             int pos = _pos;
 201             if (pos > _chars.Length - s.Length)
 202             {
 203                 Grow(s.Length);
 204             }
 205
 206             s.AsSpan().CopyTo(_chars.Slice(pos));
 207             _pos += s.Length;
 208         }
 209
 210         public void Append(char c, int count)
 211         {
 212             if (_pos > _chars.Length - count)
 213             {
 214                 Grow(count);
 215             }
 216
 217             Span<char> dst = _chars.Slice(_pos, count);
 218             for (int i = 0; i < dst.Length; i++)
 219             {
 220                 dst[i] = c;
 221             }
 222             _pos += count;
 223         }
 224
 225         public unsafe void Append(char* value, int length)
 226         {
 227             int pos = _pos;
 228             if (pos > _chars.Length - length)
 229             {
 230                 Grow(length);
 231             }
 232
 233             Span<char> dst = _chars.Slice(_pos, length);
 234             for (int i = 0; i < dst.Length; i++)
 235             {
 236                 dst[i] = *value++;
 237             }
 238             _pos += length;
 239         }
 240
 241         public void Append(ReadOnlySpan<char> value)
 242         {
 243             int pos = _pos;
 244             if (pos > _chars.Length - value.Length)
 245             {
 246                 Grow(value.Length);
 247             }
 248
 249             value.CopyTo(_chars.Slice(_pos));
 250             _pos += value.Length;
 251         }
 252
 253         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 254         public Span<char> AppendSpan(int length)
 255         {
 256             int origPos = _pos;
 257             if (origPos > _chars.Length - length)
 258             {
 259                 Grow(length);
 260             }
 261
 262             _pos = origPos + length;
 263             return _chars.Slice(origPos, length);
 264         }
 265
 266         [MethodImpl(MethodImplOptions.NoInlining)]
 267         private void GrowAndAppend(char c)
 268         {
 269             Grow(1);
 270             Append(c);
 271         }
 272
 273         /// <summary>
 274         /// Resize the internal buffer either by doubling current buffer size or
 275         /// by adding <paramref name="additionalCapacityBeyondPos"/> to
 276         /// <see cref="_pos"/> whichever is greater.
 277         /// </summary>
 278         /// <param name="additionalCapacityBeyondPos">
 279         /// Number of chars requested beyond current position.
 280         /// </param>
 281         [MethodImpl(MethodImplOptions.NoInlining)]
 282         private void Grow(int additionalCapacityBeyondPos)
 283         {
 284             Debug.Assert(additionalCapacityBeyondPos > 0);
 285             Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed.");
 286
 287             char[] poolArray = ArrayPool<char>.Shared.Rent(Math.Max(_pos + additionalCapacityBeyondPos, _chars.Length * 2));
 288
 289             _chars.Slice(0, _pos).CopyTo(poolArray);
 290
 291             char[]? toReturn = _arrayToReturnToPool;
 292             _chars = _arrayToReturnToPool = poolArray;
 293             if (toReturn != null)
 294             {
 295                 ArrayPool<char>.Shared.Return(toReturn);
 296             }
 297         }
 298
 299         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 300         public void Dispose()
 301         {
 302             char[]? toReturn = _arrayToReturnToPool;
 303             this = default; // for safety, to avoid using pooled array if this instance is erroneously appended to again
 304             if (toReturn != null)
 305             {
 306                 ArrayPool<char>.Shared.Return(toReturn);
 307             }
 308         }
 309     }
 310 }