MemoryBufferWriter.cs

Go to the documentation of this file.

using System;
using System.Buffers;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
 
namespace IKVM.CoreLib.Buffers
{
 
    class MemoryBufferWriter<T> : IBufferWriter<T>
    {
 
        readonly Memory<T> _memory;
        int _index;
 
        public MemoryBufferWriter(Memory<T> memory)
        {
            _memory = memory;
        }
 
 
        public ReadOnlyMemory<T> WrittenMemory
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => _memory.Slice(0, _index);
        }
 
        public ReadOnlySpan<T> WrittenSpan
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => _memory.Slice(0, _index).Span;
        }
 
        public int WrittenCount
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => _index;
        }
 
        public int Capacity
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => _memory.Length;
        }
 
        public int FreeCapacity
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => _memory.Length - _index;
        }
 
        public void Clear()
        {
            _memory.Slice(0, _index).Span.Clear();
            _index = 0;
        }
 
        public void Advance(int count)
        {
            if (count < 0)
            {
                ThrowArgumentOutOfRangeExceptionForNegativeCount();
            }
 
            if (_index > _memory.Length - count)
            {
                ThrowArgumentExceptionForAdvancedTooFar();
            }
 
            _index += count;
        }
 
        public Memory<T> GetMemory(int sizeHint = 0)
        {
            ValidateSizeHint(sizeHint);
 
            return _memory.Slice(_index);
        }
 
        public Span<T> GetSpan(int sizeHint = 0)
        {
            ValidateSizeHint(sizeHint);
 
            return _memory.Slice(_index).Span;
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        void ValidateSizeHint(int sizeHint)
        {
            if (sizeHint < 0)
            {
                ThrowArgumentOutOfRangeExceptionForNegativeSizeHint();
            }
 
            if (sizeHint == 0)
                sizeHint = 1;
 
            if (sizeHint > FreeCapacity)
            {
                ThrowArgumentExceptionForCapacityExceeded();
            }
        }
 
        [Pure]
        public override string ToString()
        {
            // See comments in MemoryOwner<T> about this
            if (typeof(T) == typeof(char))
            {
                return _memory.Slice(0, _index).ToString();
            }
 
            // Same representation used in Span<T>
            return $"IKVM.CoreLib.Buffers.MemoryBufferWriter<{typeof(T)}>[{_index}]";
        }
 
        static void ThrowArgumentOutOfRangeExceptionForNegativeCount()
        {
            throw new ArgumentOutOfRangeException("count", "The count can't be a negative value");
        }
 
        static void ThrowArgumentOutOfRangeExceptionForNegativeSizeHint()
        {
            throw new ArgumentOutOfRangeException("sizeHint", "The size hint can't be a negative value");
        }
 
        static void ThrowArgumentExceptionForAdvancedTooFar()
        {
            throw new ArgumentException("The buffer writer has advanced too far");
        }
 
        static void ThrowArgumentExceptionForCapacityExceeded()
        {
            throw new ArgumentException("The buffer writer doesn't have enough capacity left");
        }
 
    }
 
}