Guard ChunkResolver use in altrep.cpp

cpp/src/arrow/chunk_resolver.h

@@ -75,23 +75,12 @@ class ARROW_EXPORT ChunkResolver {
   mutable std::atomic<int32_t> cached_chunk_;
 
  public:
-  /// \brief Initialize from an `ArrayVector`.
   explicit ChunkResolver(const ArrayVector& chunks) noexcept;
 
-  /// \brief Initialize from a vector of raw `Array` pointers.
   explicit ChunkResolver(const std::vector<const Array*>& chunks) noexcept;
 
-  /// \brief Initialize from a `RecordBatchVector`.
-  ///
-  /// Because all `Array`s in a `RecordBatch` must have the same length, this
-  /// can be useful for iterating over multiple columns simultaneously.
   explicit ChunkResolver(const RecordBatchVector& batches) noexcept;
 
-  /// \brief Construct a ChunkResolver from a vector of chunks.size() + 1 offsets.
-  ///
-  /// The first offset must be 0 and the last offset must be the logical length of the
-  /// chunked array. Each offset before the last represents the starting logical index of
-  /// the corresponding chunk.
   explicit ChunkResolver(std::vector<int64_t> offsets) noexcept
       : offsets_(std::move(offsets)), cached_chunk_(0) {
 #ifndef NDEBUG

r/src/altrep.cpp

@@ -80,18 +80,26 @@ void DeletePointer(std::shared_ptr<T>* ptr) {
 template <typename T>
 using Pointer = cpp11::external_pointer<std::shared_ptr<T>, DeletePointer<T>>;
 
+#if ARROW_MAJOR_VERSION >= 18
+using ChunkResolver = arrow::ChunkResolver;
+using ChunkLocation = arrow::ChunkLocation;
+#else
+using ChunkResolver = arrow::internal::ChunkResolver;
+using ChunkLocation = arrow::internal::ChunkLocation;
+#endif
+
 class ArrowAltrepData {
  public:
   explicit ArrowAltrepData(const std::shared_ptr<ChunkedArray>& chunked_array)
       : chunked_array_(chunked_array), resolver_(chunked_array->chunks()) {}
 
   const std::shared_ptr<ChunkedArray>& chunked_array() { return chunked_array_; }
 
-  arrow::ChunkLocation locate(int64_t index) { return resolver_.Resolve(index); }
+  ChunkLocation locate(int64_t index) { return resolver_.Resolve(index); }
 
  private:
   std::shared_ptr<ChunkedArray> chunked_array_;
-  arrow::ChunkResolver resolver_;
+  ChunkResolver resolver_;
 };
 
 // the ChunkedArray that is being wrapped by the altrep object