Class BitPackedRun

cpp/src/arrow/util/rle_encoding_internal.h:155–192

A single bit packed run. Consist of a view on a buffer of bytes that encode integers on ``value_bit_width`` bits (that is the numbers are small enough that high order bits are all zeros and can be omitted). A previous version of this class also stored the value bit width to be self contain, removing it and passing it explicitly when needed proved to speed up decoding up to 10 % on some benchmarks

/// removing it and passing it explicitly when needed proved to speed up decoding up to
/// 10 % on some benchmarks.
class BitPackedRun {
 public:
  constexpr BitPackedRun() noexcept = default;

  constexpr BitPackedRun(const uint8_t* data, rle_size_t values_count,
                         rle_size_t value_bit_width, rle_size_t max_read_bytes) noexcept
      : data_(data), values_count_(values_count), max_read_bytes_(max_read_bytes) {
    ARROW_DCHECK_GE(value_bit_width, 0);
    ARROW_DCHECK_GE(values_count_, 0);
    ARROW_DCHECK(max_read_bytes < 0 ||
                 bit_util::BytesForBits(value_bit_width * values_count) <=
                     max_read_bytes);
  }

  constexpr rle_size_t values_count() const noexcept { return values_count_; }

  constexpr const uint8_t* raw_data_ptr() const noexcept { return data_; }

  constexpr rle_size_t raw_data_size(rle_size_t value_bit_width) const noexcept {
    auto out = bit_util::BytesForBits(static_cast<int64_t>(value_bit_width) *
                                      static_cast<int64_t>(values_count_));
    ARROW_DCHECK_LE(out, std::numeric_limits<rle_size_t>::max());
    return static_cast<rle_size_t>(out);
  }

  /// Maximum number of bytes allowed to be read in the buffer.
  /// This is used for unpacking operations that may need to read more bytes than they
  /// extract for performance.
  constexpr rle_size_t raw_data_max_size() const noexcept { return max_read_bytes_; }

 private:
  /// The pointer to the beginning of the run
  const uint8_t* data_ = nullptr;
  /// Number of values in this run.
  rle_size_t values_count_ = 0;
  /// Not the size of the run, but the maximum number of bytes we can read in the buffer.
  rle_size_t max_read_bytes_ = -1;
};

/// A parser that emits either a ``BitPackedRun`` or a ``RleRun``.
class RleBitPackedParser {