Method Export

cpp/src/arrow/c/bridge.cc:577–635

      : device_interface_(device_interface) {}

  Status Export(const std::shared_ptr<ArrayData>& data) {
    // Force computing null count.
    // This is because ARROW-9037 is in version 0.17 and 0.17.1, and they are
    // not able to import arrays without a null bitmap and null_count == -1.
    data->GetNullCount();
    // Store buffer pointers
    size_t n_buffers = data->buffers.size();
    auto buffers_begin = data->buffers.begin();
    if (n_buffers > 0 && !internal::may_have_validity_bitmap(data->type->id())) {
      --n_buffers;
      ++buffers_begin;
    }

    bool need_variadic_buffer_sizes = data->type->storage_id() == Type::BINARY_VIEW ||
                                      data->type->storage_id() == Type::STRING_VIEW;
    if (need_variadic_buffer_sizes) {
      ++n_buffers;
    }

    export_.buffers_.resize(n_buffers);
    std::transform(buffers_begin, data->buffers.end(), export_.buffers_.begin(),
                   [this](const std::shared_ptr<Buffer>& buffer) -> const void* {
                     return buffer
                                ? (device_interface_
                                       ? reinterpret_cast<const void*>(buffer->address())
                                       : buffer->data())
                                : nullptr;
                   });

    if (need_variadic_buffer_sizes) {
      auto variadic_buffers = std::span(data->buffers).subspan(2);
      export_.variadic_buffer_sizes_.resize(variadic_buffers.size());
      size_t i = 0;
      for (const auto& buf : variadic_buffers) {
        export_.variadic_buffer_sizes_[i++] = buf->size();
      }
      export_.buffers_.back() = export_.variadic_buffer_sizes_.data();
    }

    // Export dictionary
    if (data->dictionary != nullptr) {
      dict_exporter_ = std::make_unique<ArrayExporter>(device_interface_);
      RETURN_NOT_OK(dict_exporter_->Export(data->dictionary));
    }

    // Export children
    export_.children_.resize(data->child_data.size());
    child_exporters_.reserve(data->child_data.size());
    for (const auto& child : data->child_data) {
      child_exporters_.emplace_back(ArrayExporter{device_interface_});
      RETURN_NOT_OK(child_exporters_.back().Export(child));
    }

    // Store owning pointer to ArrayData
    export_.data_ = data;

    export_.sync_ = nullptr;
    return Status::OK();