Method GetBatch

cpp/src/arrow/util/rle_encoding_internal.h:790–834

template <typename T>
auto RleBitPackedDecoder<T>::GetBatch(value_type* out,
                                      rle_size_t batch_size) -> rle_size_t {
  using ControlFlow = RleBitPackedParser::ControlFlow;

  if (ARROW_PREDICT_FALSE(batch_size == 0 || exhausted())) {
    return 0;
  }

  rle_size_t values_read = 0;

  // Remaining from a previous call that would have left some unread data from a run.
  if (ARROW_PREDICT_FALSE(run_remaining() > 0)) {
    const auto read = RunGetBatch(out, batch_size);
    values_read += read;
    out += read;

    // Either we fulfilled all the batch to be read or we finished remaining run.
    if (ARROW_PREDICT_FALSE(values_read == batch_size)) {
      return values_read;
    }
    ARROW_DCHECK(run_remaining() == 0);
  }

  parser_.ParseWithCallable([&](auto run) {
    using RunDecoder =
        typename RleBitPackedDecoderGetRunDecoder<value_type, decltype(run)>::type;

    ARROW_DCHECK_LT(values_read, batch_size);
    RunDecoder decoder(run, value_bit_width_);
    const auto read = decoder.GetBatch(out, batch_size - values_read, value_bit_width_);
    ARROW_DCHECK_LE(read, batch_size - values_read);
    values_read += read;
    out += read;

    // Stop reading and store remaining decoder
    if (ARROW_PREDICT_FALSE(values_read == batch_size || read == 0)) {
      decoder_ = std::move(decoder);
      return ControlFlow::Break;
    }

    return ControlFlow::Continue;
  });

  return values_read;
}

namespace internal {