Method DecodeArrowDense

cpp/src/parquet/decoder.cc:1294–1349

 private:
  Status DecodeArrowDense(int num_values, int null_count, const uint8_t* valid_bits,
                          int64_t valid_bits_offset,
                          typename EncodingTraits<ByteArrayType>::Accumulator* out,
                          int* out_num_values) {
    constexpr int32_t kBufferSize = 1024;
    int32_t indices[kBufferSize];

    auto visit_binary_helper = [&](auto* helper) {
      const auto* dict_values = dictionary_->data_as<ByteArray>();
      const int values_to_decode = num_values - null_count;
      int values_decoded = 0;
      int num_indices = 0;
      int pos_indices = 0;

      auto visit_bit_run = [&](int64_t position, int64_t length, bool valid) {
        if (valid) {
          while (length > 0) {
            if (num_indices == pos_indices) {
              // Refill indices buffer
              const auto max_batch_size =
                  std::min<int32_t>(kBufferSize, values_to_decode - values_decoded);
              num_indices = idx_decoder_.GetBatch(indices, max_batch_size);
              if (ARROW_PREDICT_FALSE(num_indices < 1)) {
                return Status::Invalid("Invalid number of indices: ", num_indices);
              }
              pos_indices = 0;
            }
            const auto batch_size = std::min<int64_t>(num_indices - pos_indices, length);
            for (int64_t j = 0; j < batch_size; ++j) {
              const auto index = indices[pos_indices++];
              RETURN_NOT_OK(IndexInBounds(index));
              const auto& val = dict_values[index];
              RETURN_NOT_OK(helper->AppendValue(val.ptr, static_cast<int32_t>(val.len)));
            }
            values_decoded += static_cast<int32_t>(batch_size);
            length -= static_cast<int32_t>(batch_size);
          }
        } else {
          for (int64_t i = 0; i < length; ++i) {
            helper->UnsafeAppendNull();
          }
        }
        return Status::OK();
      };

      RETURN_NOT_OK(
          VisitBitRuns(valid_bits, valid_bits_offset, num_values, visit_bit_run));
      *out_num_values = values_decoded;
      return Status::OK();
    };
    // The `len_` in the ByteArrayDictDecoder is the total length of the
    // RLE/Bit-pack encoded data size, so, we cannot use `len_` to reserve
    // space for binary data.
    return DispatchArrowBinaryHelper<ByteArrayType>(
        out, num_values, /*estimated_data_length=*/{}, visit_binary_helper);
  }

  template <typename BuilderType>