PipeReadBufferState
using System.Buffers;
using System.IO.Pipelines;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
namespace System.Text.Json.Serialization
{
[StructLayout(LayoutKind.Auto)]
internal struct PipeReadBufferState : IReadBufferState<PipeReadBufferState, PipeReader>, IDisposable
{
private readonly PipeReader _utf8Json;
private ReadOnlySequence<byte> _sequence;
private bool _isFinalBlock;
private bool _isFirstBlock;
private int _unsuccessfulReadBytes;
public bool IsFinalBlock {
[System.Runtime.CompilerServices.IsReadOnly]
get {
return _isFinalBlock;
}
}
public PipeReadBufferState(PipeReader utf8Json)
{
_isFinalBlock = false;
_unsuccessfulReadBytes = 0;
_sequence = ReadOnlySequence<byte>.Empty;
_isFirstBlock = true;
_utf8Json = utf8Json;
}
public void Advance(long bytesConsumed)
{
_unsuccessfulReadBytes = 0;
if (bytesConsumed == 0) {
long length = _sequence.Length;
_unsuccessfulReadBytes = (int)Math.Min(2147483647, length * 2);
}
_utf8Json.AdvanceTo(_sequence.Slice(bytesConsumed).Start, _sequence.End);
_sequence = ReadOnlySequence<byte>.Empty;
}
[AsyncStateMachine(typeof(<ReadAsync>d__9))]
public ValueTask<PipeReadBufferState> ReadAsync(PipeReader utf8Json, CancellationToken cancellationToken, bool fillBuffer = true)
{
<ReadAsync>d__9 stateMachine = default(<ReadAsync>d__9);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder<PipeReadBufferState>.Create();
stateMachine.<>4__this = this;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public void Read(PipeReader utf8Json)
{
throw new NotImplementedException();
}
public void GetReader(JsonReaderState jsonReaderState, out Utf8JsonReader reader)
{
if (_sequence.IsSingleSegment)
reader = new Utf8JsonReader(_sequence.First.Span, IsFinalBlock, jsonReaderState);
else
reader = new Utf8JsonReader(_sequence, IsFinalBlock, jsonReaderState);
}
private void ProcessReadBytes()
{
if (_isFirstBlock) {
_isFirstBlock = false;
if (_sequence.Length > 0) {
ReadOnlyMemory<byte> first = _sequence.First;
int length = first.Length;
ReadOnlySpan<byte> utf8Bom = JsonConstants.Utf8Bom;
if (length >= utf8Bom.Length) {
first = _sequence.First;
if (first.Span.StartsWith(JsonConstants.Utf8Bom)) {
ref ReadOnlySequence<byte> sequence = ref _sequence;
utf8Bom = JsonConstants.Utf8Bom;
_sequence = sequence.Slice((byte)utf8Bom.Length);
}
} else {
SequencePosition position = _sequence.Start;
int num = 0;
ReadOnlySpan<byte> utf8Bom2;
while (true) {
int num2 = num;
utf8Bom = JsonConstants.Utf8Bom;
if (num2 >= utf8Bom.Length || !_sequence.TryGet(ref position, out ReadOnlyMemory<byte> memory, true))
break;
ReadOnlySpan<byte> span = memory.Span;
int num3 = 0;
while (num3 < span.Length) {
int num4 = num;
utf8Bom2 = JsonConstants.Utf8Bom;
if (num4 >= utf8Bom2.Length)
break;
byte num5 = span[num3];
utf8Bom = JsonConstants.Utf8Bom;
if (num5 != utf8Bom[num]) {
num = 0;
break;
}
num3++;
num++;
}
}
int num6 = num;
utf8Bom2 = JsonConstants.Utf8Bom;
if (num6 == utf8Bom2.Length) {
ref ReadOnlySequence<byte> sequence2 = ref _sequence;
utf8Bom2 = JsonConstants.Utf8Bom;
_sequence = sequence2.Slice(utf8Bom2.Length);
}
}
}
}
}
public void Dispose()
{
if (!_sequence.Equals(ReadOnlySequence<byte>.Empty)) {
_utf8Json.AdvanceTo(_sequence.Start);
_sequence = ReadOnlySequence<byte>.Empty;
}
}
}
}