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