/// <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);
}
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);
}
public BooleanArray Build(MemoryAllocator allocator = default)
{
var validityBuffer = NullCount > 0
? ValidityBuffer.Build(allocator)
: ArrowBuffer.Empty;
return(new BooleanArray(
ValueBuffer.Build(allocator), validityBuffer,
Length, NullCount, 0));
}
public Builder Reserve(int capacity)
{
if (capacity < 0)
{
throw new ArgumentOutOfRangeException(nameof(capacity));
}
ValueBuffer.Reserve(BitUtility.ByteCount(capacity));
ValidityBuffer.Reserve(BitUtility.ByteCount(capacity));
return(this);
}
/// <summary>
/// Clear all contents appended so far.
/// </summary>
/// <returns>Returns the builder (for fluent-style composition).</returns>
public TBuilder Clear()
{
ValueOffsets.Clear();
ValueBuffer.Clear();
ValidityBuffer.Clear();
// Always write the first offset before anything has been written.
Offset = 0;
ValueOffsets.Append(Offset);
return(Instance);
}
public Builder Resize(int length)
{
if (length < 0)
{
throw new ArgumentOutOfRangeException(nameof(length));
}
ValueBuffer.Resize(BitUtility.ByteCount(length));
ValidityBuffer.Resize(BitUtility.ByteCount(length));
Length = length;
return(this);
}
public TArray Build(MemoryAllocator allocator = default)
{
ValueOffsets.Append(Offset);
ArrowBuffer validityBuffer = NullCount > 0
? ValidityBuffer.Build(allocator).ValueBuffer
: ArrowBuffer.Empty;
var data = new ArrayData(DataType, ValueOffsets.Length - 1, NullCount, 0,
new[] { validityBuffer, ValueOffsets.Build(allocator), ValueBuffer.Build(allocator) });
return(Build(data));
}
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);
}
/// <summary>
/// Build an Arrow array from the appended contents so far.
/// </summary>
/// <param name="allocator">Optional memory allocator.</param>
/// <returns>Returns an array of type <typeparamref name="TArray"/>.</returns>
public TArray Build(MemoryAllocator allocator = default)
{
var bufs = new[]
{
NullCount > 0 ? ValidityBuffer.Build(allocator) : ArrowBuffer.Empty,
ValueOffsets.Build(allocator),
ValueBuffer.Build(allocator),
};
var data = new ArrayData(
DataType,
length: Length,
NullCount,
offset: 0,
bufs);
return(Build(data));
}
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);
}
public TBuilder AppendNull()
{
ValueOffsets.Append(Offset);
ValidityBuffer.Append(false);
return(Instance);
}
