public static void GetBytes(ref BufferWriter writer, double value)
{
var resultBuilder = StringBuilder.Create();
try
{
var doubleValue = new IeeeDouble(value);
if (doubleValue.IsSpecial())
{
if (!HandleSpecialValues(doubleValue, ref resultBuilder))
{
throw new InvalidOperationException("not support special double value:" + value);
}
}
else if (!ToShortestIeeeNumber(value, ref resultBuilder, DtoaMode.Shortest))
{
throw new InvalidOperationException("not support double value:" + value);
}
var resultBuilderLength = resultBuilder.Length;
var destination = writer.GetSpan(resultBuilderLength);
resultBuilder.ReadableSpan.CopyTo(destination);
writer.Advance(resultBuilderLength);
}
finally
{
resultBuilder.Dispose();
}
}
public void TrimAdd(int totalBytes, int blockSize, int trim)
{
var Random = new Random();
var Source = new byte[totalBytes];
Random.NextBytes(Source);
using var Writer = new BufferWriter <byte>(ArrayPool <byte> .Shared, 1);
var TotalTrimmed = 0;
for (var Index = 0; Index < totalBytes; Index += blockSize)
{
var NextBlockSize = Math.Min(blockSize, totalBytes - Index);
var Contents = Writer.GetSpan(NextBlockSize);
Source.AsSpan(Index, NextBlockSize).CopyTo(Contents);
Writer.Advance(NextBlockSize);
Writer.TrimStart(trim);
TotalTrimmed += trim;
}
Assert.AreEqual(totalBytes - TotalTrimmed, Writer.Length);
Assert.IsTrue(Writer.ToSequence().SequenceEqual(Source.AsSpan(TotalTrimmed)));
}
public void WriteTest()
{
using var writer = new BufferWriter <char>(1);
writer.Write('H');
Assert.Equal(1, writer.WrittenCount);
writer.Write('e');
Assert.Equal(2, writer.WrittenCount);
writer.Write("llo");
Assert.True(writer.GetWrittenSpan().SequenceEqual("Hello"));
writer.Clear();
Assert.Equal(0, writer.WrittenCount);
var span = writer.GetSpan();
"Word".AsSpan().CopyTo(span);
writer.Advance(4);
Assert.True(writer.GetWrittenSpan().SequenceEqual("Word"));
}
public void SingleByte(int totalBytes)
{
using var Writer = new BufferWriter <byte>(ExactPool <byte> .Shared);
for (var Index = 0; Index < totalBytes; Index++)
{
var Contents = Writer.GetSpan(1);
Contents[0] = 1;
Writer.Advance(1);
}
Assert.AreEqual(totalBytes, Writer.Length);
var Sequence = Writer.ToSequence();
Assert.AreEqual(totalBytes, Sequence.Length);
}
public void BlocksApproximate(int totalBytes, int blockSize)
{
using var Writer = new BufferWriter <byte>();
for (var Index = 0; Index < totalBytes; Index += blockSize)
{
var NextBlockSize = Math.Min(blockSize, totalBytes - Index);
var Contents = Writer.GetSpan(NextBlockSize);
Contents.Slice(0, NextBlockSize).Fill(1);
Writer.Advance(NextBlockSize);
}
Assert.AreEqual(totalBytes, Writer.Length);
var Sequence = Writer.ToSequence();
Assert.AreEqual(totalBytes, Sequence.Length);
}
public void BufferWriterCountsBytesCommitted()
{
BufferWriter <PipeWriter> writer = new BufferWriter <PipeWriter>(Pipe.Writer);
writer.Write(new byte[] { 1, 2, 3 });
Assert.Equal(0, writer.BytesCommitted);
writer.Commit();
Assert.Equal(3, writer.BytesCommitted);
writer.Ensure(10);
writer.Advance(10);
Assert.Equal(3, writer.BytesCommitted);
writer.Commit();
Assert.Equal(13, writer.BytesCommitted);
Pipe.Writer.FlushAsync().GetAwaiter().GetResult();
var readResult = Pipe.Reader.ReadAsync().GetAwaiter().GetResult();
// Consuming the buffer does not change BytesCommitted
Assert.Equal(13, readResult.Buffer.Length);
Assert.Equal(13, writer.BytesCommitted);
}
/// <summary>
/// Writes a null value.
/// </summary>
public void WriteNull()
{
var span = Writer.GetSpan(4);
span[0] = (byte)'n';
span[1] = (byte)'u';
span[2] = (byte)'l';
span[3] = (byte)'l';
Writer.Advance(4);
}
public void Advance(int count)
{
_bufferWriter.Advance(count);
}
