Method operator()

cpp/src/arrow/c/bridge_test.cc:573–625

struct ArrayExportChecker {
  void operator()(struct ArrowArray* c_export, const ArrayData& expected_data) {
    ASSERT_EQ(c_export->length, expected_data.length);
    ASSERT_EQ(c_export->null_count, expected_data.null_count);
    ASSERT_EQ(c_export->offset, expected_data.offset);

    auto expected_n_buffers = static_cast<int64_t>(expected_data.buffers.size());
    auto expected_buffers = expected_data.buffers.data();
    if (!internal::may_have_validity_bitmap(expected_data.type->id())) {
      --expected_n_buffers;
      ++expected_buffers;
    }

    bool has_variadic_buffer_sizes =
        expected_data.type->storage_id() == Type::BINARY_VIEW ||
        expected_data.type->storage_id() == Type::STRING_VIEW;
    ASSERT_EQ(c_export->n_buffers, expected_n_buffers + has_variadic_buffer_sizes);
    ASSERT_NE(c_export->buffers, nullptr);

    for (int64_t i = 0; i < expected_n_buffers; ++i) {
      auto expected_ptr = expected_buffers[i] ? expected_buffers[i]->data() : nullptr;
      ASSERT_EQ(c_export->buffers[i], expected_ptr);
    }
    if (has_variadic_buffer_sizes) {
      auto variadic_buffers = std::span(expected_data.buffers).subspan(2);
      auto variadic_buffer_sizes = std::span(
          static_cast<const int64_t*>(c_export->buffers[c_export->n_buffers - 1]),
          variadic_buffers.size());
      for (auto [buf, size] : Zip(variadic_buffers, variadic_buffer_sizes)) {
        ASSERT_EQ(buf->size(), size);
      }
    }

    if (expected_data.dictionary != nullptr) {
      // Recurse into dictionary
      ASSERT_NE(c_export->dictionary, nullptr);
      operator()(c_export->dictionary, *expected_data.dictionary);
    } else {
      ASSERT_EQ(c_export->dictionary, nullptr);
    }

    ASSERT_EQ(c_export->n_children,
              static_cast<int64_t>(expected_data.child_data.size()));
    if (c_export->n_children > 0) {
      ASSERT_NE(c_export->children, nullptr);
      // Recurse into children
      for (int64_t i = 0; i < c_export->n_children; ++i) {
        ASSERT_NE(c_export->children[i], nullptr);
        operator()(c_export->children[i], *expected_data.child_data[i]);
      }
    } else {
      ASSERT_EQ(c_export->children, nullptr);
    }
  }

  void operator()(struct ArrowDeviceArray* c_export, const ArrayData& expected_data,
                  const ArrowDeviceType device_type, const int64_t device_id,