cuda-cccl 0.3.0__cp311-cp311-manylinux_2_24_aarch64.whl → 0.3.2__cp311-cp311-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/__iterator/zip_iterator.h

@@ -25,6 +25,7 @@
 #if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
 #  include <cuda/std/__compare/three_way_comparable.h>
 #endif // _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+#include <cuda/__iterator/zip_common.h>
 #include <cuda/std/__concepts/convertible_to.h>
 #include <cuda/std/__concepts/equality_comparable.h>
 #include <cuda/std/__functional/invoke.h>
@@ -41,7 +42,6 @@
 #include <cuda/std/__utility/forward.h>
 #include <cuda/std/__utility/integer_sequence.h>
 #include <cuda/std/__utility/move.h>
-#include <cuda/std/__utility/pair.h>
 #include <cuda/std/tuple>
 
 #include <cuda/std/__cccl/prologue.h>
@@ -51,46 +51,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA
 //! @addtogroup iterators
 //! @{
 
-template <class... _Iterators>
-struct __tuple_or_pair_impl
-{
-  using type = ::cuda::std::tuple<_Iterators...>;
-};
-
-template <class _Iterator1, class _Iterator2>
-struct __tuple_or_pair_impl<_Iterator1, _Iterator2>
-{
-  using type = ::cuda::std::pair<_Iterator1, _Iterator2>;
-};
-
-template <class... _Iterators>
-using __tuple_or_pair = typename __tuple_or_pair_impl<_Iterators...>::type;
-
-template <class... _Iterators>
-struct __zip_iter_constraints
-{
-  static constexpr bool __all_forward       = (::cuda::std::__has_forward_traversal<_Iterators> && ...);
-  static constexpr bool __all_bidirectional = (::cuda::std::__has_bidirectional_traversal<_Iterators> && ...);
-  static constexpr bool __all_random_access = (::cuda::std::__has_random_access_traversal<_Iterators> && ...);
-
-  static constexpr bool __all_equality_comparable = (::cuda::std::equality_comparable<_Iterators> && ...);
-
-#if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
-  static constexpr bool __all_three_way_comparable = (::cuda::std::three_way_comparable<_Iterators> && ...);
-#endif // _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
-
-  // Our C++17 iterators sometimes do not satisfy `sized_sentinel_for` but they should all be random_access
-  static constexpr bool __all_sized_sentinel =
-    (::cuda::std::sized_sentinel_for<_Iterators, _Iterators> && ...) || __all_random_access;
-  static constexpr bool __all_nothrow_iter_movable =
-    (noexcept(::cuda::std::ranges::iter_move(::cuda::std::declval<const _Iterators&>())) && ...)
-    && (::cuda::std::is_nothrow_move_constructible_v<::cuda::std::iter_rvalue_reference_t<_Iterators>> && ...);
-
-  static constexpr bool __all_indirectly_swappable = (::cuda::std::indirectly_swappable<_Iterators> && ...);
-
-  static constexpr bool __all_noexcept_swappable = (::cuda::std::__noexcept_swappable<_Iterators> && ...);
-};
-
 struct __zv_iter_category_base_none
 {};
 
@@ -105,77 +65,8 @@ using __zv_iter_category_base =
                              __zv_iter_category_base_tag,
                              __zv_iter_category_base_none>;
 
-template <class... _Iterators>
-_CCCL_API constexpr auto __get_zip_view_iterator_tag()
-{
-  using _Constraints = __zip_iter_constraints<_Iterators...>;
-  if constexpr (_Constraints::__all_random_access)
-  {
-    return ::cuda::std::random_access_iterator_tag();
-  }
-  else if constexpr (_Constraints::__all_bidirectional)
-  {
-    return ::cuda::std::bidirectional_iterator_tag();
-  }
-  else if constexpr (_Constraints::__all_forward)
-  {
-    return ::cuda::std::forward_iterator_tag();
-  }
-  else
-  {
-    return ::cuda::std::input_iterator_tag();
-  }
-  _CCCL_UNREACHABLE();
-}
-
-//! @note Not static functions because nvc++ sometimes has issues with class static functions in device code
-struct __zip_op_star
-{
-  template <class... _Iterators>
-  using reference = __tuple_or_pair<::cuda::std::iter_reference_t<_Iterators>...>;
-
-  _CCCL_EXEC_CHECK_DISABLE
-  template <class... _Iterators>
-  [[nodiscard]] _CCCL_API constexpr reference<_Iterators...> operator()(const _Iterators&... __iters) const
-    noexcept(noexcept(reference<_Iterators...>{*__iters...}))
-  {
-    return reference<_Iterators...>{*__iters...};
-  }
-};
-
-struct __zip_op_increment
-{
-  _CCCL_EXEC_CHECK_DISABLE
-  template <class... _Iterators>
-  _CCCL_API constexpr void operator()(_Iterators&... __iters) const noexcept(noexcept(((void) ++__iters, ...)))
-  {
-    ((void) ++__iters, ...);
-  }
-};
-
-struct __zip_op_decrement
-{
-  _CCCL_EXEC_CHECK_DISABLE
-  template <class... _Iterators>
-  _CCCL_API constexpr void operator()(_Iterators&... __iters) const noexcept(noexcept(((void) --__iters, ...)))
-  {
-    ((void) --__iters, ...);
-  }
-};
-
-struct __zip_iter_move
-{
-  template <class... _Iterators>
-  using __iter_move_ret = __tuple_or_pair<::cuda::std::iter_rvalue_reference_t<_Iterators>...>;
-
-  _CCCL_EXEC_CHECK_DISABLE
-  template <class... _Iterators>
-  [[nodiscard]] _CCCL_API constexpr __iter_move_ret<_Iterators...> operator()(const _Iterators&... __iters) const
-    noexcept(noexcept(__iter_move_ret<_Iterators...>{::cuda::std::ranges::iter_move(__iters)...}))
-  {
-    return __iter_move_ret<_Iterators...>{::cuda::std::ranges::iter_move(__iters)...};
-  }
-};
+//! @addtogroup iterators
+//! @{
 
 //! @brief @c zip_iterator is an iterator which represents a @c tuple of iterators. This iterator is useful for creating
 //! a virtual array of structures while achieving the same performance and bandwidth as the structure of arrays idiom.
@@ -231,7 +122,7 @@ struct __zip_iter_move
 template <class... _Iterators>
 class zip_iterator : public __zv_iter_category_base<_Iterators...>
 {
-  __tuple_or_pair<_Iterators...> __current_;
+  ::cuda::std::tuple<_Iterators...> __current_;
 
   template <class...>
   friend class zip_iterator;
@@ -239,8 +130,8 @@ class zip_iterator : public __zv_iter_category_base<_Iterators...>
   template <class _Fn>
   _CCCL_API static constexpr auto
   __zip_apply(const _Fn& __fun,
-              const __tuple_or_pair<_Iterators...>& __tuple1,
-              const __tuple_or_pair<_Iterators...>& __tuple2) //
+              const ::cuda::std::tuple<_Iterators...>& __tuple1,
+              const ::cuda::std::tuple<_Iterators...>& __tuple2) //
     noexcept(noexcept(__fun(__tuple1, __tuple2, ::cuda::std::make_index_sequence<sizeof...(_Iterators)>())))
   {
     return __fun(__tuple1, __tuple2, ::cuda::std::make_index_sequence<sizeof...(_Iterators)>());
@@ -251,8 +142,8 @@ public:
   _CCCL_HIDE_FROM_ABI zip_iterator() = default;
 
   //! @brief Constructs a @c zip_iterator from a tuple of iterators
-  //! @param __iters A tuple or pair of iterators
-  _CCCL_API constexpr explicit zip_iterator(__tuple_or_pair<_Iterators...> __iters)
+  //! @param __iters A tuple of iterators
+  _CCCL_API constexpr explicit zip_iterator(::cuda::std::tuple<_Iterators...> __iters)
       : __current_(::cuda::std::move(__iters))
   {}
 
@@ -270,9 +161,9 @@ public:
       : __current_(::cuda::std::move(__iters)...)
   {}
 
-  using iterator_concept = decltype(__get_zip_view_iterator_tag<_Iterators...>());
-  using value_type       = __tuple_or_pair<::cuda::std::iter_value_t<_Iterators>...>;
-  using reference        = __tuple_or_pair<::cuda::std::iter_reference_t<_Iterators>...>;
+  using iterator_concept = decltype(__get_zip_iterator_concept<_Iterators...>());
+  using value_type       = ::cuda::std::tuple<::cuda::std::iter_value_t<_Iterators>...>;
+  using reference        = ::cuda::std::tuple<::cuda::std::iter_reference_t<_Iterators>...>;
   using difference_type  = ::cuda::std::common_type_t<::cuda::std::iter_difference_t<_Iterators>...>;
 
   // Those are technically not to spec, but pre-ranges iterator_traits do not work properly with iterators that do not
@@ -468,8 +359,8 @@ public:
     _CCCL_EXEC_CHECK_DISABLE
     template <size_t _Zero, size_t... _Indices>
     [[nodiscard]] _CCCL_API constexpr difference_type
-    operator()(const __tuple_or_pair<_Iterators...>& __iters1,
-               const __tuple_or_pair<_Iterators...>& __iters2,
+    operator()(const ::cuda::std::tuple<_Iterators...>& __iters1,
+               const ::cuda::std::tuple<_Iterators...>& __iters2,
                ::cuda::std::index_sequence<_Zero, _Indices...>) const //
       noexcept(noexcept(((::cuda::std::get<_Indices>(__iters1) - ::cuda::std::get<_Indices>(__iters2)) && ...)))
     {
@@ -499,8 +390,8 @@ public:
   {
     _CCCL_EXEC_CHECK_DISABLE
     template <size_t... _Indices>
-    _CCCL_API constexpr bool operator()(const __tuple_or_pair<_Iterators...>& __iters1,
-                                        const __tuple_or_pair<_Iterators...>& __iters2,
+    _CCCL_API constexpr bool operator()(const ::cuda::std::tuple<_Iterators...>& __iters1,
+                                        const ::cuda::std::tuple<_Iterators...>& __iters2,
                                         ::cuda::std::index_sequence<_Indices...>) const
       noexcept(noexcept(((::cuda::std::get<_Indices>(__iters1) == ::cuda::std::get<_Indices>(__iters2)) || ...)))
     {
@@ -595,17 +486,13 @@ public:
     return ::cuda::std::apply(__zip_iter_move{}, __iter.__current_);
   }
 
-  template <class... _OtherIterators>
-  static constexpr bool __all_nothrow_swappable =
-    (::cuda::std::__noexcept_swappable<_OtherIterators, _OtherIterators> && ...);
-
   struct __zip_op_iter_swap
   {
     template <size_t... _Indices>
-    _CCCL_API constexpr void
-    operator()(const __tuple_or_pair<_Iterators...>& __iters1,
-               const __tuple_or_pair<_Iterators...>& __iters2,
-               ::cuda::std::index_sequence<_Indices...>) const noexcept(__all_nothrow_swappable<_Iterators...>)
+    _CCCL_API constexpr void operator()(const ::cuda::std::tuple<_Iterators...>& __iters1,
+                                        const ::cuda::std::tuple<_Iterators...>& __iters2,
+                                        ::cuda::std::index_sequence<_Indices...>) const
+      noexcept(__zip_iter_constraints<_Iterators...>::__all_noexcept_swappable)
     {
       (::cuda::std::ranges::iter_swap(::cuda::std::get<_Indices>(__iters1), ::cuda::std::get<_Indices>(__iters2)), ...);
     }
@@ -620,12 +507,12 @@ public:
     return __zip_apply(__zip_op_iter_swap{}, __lhs.__current_, __rhs.__current_);
   }
 
-  [[nodiscard]] _CCCL_API constexpr __tuple_or_pair<_Iterators...>& __iterators() noexcept
+  [[nodiscard]] _CCCL_API constexpr ::cuda::std::tuple<_Iterators...>& __iterators() noexcept
   {
     return __current_;
   }
 
-  [[nodiscard]] _CCCL_API constexpr const __tuple_or_pair<_Iterators...>& __iterators() const noexcept
+  [[nodiscard]] _CCCL_API constexpr const ::cuda::std::tuple<_Iterators...>& __iterators() const noexcept
   {
     return __current_;
   }
@@ -634,9 +521,6 @@ public:
 template <class... _Iterators>
 _CCCL_HOST_DEVICE zip_iterator(::cuda::std::tuple<_Iterators...>) -> zip_iterator<_Iterators...>;
 
-template <class _Iterator1, class _Iterator2>
-_CCCL_HOST_DEVICE zip_iterator(::cuda::std::pair<_Iterator1, _Iterator2>) -> zip_iterator<_Iterator1, _Iterator2>;
-
 template <class... _Iterators>
 _CCCL_HOST_DEVICE zip_iterator(_Iterators...) -> zip_iterator<_Iterators...>;