internal (HeaderEnumerator Headers, bool IsHeader, Memory <char> PushBack) Read()
{
var madeProgress = true;
while (true)
{
var available = Buffer.Read(Inner.Value, madeProgress);
if (available == 0)
{
if (BuilderBacking.Length > 0)
{
var inEscapedValue = ReaderStateMachine.IsInEscapedValue(StateMachine.CurrentState);
PushPendingCharactersToValue(inEscapedValue);
}
break;
}
else
{
AddToPushback(Buffer.Buffer.Span.Slice(0, available));
}
if (AdvanceWork(available, out madeProgress))
{
break;
}
}
return(IsHeaderResult());
}
internal ValueTask <(HeaderEnumerator Headers, bool IsHeader, Memory <char> PushBack)> ReadAsync(CancellationToken cancellationToken)
{
var madeProgress = true;
while (true)
{
var availableTask = Buffer.ReadAsync(InnerAsync.Value, madeProgress, cancellationToken);
if (!availableTask.IsCompletedSuccessfully(this))
{
return(ReadAsync_ContinueAfterReadAsync(this, availableTask, cancellationToken));
}
var available = availableTask.Result;
if (available == 0)
{
if (BuilderBacking.Length > 0)
{
var inEscapedValue = ReaderStateMachine.IsInEscapedValue(StateMachine.CurrentState);
PushPendingCharactersToValue(inEscapedValue);
}
break;
}
else
{
AddToPushback(Buffer.Buffer.Span.Slice(0, available));
}
if (AdvanceWork(available, out madeProgress))
{
break;
}
}
return(new ValueTask <(HeaderEnumerator Headers, bool IsHeader, Memory <char> PushBack)>(IsHeaderResult()));
protected ReaderBase(BoundConfigurationBase <T> config, object context)
{
RowNumber = 0;
Configuration = config;
Context = context;
var bufferSize = config.ReadBufferSizeHint;
if (bufferSize == 0)
{
bufferSize = DEFAULT_BUFFER_SIZE;
}
Buffer = new BufferWithPushback(config.MemoryPool, bufferSize);
Partial = new Partial <T>(config.MemoryPool);
SharedCharacterLookup =
ReaderStateMachine.MakeCharacterLookup(
config.MemoryPool,
config.EscapedValueStartAndStop,
config.ValueSeparator,
config.EscapeValueEscapeChar,
config.CommentChar
);
}
internal HeadersReader(
BoundConfigurationBase <T> config,
ReaderStateMachine.CharacterLookup charLookup,
TextReader inner,
BufferWithPushback buffer
)
{
MemoryPool = config.MemoryPool;
BufferSizeHint = config.ReadBufferSizeHint;
Columns = config.DeserializeColumns;
Inner = inner;
StateMachine =
new ReaderStateMachine(
charLookup,
config.EscapedValueStartAndStop,
config.EscapeValueEscapeChar,
config.RowEnding,
ReadHeaders.Never
);
Buffer = buffer;
HeaderCount = 0;
PushBackLength = 0;
}
private RowEndingDetector(ReaderStateMachine stateMachine, Options options, MemoryPool <char> memPool, CharacterLookup charLookup, IReaderAdapter?inner, IAsyncReaderAdapter?innerAsync, ReadOnlyMemory <char> valueSeparatorMemory)
{
Inner.SetAllowNull(inner);
InnerAsync.SetAllowNull(innerAsync);
State = stateMachine;
stateMachine.Initialize(
charLookup,
options.EscapedValueStartAndEnd,
options.EscapedValueEscapeCharacter,
internal HeadersReader(
ReaderStateMachine stateMachine,
BoundConfigurationBase <T> config,
CharacterLookup charLookup,
IAsyncReaderAdapter inner,
BufferWithPushback buffer,
ReadRowEnding rowEndingOverride
)
: this(stateMachine, config, charLookup, null, inner, buffer, rowEndingOverride)
{
}
private HeadersReader(
ReaderStateMachine stateMachine,
BoundConfigurationBase <T> config,
CharacterLookup charLookup,
IReaderAdapter?inner,
IAsyncReaderAdapter?innerAsync,
BufferWithPushback buffer,
ReadRowEnding rowEndingOverride
)
{
LogHelper.StateTransition_NewHeadersReader();
Configuration = config;
Inner.SetAllowNull(inner);
InnerAsync.SetAllowNull(innerAsync);
var options = Configuration.Options;
MemoryPool = Configuration.MemoryPool;
BufferSizeHint = options.ReadBufferSizeHint;
Columns = config.DeserializeColumns;
StateMachine = stateMachine;
stateMachine.Initialize(
charLookup,
options.EscapedValueStartAndEnd,
options.EscapedValueEscapeCharacter,
rowEndingOverride, // this can be something OTHER than what was provided, due to RowEnding.Detect
ReadHeader.Never,
false,
options.WhitespaceTreatment.HasFlag(WhitespaceTreatments.TrimBeforeValues),
options.WhitespaceTreatment.HasFlag(WhitespaceTreatments.TrimAfterValues)
);
Buffer = buffer;
HeaderCount = 0;
PushBackLength = 0;
WhitespaceTreatment = options.WhitespaceTreatment;
}
protected ReaderBase(BoundConfigurationBase <T> config, object?context, IRowConstructor <T> rowBuilder, ExtraColumnTreatment extraTreatment)
{
RowNumber = 0;
Configuration = config;
Context = context;
var options = config.Options;
var bufferSize = options.ReadBufferSizeHint;
if (bufferSize == 0)
{
bufferSize = Utils.DEFAULT_BUFFER_SIZE;
}
// always need to be able to store a whole value separator "character"
var bufferMinSize = config.ValueSeparatorMemory.Length * 2;
if (bufferSize < bufferMinSize)
{
bufferSize = bufferMinSize;
}
var memPool = config.MemoryPool;
Buffer =
new BufferWithPushback(
memPool,
bufferSize
);
Partial = new Partial(memPool);
SharedCharacterLookup = CharacterLookup.MakeCharacterLookup(options, out _);
StateMachine = new ReaderStateMachine();
RowBuilder = rowBuilder;
ExtraColumnTreatment = extraTreatment;
}
internal RowEndingDetector(BoundConfigurationBase <T> config, ReaderStateMachine.CharacterLookup charLookup, TextReader inner)
{
Inner = inner;
State =
new ReaderStateMachine(
charLookup,
config.EscapedValueStartAndStop,
config.EscapeValueEscapeChar,
RowEndings.None,
ReadHeaders.Never
);
MemoryPool = config.MemoryPool;
BufferSizeHint = config.ReadBufferSizeHint;
if (BufferSizeHint == 0)
{
BufferSizeHint = ReaderBase <T> .DEFAULT_BUFFER_SIZE;
}
BufferOwner = MemoryPool.Rent(BufferSizeHint);
BufferStart = 0;
}
// wait for read to complete, then continue async
static async ValueTask <(HeaderEnumerator Headers, bool IsHeader, Memory <char> PushBack)> ReadAsync_ContinueAfterReadAsync(
HeadersReader <T> self,
ValueTask <int> waitFor,
CancellationToken cancellationToken)
{
bool madeProgress;
int available;
{
available = await ConfigureCancellableAwait(self, waitFor, cancellationToken);
}
// handle the in flight task
if (available == 0)
{
if (self.BuilderBacking.Length > 0)
{
var inEscapedValue = ReaderStateMachine.IsInEscapedValue(self.StateMachine.CurrentState);
self.PushPendingCharactersToValue(inEscapedValue);
}
return(self.IsHeaderResult());
}
else
{
self.AddToPushback(self.Buffer.Buffer.Span.Slice(0, available));
}
if (self.AdvanceWork(available, out madeProgress))
{
return(self.IsHeaderResult());
}
// go back into the loop
while (true)
{
var readTask = self.Buffer.ReadAsync(self.InnerAsync.Value, madeProgress, cancellationToken);
{
available = await ConfigureCancellableAwait(self, readTask, cancellationToken);
}
if (available == 0)
{
if (self.BuilderBacking.Length > 0)
{
var inEscapedValue = ReaderStateMachine.IsInEscapedValue(self.StateMachine.CurrentState);
self.PushPendingCharactersToValue(inEscapedValue);
}
break;
}
else
{
self.AddToPushback(self.Buffer.Buffer.Span.Slice(0, available));
}
if (self.AdvanceWork(available, out madeProgress))
{
break;
}
}
return(self.IsHeaderResult());
}
internal RowEndingDetector(ReaderStateMachine stateMachine, Options options, MemoryPool <char> memPool, CharacterLookup charLookup, IAsyncReaderAdapter innerAsync, ReadOnlyMemory <char> valueSeparatorMemory)
: this(stateMachine, options, memPool, charLookup, null, innerAsync, valueSeparatorMemory)
{
}