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