Method PeekImpl

cpp/src/arrow/util/rle_encoding_internal.h:691–764

template <typename Handler>
auto RleBitPackedParser::PeekImpl(Handler&& handler) const
    -> std::pair<rle_size_t, ControlFlow> {
  ARROW_DCHECK(!exhausted());

  constexpr auto kMaxSize = bit_util::kMaxLEB128ByteLenFor<uint32_t>;
  uint32_t run_len_type = 0;
  const auto header_bytes =
      bit_util::ParseLeadingLEB128(data_, std::min(kMaxSize, data_size_), &run_len_type);
  if (ARROW_PREDICT_FALSE(header_bytes == 0)) {
    // Malformed LEB128 data
    return {0, ControlFlow::Break};
  }

  const bool is_bit_packed = run_len_type & 1;
  const uint32_t count = run_len_type >> 1;
  if (is_bit_packed) {
    // Bit-packed run
    constexpr auto kMaxCount = internal::max_size_for_v<rle_size_t> / 8;
    if (ARROW_PREDICT_FALSE(count == 0 || count > kMaxCount)) {
      // Illegal number of encoded values
      return {0, ControlFlow::Break};
    }

    ARROW_DCHECK_LT(static_cast<uint64_t>(count) * 8,
                    internal::max_size_for_v<rle_size_t>);
    // Count Already divided by 8 for byte size calculations
    auto bytes_read = header_bytes + static_cast<int64_t>(count) * value_bit_width_;
    auto values_count = static_cast<rle_size_t>(count * 8);
    if (ARROW_PREDICT_FALSE(bytes_read > data_size_)) {
      // Bit-packed run would overflow data buffer, but we might still be able
      // to return a truncated bit-packed such as generated by some non-compliant
      // encoders.
      // Example in GH-47981: column contains 25 5-bit values, has a single
      // bit-packed run with count=4 (theoretically 32 values), but only 17
      // bytes of RLE-bit-packed data (including the one-byte header).
      bytes_read = data_size_;
      values_count =
          static_cast<rle_size_t>((bytes_read - header_bytes) * 8 / value_bit_width_);
      // Only allow errors where the bit-packed run is not padded to a multiple
      // of 8 values. Larger truncation should not occur.
      if (values_count <= static_cast<rle_size_t>((count - 1) * 8)) {
        return {0, ControlFlow::Break};
      }
    }

    auto control = handler.OnBitPackedRun(
        BitPackedRun(data_ + header_bytes, values_count, value_bit_width_,
                     /* .max_read_bytes= */ data_size_ - header_bytes));

    return {static_cast<rle_size_t>(bytes_read), control};
  }

  // RLE run
  if (ARROW_PREDICT_FALSE(count == 0)) {
    // Illegal number of encoded values
    return {0, ControlFlow::Break};
  }