Function MakeArrow

cpp/src/parquet/arrow/fuzz_encoding_internal.cc:172–388

template <typename DType>
struct TypedFuzzEncoding {
  static constexpr Type::type kType = DType::type_num;

  using c_type =
      std::conditional_t<kType == Type::BOOLEAN, BooleanSlot, typename DType::c_type>;
  using EncoderType = typename EncodingTraits<DType>::Encoder;
  using DecoderType = typename EncodingTraits<DType>::Decoder;
  using Accumulator = typename EncodingTraits<DType>::Accumulator;

  TypedFuzzEncoding(Encoding::type source_encoding, Encoding::type roundtrip_encoding,
                    const ColumnDescriptor* descr, int num_values,
                    std::span<const uint8_t> encoded_data)
      : source_encoding_(source_encoding),
        roundtrip_encoding_(roundtrip_encoding),
        descr_(descr),
        num_values_(num_values),
        encoded_data_(encoded_data) {}

  // Decoders of string-like types return pointers into the
  // decoder's internal scratch space, which get invalidated on the
  // following decoder call. We circumvent the issue by executing a
  // functor on each decoded chunk before moving to the next one.
  Status RunOnDecodedChunks(
      Encoding::type encoding, std::span<const uint8_t> encoded_data, int chunk_size,
      std::function<Status(int offset, std::span<const c_type>)> func) {
    BEGIN_PARQUET_CATCH_EXCEPTIONS
    int total_values = 0;
    auto decoder = MakeDecoder(encoding);
    // NOTE: In real API usage, the `num_values` given to SetData() is read from
    // the data page header and can include a number of nulls, so it's merely an
    // upper bound for the number of physical values.
    // However, Decode() calls are not supposed to ask more than the actual number
    // of physical values.
    decoder->SetData(num_values_, encoded_data.data(),
                     static_cast<int>(encoded_data.size()));
    while (total_values < num_values_) {
      const int read_size = std::min(num_values_ - total_values, chunk_size);
      PoolVector<c_type> chunk_values(pool());
      BEGIN_CATCH_BAD_ALLOC
      chunk_values.resize(read_size);
      END_CATCH_BAD_ALLOC
      int values_read;
      if constexpr (kType == Type::BOOLEAN) {
        values_read =
            decoder->Decode(reinterpret_cast<bool*>(chunk_values.data()), read_size);
      } else {
        values_read = decoder->Decode(chunk_values.data(), read_size);
      }
      ARROW_CHECK_LE(values_read, read_size);
      RETURN_NOT_OK(func(total_values, std::span(chunk_values).first(values_read)));
      total_values += values_read;
      if (values_read < chunk_size) {
        break;
      }
    }
    if (total_values < num_values_) {
      return Status::Invalid("Read less values than expected");
    }