public bool?GetBoolean(int index)
{
if (IsNull(index))
{
return(null);
}
return(BitUtility.GetBit(Values, index));
}
/// <summary>
/// Set the bit at a particular index to 1.
/// </summary>
/// <param name="index">Index of bit to set.</param>
/// <returns>Returns the builder (for fluent-style composition).</returns>
public BitmapBuilder Set(int index)
{
CheckIndex(index);
bool priorValue = BitUtility.GetBit(Span, index);
SetBitCount += priorValue ? 0 : 1;
BitUtility.SetBit(Span, index);
return(this);
}
public Builder Reserve(int capacity)
{
if (capacity < 0)
{
throw new ArgumentOutOfRangeException(nameof(capacity));
}
ValueBuffer.Reserve(BitUtility.ByteCount(capacity));
return(this);
}
/// <summary>
/// Set the bit at a particular index to a given value.
/// </summary>
/// <param name="index">Index of bit to set/unset.</param>
/// <param name="value">Value of bit.</param>
/// <returns>Returns the builder (for fluent-style composition).</returns>
public BitmapBuilder Set(int index, bool value)
{
CheckIndex(index);
bool priorValue = BitUtility.GetBit(Span, index);
SetBitCount -= priorValue ? 1 : 0;
SetBitCount += value ? 1 : 0;
BitUtility.SetBit(Span, index, value);
return(this);
}
/// <summary>
/// Resize the buffer to a given size.
/// </summary>
/// <remarks>
/// Note that if the required capacity is larger than the current length of the populated buffer so far,
/// the buffer's contents in the new, expanded region are undefined.
/// </remarks>
/// <remarks>
/// Note that if the required capacity is smaller than the current length of the populated buffer so far,
/// the buffer will be truncated and items at the end of the buffer will be lost.
/// </remarks>
/// <remarks>
/// Note also that a negative capacity will result in the buffer being resized to zero.
/// </remarks>
/// <param name="capacity">Number of bits of required capacity.</param>
/// <returns>Returns the builder (for fluent-style composition).</returns>
public BitmapBuilder Resize(int capacity)
{
capacity = capacity < 0 ? 0 : capacity;
EnsureCapacity(capacity);
Length = capacity;
SetBitCount = BitUtility.CountBits(Span, 0, Length);
return(this);
}
public Builder Resize(int length)
{
if (length < 0)
{
throw new ArgumentOutOfRangeException(nameof(length));
}
ValueBuffer.Resize(BitUtility.ByteCount(length));
Length = length;
return(this);
}
public Builder Append(bool value)
{
if (Length % 8 == 0)
{
// append a new byte to the buffer when needed
ValueBuffer.Append(0);
}
BitUtility.SetBit(ValueBuffer.Span, Length, value);
Length++;
return(this);
}
public Builder Swap(int i, int j)
{
CheckIndex(i);
CheckIndex(j);
var bi = BitUtility.GetBit(ValueBuffer.Span, i);
var bj = BitUtility.GetBit(ValueBuffer.Span, j);
BitUtility.SetBit(ValueBuffer.Span, i, bj);
BitUtility.SetBit(ValueBuffer.Span, j, bi);
return(this);
}
/// <summary>
/// Swap the bits at two given indices.
/// </summary>
/// <param name="i">First index.</param>
/// <param name="j">Second index.</param>
/// <returns>Returns the builder (for fluent-style composition).</returns>
public BitmapBuilder Swap(int i, int j)
{
CheckIndex(i);
CheckIndex(j);
bool bi = BitUtility.GetBit(Span, i);
bool bj = BitUtility.GetBit(Span, j);
BitUtility.SetBit(Span, i, bj);
BitUtility.SetBit(Span, j, bi);
return(this);
}
public bool?GetBoolean(int index)
{
if (IsNull(index))
{
return(null);
}
var span = GetSpan();
return(BitUtility.GetBit(span, index));
}
/// <summary>
/// Append a single bit.
/// </summary>
/// <param name="value">Bit to append.</param>
/// <returns>Returns the builder (for fluent-style composition).</returns>
public BitmapBuilder Append(bool value)
{
if (Length % 8 == 0)
{
// Append a new byte to the buffer when needed.
EnsureAdditionalCapacity(1);
}
BitUtility.SetBit(Span, Length, value);
Length++;
SetBitCount += value ? 1 : 0;
return(this);
}
/// <summary>
/// Resize the buffer to a given size.
/// </summary>
/// <remarks>
/// Note that if the required capacity is larger than the current length of the populated buffer so far,
/// the buffer's contents in the new, expanded region are undefined.
/// </remarks>
/// <remarks>
/// Note that if the required capacity is smaller than the current length of the populated buffer so far,
/// the buffer will be truncated and items at the end of the buffer will be lost.
/// </remarks>
/// <param name="capacity">Number of bits of required capacity.</param>
/// <returns>Returns the builder (for fluent-style composition).</returns>
public BitmapBuilder Resize(int capacity)
{
if (capacity < 0)
{
throw new ArgumentOutOfRangeException(nameof(capacity), "Capacity must be non-negative");
}
EnsureCapacity(capacity);
Length = capacity;
SetBitCount = BitUtility.CountBits(Span, 0, Length);
return(this);
}
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);
}
private ArrowBuffer ConcatenateBitmapBuffer(int bufferIndex)
{
var builder = new ArrowBuffer.BitmapBuilder(_totalLength);
foreach (ArrayData arrayData in _arrayDataList)
{
int length = arrayData.Length;
ReadOnlySpan <byte> span = arrayData.Buffers[bufferIndex].Span;
for (int i = 0; i < length; i++)
{
builder.Append(span.IsEmpty || BitUtility.GetBit(span, i));
}
}
return(builder.Build(_allocator));
}
public void Set(int index)
{
BitUtility.SetBit(
Buffer.GetSpan <byte>(), index);
}
public bool IsValid(int index) => NullCount == 0 || NullBitmapBuffer.IsEmpty || BitUtility.GetBit(NullBitmapBuffer.Span, index);
/// <summary>
/// Creates an instance of the <see cref="BitmapBuilder"/> class.
/// </summary>
/// <param name="capacity">Number of bits of initial capacity to reserve.</param>
public BitmapBuilder(int capacity = DefaultBitCapacity)
{
Memory = new byte[BitUtility.ByteCount(capacity)];
Capacity = capacity;
}
public Builder Toggle(int index)
{
CheckIndex(index);
BitUtility.ToggleBit(ValueBuffer.Span, index);
return(this);
}
public Builder Set(int index, bool value)
{
CheckIndex(index);
BitUtility.SetBit(ValueBuffer.Span, index, value);
return(this);
}
public bool GetBoolean(int index)
{
return(BitUtility.GetBit(Values, index));
}
public void Clear(int index)
{
BitUtility.ClearBit(
Buffer.GetSpan <byte>(), index);
}
public bool?GetValue(int index)
{
return(IsNull(index)
? (bool?)null
: BitUtility.GetBit(ValueBuffer.Span, index + Offset));
}
public bool IsSet(int index)
{
return(BitUtility.GetBit(
Buffer.GetSpan <byte>(), index));
}