Method GetBatch

cpp/src/arrow/util/rle_bitmap_internal.h:323–367

};

inline auto RleBitPackedToBitmapDecoder::GetBatch(BitmapSpanMut 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;

    // 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 = RleBitPackedToBitmapDecoderGetDecoder<decltype(run)>::type;

    ARROW_DCHECK_LT(values_read, batch_size);
    RunDecoder decoder(run);
    // The output span carries its own bit offset, so advancing it past the values
    // already written keeps successive runs correctly aligned in the bitmap.
    const auto read =
        decoder.GetBatch(out.NewStartingAt(values_read), batch_size - values_read);
    ARROW_DCHECK_LE(read, batch_size - values_read);
    values_read += 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 arrow::util