ValueStringBuilder.cs

Go to the documentation of this file.

using System.Buffers;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
 
namespace System.Text;
 
internal ref struct ValueStringBuilder
{
    private char[] _arrayToReturnToPool;
 
    private Span<char> _chars;
 
    private int _pos;
 
    public int Length
    {
        get
        {
            return _pos;
        }
        set
        {
            _pos = value;
        }
    }
 
    public ref char this[int index] => ref _chars[index];
 
    public Span<char> RawChars => _chars;
 
    public ValueStringBuilder(Span<char> initialBuffer)
    {
        _arrayToReturnToPool = null;
        _chars = initialBuffer;
        _pos = 0;
    }
 
    public ValueStringBuilder(int initialCapacity)
    {
        _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);
        _chars = _arrayToReturnToPool;
        _pos = 0;
    }
 
    public void EnsureCapacity(int capacity)
    {
        if ((uint)capacity > (uint)_chars.Length)
        {
            Grow(capacity - _pos);
        }
    }
 
    public ref char GetPinnableReference()
    {
        return ref MemoryMarshal.GetReference(_chars);
    }
 
    public override string ToString()
    {
        string result = _chars.Slice(0, _pos).ToString();
        Dispose();
        return result;
    }
 
    public ReadOnlySpan<char> AsSpan()
    {
        return _chars.Slice(0, _pos);
    }
 
    public ReadOnlySpan<char> AsSpan(int start)
    {
        return _chars.Slice(start, _pos - start);
    }
 
    public ReadOnlySpan<char> AsSpan(int start, int length)
    {
        return _chars.Slice(start, length);
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Append(char c)
    {
        int pos = _pos;
        if ((uint)pos < (uint)_chars.Length)
        {
            _chars[pos] = c;
            _pos = pos + 1;
        }
        else
        {
            GrowAndAppend(c);
        }
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Append(string s)
    {
        if (s != null)
        {
            int pos = _pos;
            if (s.Length == 1 && (uint)pos < (uint)_chars.Length)
            {
                _chars[pos] = s[0];
                _pos = pos + 1;
            }
            else
            {
                AppendSlow(s);
            }
        }
    }
 
    private void AppendSlow(string s)
    {
        int pos = _pos;
        if (pos > _chars.Length - s.Length)
        {
            Grow(s.Length);
        }
        s.CopyTo(_chars.Slice(pos));
        _pos += s.Length;
    }
 
    public unsafe void Append(char* value, int length)
    {
        int pos = _pos;
        if (pos > _chars.Length - length)
        {
            Grow(length);
        }
        Span<char> span = _chars.Slice(_pos, length);
        for (int i = 0; i < span.Length; i++)
        {
            span[i] = *(value++);
        }
        _pos += length;
    }
 
    public void Append(ReadOnlySpan<char> value)
    {
        int pos = _pos;
        if (pos > _chars.Length - value.Length)
        {
            Grow(value.Length);
        }
        value.CopyTo(_chars.Slice(_pos));
        _pos += value.Length;
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Span<char> AppendSpan(int length)
    {
        int pos = _pos;
        if (pos > _chars.Length - length)
        {
            Grow(length);
        }
        _pos = pos + length;
        return _chars.Slice(pos, length);
    }
 
    [MethodImpl(MethodImplOptions.NoInlining)]
    private void GrowAndAppend(char c)
    {
        Grow(1);
        Append(c);
    }
 
    [MethodImpl(MethodImplOptions.NoInlining)]
    private void Grow(int additionalCapacityBeyondPos)
    {
        char[] array = ArrayPool<char>.Shared.Rent((int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), (uint)(_chars.Length * 2)));
        _chars.Slice(0, _pos).CopyTo(array);
        char[] arrayToReturnToPool = _arrayToReturnToPool;
        _chars = (_arrayToReturnToPool = array);
        if (arrayToReturnToPool != null)
        {
            ArrayPool<char>.Shared.Return(arrayToReturnToPool);
        }
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Dispose()
    {
        char[] arrayToReturnToPool = _arrayToReturnToPool;
        this = default(System.Text.ValueStringBuilder);
        if (arrayToReturnToPool != null)
        {
            ArrayPool<char>.Shared.Return(arrayToReturnToPool);
        }
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Append(Rune rune)
    {
        int pos = _pos;
        Span<char> chars = _chars;
        if ((uint)(pos + 1) < (uint)chars.Length && (uint)pos < (uint)chars.Length)
        {
            if (rune.Value <= 65535)
            {
                chars[pos] = (char)rune.Value;
                _pos = pos + 1;
            }
            else
            {
                chars[pos] = (char)((long)rune.Value + 56557568L >> 10);
                chars[pos + 1] = (char)(((ulong)rune.Value & 0x3FFuL) + 56320);
                _pos = pos + 2;
            }
        }
        else
        {
            GrowAndAppend(rune);
        }
    }
 
    [MethodImpl(MethodImplOptions.NoInlining)]
    private void GrowAndAppend(Rune rune)
    {
        Grow(2);
        Append(rune);
    }
}