Function ExecArrayCaseWhen

cpp/src/arrow/compute/kernels/scalar_if_else.cc:1571–1688

// given helper functions to copy data from a source array to a target array
template <typename Type>
Status ExecArrayCaseWhen(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
  const ArraySpan& conds_array = batch[0].array;
  if (conds_array.GetNullCount() > 0) {
    return Status::Invalid(
        "cond struct must not be a null scalar or "
        "have top-level nulls");
  }
  ArraySpan* output = out->array_span_mutable();
  const int64_t out_offset = output->offset;
  const auto num_value_args = batch.values.size() - 1;
  const bool have_else_arg =
      static_cast<size_t>(conds_array.type->num_fields()) < num_value_args;
  uint8_t* out_valid = output->buffers[0].data;
  uint8_t* out_values = output->buffers[1].data;

  if (have_else_arg) {
    // Copy 'else' value into output
    CopyValues<Type>(batch.values.back(), /*in_offset=*/0, batch.length, out_valid,
                     out_values, out_offset);
  } else {
    // There's no 'else' argument, so we should have an all-null validity bitmap
    bit_util::SetBitsTo(out_valid, out_offset, batch.length, false);
  }

  // Allocate a temporary bitmap to determine which elements still need setting.
  ARROW_ASSIGN_OR_RAISE(auto mask_buffer, ctx->AllocateBitmap(batch.length));
  uint8_t* mask = mask_buffer->mutable_data();
  std::memset(mask, 0xFF, mask_buffer->size());

  // Then iterate through each argument in turn and set elements.
  for (int i = 0; i < batch.num_values() - (have_else_arg ? 2 : 1); i++) {
    const ArraySpan& cond_array = conds_array.child_data[i];
    const int64_t cond_offset = conds_array.offset + cond_array.offset;
    const uint8_t* cond_values = cond_array.buffers[1].data;
    const ExecValue& value = batch[i + 1];
    int64_t offset = 0;

    if (cond_array.GetNullCount() == 0) {
      // If no valid buffer, visit mask & cond bitmap simultaneously
      BinaryBitBlockCounter counter(mask, /*start_offset=*/0, cond_values, cond_offset,
                                    batch.length);
      while (offset < batch.length) {
        const auto block = counter.NextAndWord();
        if (block.AllSet()) {
          CopyValues<Type>(value, offset, block.length, out_valid, out_values,
                           out_offset + offset);
          bit_util::SetBitsTo(mask, offset, block.length, false);
        } else if (block.popcount) {
          for (int64_t j = 0; j < block.length; ++j) {
            if (bit_util::GetBit(mask, offset + j) &&
                bit_util::GetBit(cond_values, cond_offset + offset + j)) {
              CopyValues<Type>(value, offset + j, /*length=*/1, out_valid, out_values,
                               out_offset + offset + j);
              bit_util::SetBitTo(mask, offset + j, false);
            }
          }
        }
        offset += block.length;