private void HandleHeaders()
{
var options = Configuration.Options;
if (options.ReadHeader == ReadHeader.Never)
{
// can just use the discovered copy from source
ReadHeaders = ReadHeader.Never;
ColumnCount = Configuration.DeserializeColumns.Length;
TryMakeStateMachine();
return;
}
// should always have been initialized by now
var rowEndings = Utils.NonNullValue(RowEndings);
using (
var headerReader = new HeadersReader <T>(
StateMachine,
Configuration,
SharedCharacterLookup,
Inner,
Buffer,
rowEndings
)
)
{
var headers = headerReader.Read();
HandleHeadersReaderResult(headers);
}
}
internal void WriteEncoded(ReadOnlySpan <char> charSpan)
{
var escapedValueStartAndStop = Utils.NonNullValue(Configuration.Options.EscapedValueStartAndEnd);
// try and blit things in big chunks
var start = 0;
var end = Utils.FindChar(charSpan, start, escapedValueStartAndStop);
while (end != -1)
{
var escapeValueEscapeChar = Utils.NonNullValue(Configuration.Options.EscapedValueEscapeCharacter);
var len = end - start;
var toWrite = charSpan.Slice(start, len);
PlaceAllInStaging(toWrite);
PlaceCharInStaging(escapeValueEscapeChar);
start += len;
end = Utils.FindChar(charSpan, start + 1, escapedValueStartAndStop);
}
if (start != charSpan.Length)
{
var toWrite = charSpan.Slice(start);
PlaceAllInStaging(toWrite);
}
}
internal void WriteEncoded(ReadOnlySequence <char> head)
{
var escapedValueStartAndStop = Utils.NonNullValue(Configuration.Options.EscapedValueEscapeCharacter);
// start with whatever the escape is
PlaceCharInStaging(escapedValueStartAndStop);
foreach (var cur in head)
{
WriteEncoded(cur.Span);
}
// end with the escape
PlaceCharInStaging(escapedValueStartAndStop);
}
internal void WriteSingleSegment(ReadOnlySpan <char> charSpan)
{
if (!NeedsEncode(charSpan))
{
// most of the time we have no need to encode
// so just blit this write into the stream
PlaceAllInStaging(charSpan);
}
else
{
var options = Configuration.Options;
CheckCanEncode(charSpan, options);
var escapedValueStartAndStop = Utils.NonNullValue(options.EscapedValueStartAndEnd);
PlaceCharInStaging(escapedValueStartAndStop);
WriteEncoded(charSpan);
PlaceCharInStaging(escapedValueStartAndStop);
}
}
private void HandleHeaders()
{
var options = Configuration.Options;
ReadHeaders = options.ReadHeader;
var allowColumnsByName = options.ReadHeader == ReadHeader.Always;
using (var reader = new HeadersReader <object>(StateMachine, Configuration, SharedCharacterLookup, Inner, Buffer, Utils.NonNullValue(RowEndings)))
{
var(headers, isHeader, pushBack) = reader.Read();
ColumnCount = headers.Count;
if (ColumnCount == 0)
{
// rare, but possible if the file is empty or all comments or something like that
ColumnNames.Value = Array.Empty <string>();
}
else
{
string[] columnNamesValue = Array.Empty <string>();
if (allowColumnsByName)
{
columnNamesValue = new string[ColumnCount];
ColumnNames.Value = columnNamesValue;
using (var e = headers)
{
var ix = 0;
while (e.MoveNext())
{
var name = allowColumnsByName ? new string(e.Current.Span) : null;
if (name != null)
{
columnNamesValue[ix] = name;
}
ix++;
}
}
Interlocked.Increment(ref NameLookupReferenceCount);
NameLookup = NameLookup.Create(columnNamesValue, Configuration.MemoryPool);
}
RowBuilder.SetColumnOrder(Configuration.Options, headers);
}
Buffer.PushBackFromOutsideBuffer(pushBack);
}
TryMakeStateMachine();
}
internal override void WriteInner(dynamic row)
{
try
{
WriteHeadersAndEndRowIfNeeded(row);
var wholeRowContext = WriteContext.DiscoveringCells(Configuration.Options, RowNumber, Context);
var options = Configuration.Options;
var valueSeparator = Configuration.ValueSeparatorMemory.Span;
var cellValuesMem = Utils.GetCells(Configuration.DynamicMemoryPool, ref CellBuffer, options.TypeDescriber, in wholeRowContext, row as object);
var columnNamesValue = Utils.NonNullValue(ColumnNames);
Utils.ForceInOrder(columnNamesValue, ColumnNameSorter, cellValuesMem);
var cellValuesEnumerableSpan = cellValuesMem.Span;
var i = 0;
foreach (var cell in cellValuesEnumerableSpan)
{
var needsSeparator = i != 0;
if (needsSeparator)
{
PlaceAllInStaging(valueSeparator);
}
ColumnIdentifier ci;
if (i < columnNamesValue.Length)
{
var name = columnNamesValue.GetColumnAt(i);
ci = ColumnIdentifier.CreateInner(i, null, name);
}
else
{
ci = ColumnIdentifier.Create(i);
}
var ctx = WriteContext.WritingColumn(Configuration.Options, RowNumber, ci, Context);
var formatter = cell.Formatter;
var delProvider = (ICreatesCacheableDelegate <Formatter.DynamicFormatterDelegate>)formatter;
var del = delProvider.Guarantee(this);
var val = cell.Value as object;
if (!del(val, in ctx, Buffer))
{
Throw.SerializationException($"Could not write column {ci}, formatter {formatter} returned false");
}
ReadOnlySequence <char> res = default;
if (!Buffer.MakeSequence(ref res))
{
// nothing was written, so just move on
goto end;
}
WriteValue(res);
Buffer.Reset();
end:
i++;
}
RowNumber++;
}
catch (Exception e)
{
Throw.PoisonAndRethrow(this, e);
}
}
