public TBuilder AppendNull()
{
ValueOffsets.Append(Offset);
ValidityBuffer.Append(false);
NullCount++;
return(Instance);
}
public TBuilder Append(ReadOnlySpan <byte> span)
{
ValueOffsets.Append(Offset);
ValueBuffer.Append(span);
ValidityBuffer.Append(true);
Offset += span.Length;
return(Instance);
}
public TBuilder Append(byte value)
{
ValueOffsets.Append(Offset);
ValueBuffer.Append(value);
Offset++;
ValidityBuffer.Append(true);
return(Instance);
}
/// <summary>
/// Append a single null value to the array.
/// </summary>
/// <returns>Returns the builder (for fluent-style composition).</returns>
public TBuilder AppendNull()
{
// Do not add to the value buffer in the case of a null.
// Note that we do not need to increment the offset as a result.
ValidityBuffer.Append(false);
ValueOffsets.Append(Offset);
return(Instance);
}
private Builder NullableAppend(bool?value)
{
if (Length % 8 == 0)
{
// append a new byte to the buffer when needed
ValueBuffer.Append(0);
ValidityBuffer.Append(0);
}
BitUtility.SetBit(ValueBuffer.Span, Length, value.GetValueOrDefault());
BitUtility.SetBit(ValidityBuffer.Span, Length, value.HasValue);
NullCount += value.HasValue ? 0 : 1;
Length++;
return(this);
}
public TBuilder AppendRange(IEnumerable <byte> values)
{
if (values == null)
{
return(AppendNull());
}
int len = ValueBuffer.Length;
ValueBuffer.AppendRange(values);
int valOffset = ValueBuffer.Length - len;
ValueOffsets.Append(Offset);
Offset += valOffset;
ValidityBuffer.Append(true);
return(Instance);
}
public TBuilder AppendRange(IEnumerable <byte[]> values)
{
foreach (byte[] arr in values)
{
if (arr == null)
{
AppendNull();
continue;
}
int len = ValueBuffer.Length;
ValueOffsets.Append(Offset);
ValueBuffer.Append(arr);
ValidityBuffer.Append(true);
Offset += ValueBuffer.Length - len;
}
return(Instance);
}
/// <summary>
/// Append a value, consisting of an enumerable collection of bytes, to the array.
/// </summary>
/// <remarks>
/// Note that this method appends a single value, which may consist of arbitrarily many bytes. If multiple
/// values are to be added, use the <see cref="AppendRange(IEnumerable{byte})"/> method instead.
/// </remarks>
/// <param name="value">Enumerable collection of bytes to add.</param>
/// <returns>Returns the builder (for fluent-style composition).</returns>
public TBuilder Append(IEnumerable <byte> value)
{
if (value == null)
{
return(AppendNull());
}
// Note: by looking at the length of the value buffer before and after, we avoid having to iterate
// through the enumerable multiple times to get both length and contents.
int priorLength = ValueBuffer.Length;
ValueBuffer.AppendRange(value);
int valueLength = ValueBuffer.Length - priorLength;
Offset += valueLength;
ValidityBuffer.Append(true);
ValueOffsets.Append(Offset);
return(Instance);
}