refactor: replace arrow::util::span with std::span

Author: chakkk309

cpp/src/arrow/array/concatenate.cc

@@ -424,7 +424,7 @@ class ConcatenateImpl {
     out_->buffers.resize(2);
 
     for (const auto& in_data : in_) {
-      for (const auto& buf : util::span(in_data->buffers).subspan(2)) {
+      for (const auto& buf : std::span(in_data->buffers).subspan(2)) {
         out_->buffers.push_back(buf);
       }
     }

cpp/src/arrow/array/data.cc

@@ -102,7 +102,7 @@ bool DictionaryMayHaveLogicalNulls(const ArrayData& data) {
 
 namespace {
 
-BufferSpan PackVariadicBuffers(util::span<const std::shared_ptr<Buffer>> buffers) {
+BufferSpan PackVariadicBuffers(std::span<const std::shared_ptr<Buffer>> buffers) {
   return {const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(buffers.data())),
           static_cast<int64_t>(buffers.size() * sizeof(std::shared_ptr<Buffer>))};
 }
@@ -322,7 +322,7 @@ void ArraySpan::SetMembers(const ArrayData& data) {
 
   if (type_id == Type::STRING_VIEW || type_id == Type::BINARY_VIEW) {
     // store the span of data buffers in the third buffer
-    this->buffers[2] = internal::PackVariadicBuffers(util::span(data.buffers).subspan(2));
+    this->buffers[2] = internal::PackVariadicBuffers(std::span(data.buffers).subspan(2));
   }
 
   if (type_id == Type::DICTIONARY) {
@@ -679,7 +679,7 @@ std::shared_ptr<ArrayData> ArraySpan::ToArrayData() const {
   return result;
 }
 
-util::span<const std::shared_ptr<Buffer>> ArraySpan::GetVariadicBuffers() const {
+std::span<const std::shared_ptr<Buffer>> ArraySpan::GetVariadicBuffers() const {
   DCHECK(HasVariadicBuffers());
   return {buffers[2].data_as<std::shared_ptr<Buffer>>(),
           static_cast<size_t>(buffers[2].size) / sizeof(std::shared_ptr<Buffer>)};

cpp/src/arrow/array/data.h

@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cstdint>
 #include <memory>
+#include <span>
 #include <utility>
 #include <vector>
 
@@ -31,9 +32,7 @@
 #include "arrow/type_fwd.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/macros.h"
-#include <span>
 #include "arrow/util/visibility.h"
-
 namespace arrow {
 
 namespace internal {
@@ -577,11 +576,11 @@ struct ARROW_EXPORT ArraySpan {
   /// this array type
   /// \return A span<const T> of the requested length
   template <typename T>
-  util::span<const T> GetSpan(int i, int64_t length) const {
+  std::span<const T> GetSpan(int i, int64_t length) const {
     const int64_t buffer_length = buffers[i].size / static_cast<int64_t>(sizeof(T));
     assert(i > 0 && length + offset <= buffer_length);
     ARROW_UNUSED(buffer_length);
-    return util::span<const T>(buffers[i].data_as<T>() + this->offset, length);
+    return std::span<const T>(buffers[i].data_as<T>() + this->offset, length);
   }
 
   /// \brief Access a buffer's data as a span
@@ -593,11 +592,11 @@ struct ARROW_EXPORT ArraySpan {
   /// this array type
   /// \return A span<T> of the requested length
   template <typename T>
-  util::span<T> GetSpan(int i, int64_t length) {
+  std::span<T> GetSpan(int i, int64_t length) {
     const int64_t buffer_length = buffers[i].size / static_cast<int64_t>(sizeof(T));
     assert(i > 0 && length + offset <= buffer_length);
     ARROW_UNUSED(buffer_length);
-    return util::span<T>(buffers[i].mutable_data_as<T>() + this->offset, length);
+    return std::span<T>(buffers[i].mutable_data_as<T>() + this->offset, length);
   }
 
   inline bool IsNull(int64_t i) const { return !IsValid(i); }
@@ -709,7 +708,7 @@ struct ARROW_EXPORT ArraySpan {
   /// sizeof(shared_ptr<Buffer>).
   ///
   /// \see HasVariadicBuffers
-  util::span<const std::shared_ptr<Buffer>> GetVariadicBuffers() const;
+  std::span<const std::shared_ptr<Buffer>> GetVariadicBuffers() const;
   bool HasVariadicBuffers() const;
 
  private:

cpp/src/arrow/array/util.cc

@@ -15,18 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "arrow/array/util.h"
-
 #include <algorithm>
 #include <array>
 #include <cstdint>
 #include <cstring>
 #include <limits>
 #include <memory>
+#include <span>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
+#include "arrow/array/util.h"
 #include "arrow/array.h"
 #include "arrow/array/builder_base.h"
 #include "arrow/array/concatenate.h"
@@ -44,10 +44,8 @@
 #include "arrow/util/endian.h"
 #include "arrow/util/logging_internal.h"
 #include "arrow/util/sort_internal.h"
-#include <span>
 #include "arrow/visit_data_inline.h"
 #include "arrow/visit_type_inline.h"
-
 namespace arrow {
 
 using internal::checked_cast;

cpp/src/arrow/array/validate.cc

@@ -650,9 +650,9 @@ struct ValidateArrayImpl {
                              HexEncode(data, BinaryViewType::kPrefixSize));
     };
 
-    util::span views(data.GetValues<BinaryViewType::c_type>(1),
+    std::span views(data.GetValues<BinaryViewType::c_type>(1),
                      static_cast<size_t>(data.length));
-    util::span data_buffers(data.buffers.data() + 2, data.buffers.size() - 2);
+    std::span data_buffers(data.buffers.data() + 2, data.buffers.size() - 2);
 
     for (size_t i = 0; i < static_cast<size_t>(data.length); ++i) {
       if (data.IsNull(i)) continue;
@@ -663,7 +663,7 @@ struct ValidateArrayImpl {
       }
 
       if (views[i].is_inline()) {
-        auto padding_bytes = util::span(views[i].inlined.data).subspan(views[i].size());
+        auto padding_bytes = std::span(views[i].inlined.data).subspan(views[i].size());
         for (auto padding_byte : padding_bytes) {
           if (padding_byte != 0) {
             return Status::Invalid("View at slot ", i, " was inline with size ",

cpp/src/arrow/buffer.h

@@ -21,6 +21,7 @@
 #include <cstring>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -30,7 +31,6 @@
 #include "arrow/status.h"
 #include "arrow/type_fwd.h"
 #include "arrow/util/macros.h"
-#include <span>
 #include "arrow/util/visibility.h"
 
 namespace arrow {
@@ -236,8 +236,8 @@ class ARROW_EXPORT Buffer {
 
   /// \brief Return the buffer's data as a span
   template <typename T>
-  util::span<const T> span_as() const {
-    return util::span(data_as<T>(), static_cast<size_t>(size() / sizeof(T)));
+  std::span<const T> span_as() const {
+    return std::span(data_as<T>(), static_cast<size_t>(size() / sizeof(T)));
   }
 
   /// \brief Return a writable pointer to the buffer's data
@@ -269,8 +269,8 @@ class ARROW_EXPORT Buffer {
 
   /// \brief Return the buffer's mutable data as a span
   template <typename T>
-  util::span<T> mutable_span_as() {
-    return util::span(mutable_data_as<T>(), static_cast<size_t>(size() / sizeof(T)));
+  std::span<T> mutable_span_as() {
+    return std::span(mutable_data_as<T>(), static_cast<size_t>(size() / sizeof(T)));
   }
 
   /// \brief Return the device address of the buffer's data

cpp/src/arrow/c/bridge.cc

@@ -603,7 +603,7 @@ struct ArrayExporter {
                    });
 
     if (need_variadic_buffer_sizes) {
-      auto variadic_buffers = util::span(data->buffers).subspan(2);
+      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) {

cpp/src/arrow/c/bridge_test.cc

@@ -592,8 +592,8 @@ struct ArrayExportChecker {
       ASSERT_EQ(c_export->buffers[i], expected_ptr);
     }
     if (has_variadic_buffer_sizes) {
-      auto variadic_buffers = util::span(expected_data.buffers).subspan(2);
-      auto variadic_buffer_sizes = util::span(
+      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)) {

cpp/src/arrow/chunk_resolver.cc

@@ -28,7 +28,7 @@
 
 namespace arrow {
 
-using util::span;
+using std::span;
 
 namespace {
 template <typename T>

cpp/src/arrow/chunk_resolver.h

@@ -21,12 +21,12 @@
 #include <cassert>
 #include <cstdint>
 #include <limits>
+#include <span>
 #include <type_traits>
 #include <vector>
 
 #include "arrow/type_fwd.h"
 #include "arrow/util/macros.h"
-#include <span>
 
 namespace arrow {
 
@@ -77,7 +77,7 @@ class ARROW_EXPORT ChunkResolver {
 
  public:
   explicit ChunkResolver(const ArrayVector& chunks) noexcept;
-  explicit ChunkResolver(util::span<const Array* const> chunks) noexcept;
+  explicit ChunkResolver(std::span<const Array* const> chunks) noexcept;
   explicit ChunkResolver(const RecordBatchVector& batches) noexcept;
 
   /// \brief Construct a ChunkResolver from a vector of chunks.size() + 1 offsets.