public override Span <byte> AsSpan(int index, int length)
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(ManagedBufferPool));
}
return(new Span <byte>(_array, index, length));
}
public override Span <byte> AsSpan(int index, int length)
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(OwnedBuffer));
}
return(_array.AsSpan().Slice(index, length));
}
public override void Release()
{
if (!IsRetained)
{
BufferPrimitivesThrowHelper.ThrowInvalidOperationException();
}
Interlocked.Decrement(ref _referenceCount);
}
public override Span <T> AsSpan(int index, int length)
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(CustomBuffer));
}
return(new Span <T>(_array, index, length));
}
public virtual Span <T> AsSpan()
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(OwnedBuffer <T>));
}
return(AsSpan(0, Length));
}
public override void Retain()
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(ArrayPoolBuffer));
}
Interlocked.Increment(ref _referenceCount);
}
public override Span <T> AsSpan()
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(OwnedArray <T>));
}
return(new Span <T>(_array, 0, _array.Length));
}
public OwnedArray(T[] array)
{
if (array == null)
{
BufferPrimitivesThrowHelper.ThrowArgumentNullException(nameof(array));
}
_array = array;
}
public override void Retain()
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowInvalidOperationException();
}
Interlocked.Increment(ref _referenceCount);
}
protected internal override bool TryGetArray(out ArraySegment <T> arraySegment)
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(OwnedArray <T>));
}
arraySegment = new ArraySegment <T>(_array);
return(true);
}
protected override bool TryGetArray(out ArraySegment <T> buffer)
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(AutoDisposeBuffer <T>));
}
buffer = new ArraySegment <T>(_array);
return(true);
}
public Buffer <T> Slice(int start)
{
if ((uint)start > (uint)_length)
{
BufferPrimitivesThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
}
return(new Buffer <T>(_owner, _array, _index + start, _length - start));
}
public ReadOnlyBuffer <T> Slice(int start, int length)
{
if ((uint)start > (uint)_length || (uint)length > (uint)(_length - start))
{
BufferPrimitivesThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
}
return(new ReadOnlyBuffer <T>(_owner, _array, _index + start, length));
}
protected override bool TryGetArrayInternal(out ArraySegment <byte> buffer)
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(OwnedBuffer));
}
buffer = new ArraySegment <byte>(_array);
return(true);
}
protected internal override bool TryGetArrayInternal(out ArraySegment <T> buffer)
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(OwnerEmptyMemory <T>));
}
buffer = new ArraySegment <T>(s_empty);
return(true);
}
protected override bool TryGetArray(out ArraySegment <byte> arraySegment)
{
if (IsDisposed)
{
BufferPrimitivesThrowHelper.ThrowObjectDisposedException(nameof(ManagedBufferPool));
}
arraySegment = new ArraySegment <byte>(_array);
return(true);
}
public ReadOnlyBuffer(T[] array)
{
if (array == null)
{
BufferPrimitivesThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
}
_arrayOrOwnedBuffer = array;
_index = 0;
_length = array.Length;
}
public override bool Release()
{
int newRefCount = Interlocked.Decrement(ref _referenceCount);
if (newRefCount < 0)
{
BufferPrimitivesThrowHelper.ThrowInvalidOperationException();
}
if (newRefCount == 0)
{
OnNoReferences();
return(false);
}
return(true);
}
public Buffer(T[] array)
{
if (array == null)
{
BufferPrimitivesThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
}
if (default(T) == null && array.GetType() != typeof(T[]))
{
BufferPrimitivesThrowHelper.ThrowArrayTypeMismatchException(typeof(T));
}
_arrayOrOwnedBuffer = array;
_index = 0;
_length = array.Length;
}
public ReadOnlyBuffer(T[] array, int start, int length)
{
if (array == null)
{
BufferPrimitivesThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
}
if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
{
BufferPrimitivesThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
}
_arrayOrOwnedBuffer = array;
_index = start;
_length = length;
}
public ReadOnlyBuffer <T> Slice(int start, int length)
{
if ((uint)start > (uint)_length || (uint)length > (uint)(_length - start))
{
BufferPrimitivesThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
}
// There is no need to 'and' _index by the bit mask here
// since the constructor will set the highest order bit again anyway
if (_index < 0)
{
return(new ReadOnlyBuffer <T>(Unsafe.As <OwnedBuffer <T> >(_arrayOrOwnedBuffer), _index + start, length));
}
return(new ReadOnlyBuffer <T>(Unsafe.As <T[]>(_arrayOrOwnedBuffer), _index + start, length));
}
public Buffer(T[] array, int start, int length)
{
if (array == null)
{
BufferPrimitivesThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
}
if (default(T) == null && array.GetType() != typeof(T[]))
{
BufferPrimitivesThrowHelper.ThrowArrayTypeMismatchException(typeof(T));
}
if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
{
BufferPrimitivesThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
}
_arrayOrOwnedBuffer = array;
_index = start;
_length = length;
}
public ReadOnlyBuffer(T[] array, int start)
{
if (array == null)
{
BufferPrimitivesThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
}
int arrayLength = array.Length;
if ((uint)start > (uint)arrayLength)
{
BufferPrimitivesThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
}
_array = array;
_owner = null;
_index = start;
_length = arrayLength - start;
}
