public void WriteValues <T>(Memory <T> memory)
{
var values = memory.Span;
var buffer = _bufferOwner.Memory;
var isPrimitive = PrimitiveTypes.Primitives.Contains(typeof(T));
var sizeOfElem = isPrimitive ? _sizing.SizeOf <T>() : 0;
if (!isPrimitive) // no size check bc it's checked on write calls from cache
{
foreach (var value in values)
{
BinaryCache <T> .WriteValue(this, value);
}
return;
}
var sizeOf = sizeOfElem * values.Length;
if (Remaining < sizeOf)
{
throw new ArgumentOutOfRangeException(nameof(Remaining),
$"Not enough bytes remaining in the buffer to write {typeof(T).Name} array. " +
$"Position : {Position}, Length : {Count}, Remaining : {Remaining}, SizeOf : {sizeOf}.");
}
var offset = Position;
for (var i = 0; i < values.Length; i++, offset += sizeOfElem)
{
var dst = buffer.Slice(offset, sizeOfElem);
PrimitiveBinaryCache <T> .WriteValue(dst.Span, values[i]);
}
Advance(sizeOf);
}
public void WriteValue <T>(T value)
{
var isPrimitive = PrimitiveTypes.Primitives.Contains(typeof(T));
var sizeOf = isPrimitive ? _sizing.SizeOf <T>() : _sizing.SizeOf(value);
if (Remaining < sizeOf)
{
throw new ArgumentOutOfRangeException(nameof(Remaining),
$"Not enough bytes remaining in the buffer to write {typeof(T).Name}. " +
$"Position : {Position}, Length : {Count}, Remaining : {Remaining}, SizeOf : {sizeOf}.");
}
if (!isPrimitive)
{
BinaryCache <T> .WriteValue(this, value);
return;
}
var dst = _bufferOwner.Memory.Slice(Position, sizeOf);
PrimitiveBinaryCache <T> .WriteValue(dst.Span, value);
Advance(sizeOf);
}
public T[] ReadValues <T>(int count)
{
if (count == 0)
{
return(Array.Empty <T>());
}
var value = new T[count];
if (!PrimitiveTypes.Primitives.Contains(typeof(T)))
{
for (var i = 0; i < count; i++)
{
value[i] = BinaryCache <T> .ReadValue(this);
}
return(value);
}
var sizeOfElem = PrimitiveBinaryCache <T> .SizeOf;
var sizeOfArray = sizeOfElem * count;
if (Remaining < sizeOfArray)
{
throw new ArgumentOutOfRangeException(nameof(Remaining),
$"Not enough bytes remaining in the buffer to read {typeof(T).Name} array with elements count : {count}. " +
$"Position : {Position}, Length : {Count}, Remaining : {Remaining}, SizeOf : {sizeOfArray}.");
}
var offset = Position;
for (var i = 0; i < count; i++, offset += sizeOfElem)
{
var src = _buffer.Slice(offset, sizeOfElem);
value[i] = PrimitiveBinaryCache <T> .ReadValue(src.Span);
}
Advance(sizeOfArray);
return(value);
}
public T ReadValue <T>()
{
if (!PrimitiveTypes.Primitives.Contains(typeof(T)))
{
return(BinaryCache <T> .ReadValue(this));
}
var sizeOfT = PrimitiveBinaryCache <T> .SizeOf;
if (Remaining < sizeOfT)
{
throw new ArgumentOutOfRangeException(nameof(Remaining),
$"Not enough bytes remaining in the buffer to read {typeof(T).Name}. " +
$"Position : {Position}, Length : {Count}, Remaining : {Remaining}, SizeOf : {sizeOfT}.");
}
var src = _buffer.Slice(Position, sizeOfT);
var value = PrimitiveBinaryCache <T> .ReadValue(src.Span);
Advance(sizeOfT);
return(value);
}
