Function PutListViewOffsets

cpp/src/arrow/array/concatenate.cc:273–335

template <typename offset_type>
Result<OffsetBufferOpOutcome> PutListViewOffsets(const ArrayData& input,
                                                 offset_type* sizes, const Buffer& src,
                                                 offset_type displacement,
                                                 offset_type* dst) {
  if (src.size() == 0) {
    return OffsetBufferOpOutcome::kOk;
  }
  const auto& validity_buffer = input.buffers[0];
  if (validity_buffer) {
    // Ensure that it is safe to access all the bits in the validity bitmap of input.
    RETURN_NOT_OK(internal::CheckSliceParams(/*size=*/8 * validity_buffer->size(),
                                             input.offset, input.length, "buffer"));
  }

  const auto offsets = src.data_as<offset_type>();
  DCHECK_EQ(static_cast<int64_t>(src.size() / sizeof(offset_type)), input.length);

  auto visit_not_null = [&](int64_t position) {
    if (sizes[position] > 0) {
      // NOTE: Concatenate can be called during IPC reads to append delta
      // dictionaries. Avoid UB on non-validated input by doing the addition in the
      // unsigned domain. (the result can later be validated using
      // Array::ValidateFull)
      const auto displaced_offset = SafeSignedAdd(offsets[position], displacement);
      // displaced_offset>=0 is guaranteed by RangeOfValuesUsed returning the
      // smallest offset of valid and non-empty list-views.
      DCHECK_GE(displaced_offset, 0);
      dst[position] = displaced_offset;
    } else {
      // Do nothing to leave the dst[position] as 0.
    }
  };

  const auto* validity = validity_buffer ? validity_buffer->data_as<uint8_t>() : nullptr;
  internal::OptionalBitBlockCounter bit_counter(validity, input.offset, input.length);
  int64_t position = 0;
  while (position < input.length) {
    internal::BitBlockCount block = bit_counter.NextBlock();
    if (block.AllSet()) {
      for (int64_t i = 0; i < block.length; ++i, ++position) {
        visit_not_null(position);
      }
    } else if (block.NoneSet()) {
      // NOTE: we don't have to do anything for the null entries regarding the
      // offsets as the buffer is initialized to 0 when it is allocated.

      // Zero-out the sizes of the null entries to ensure these sizes are not
      // greater than the new values length of the concatenated array.
      memset(sizes + position, 0, block.length * sizeof(offset_type));
      position += block.length;
    } else {
      for (int64_t i = 0; i < block.length; ++i, ++position) {
        if (bit_util::GetBit(validity, input.offset + position)) {
          visit_not_null(position);
        } else {
          // Zero-out the size at position.
          sizes[position] = 0;
        }