Function DoBitmapVisitAndWrite

cpp/src/arrow/util/bitmap_test.cc:1424–1473

namespace {

void DoBitmapVisitAndWrite(int64_t part, bool with_offset) {
  int64_t bits = part * 4;

  random::RandomArrayGenerator rand(/*seed=*/0);
  auto arrow_data = rand.ArrayOf(boolean(), bits, 0);

  std::shared_ptr<Buffer>& arrow_buffer = arrow_data->data()->buffers[1];

  Bitmap bm0(arrow_buffer, 0, part);
  Bitmap bm1(arrow_buffer, part * 1, part);
  Bitmap bm2(arrow_buffer, part * 2, part);

  std::array<Bitmap, 2> out_bms;
  std::shared_ptr<Buffer> out, out0, out1;
  if (with_offset) {
    ASSERT_OK_AND_ASSIGN(out, AllocateBitmap(part * 4));
    out_bms[0] = Bitmap(out, part, part);
    out_bms[1] = Bitmap(out, part * 2, part);
  } else {
    ASSERT_OK_AND_ASSIGN(out0, AllocateBitmap(part));
    ASSERT_OK_AND_ASSIGN(out1, AllocateBitmap(part));
    out_bms[0] = Bitmap(out0, 0, part);
    out_bms[1] = Bitmap(out1, 0, part);
  }

  // out0 = bm0 & bm1, out1= bm0 | bm2
  std::array<Bitmap, 3> in_bms{bm0, bm1, bm2};
  Bitmap::VisitWordsAndWrite(
      in_bms, &out_bms,
      [](const std::array<uint64_t, 3>& in, std::array<uint64_t, 2>* out) {
        out->at(0) = in[0] & in[1];
        out->at(1) = in[0] | in[2];
      });

  auto pool = MemoryPool::CreateDefault();
  ASSERT_OK_AND_ASSIGN(auto exp_0, BitmapAnd(pool.get(), bm0.data(), bm0.offset(),
                                             bm1.data(), bm1.offset(), part, 0));
  ASSERT_OK_AND_ASSIGN(auto exp_1, BitmapOr(pool.get(), bm0.data(), bm0.offset(),
                                            bm2.data(), bm2.offset(), part, 0));

  ASSERT_TRUE(
      BitmapEquals(exp_0->data(), 0, out_bms[0].data(), out_bms[0].offset(), part))
      << "exp: " << Bitmap(exp_0->data(), 0, part).ToString() << std::endl
      << "got: " << out_bms[0].ToString();

  ASSERT_TRUE(
      BitmapEquals(exp_1->data(), 0, out_bms[1].data(), out_bms[1].offset(), part))
      << "exp: " << Bitmap(exp_1->data(), 0, part).ToString() << std::endl
      << "got: " << out_bms[1].ToString();
}

}  // namespace