cuda-cccl 0.3.0__cp310-cp310-manylinux_2_24_aarch64.whl → 0.3.1__cp310-cp310-manylinux_2_24_aarch64.whl

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

@@ -0,0 +1,158 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES
+//
+//===----------------------------------------------------------------------===//
+#ifndef _CUDA___ITERATOR_ZIP_COMMON_H
+#define _CUDA___ITERATOR_ZIP_COMMON_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/__fwd/zip_iterator.h>
+#include <cuda/std/__fwd/pair.h>
+#include <cuda/std/__fwd/tuple.h>
+#include <cuda/std/__iterator/concepts.h>
+#include <cuda/std/__iterator/iter_move.h>
+#include <cuda/std/__iterator/iter_swap.h>
+#include <cuda/std/__iterator/iterator_traits.h>
+#include <cuda/std/__type_traits/is_nothrow_default_constructible.h>
+#include <cuda/std/__type_traits/is_nothrow_move_constructible.h>
+#include <cuda/std/__utility/declval.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+_CCCL_TEMPLATE(class... _Iterators)
+_CCCL_REQUIRES((sizeof...(_Iterators) != 2))
+[[nodiscard]] _CCCL_API constexpr auto __tuple_or_pair_impl() noexcept -> ::cuda::std::tuple<_Iterators...>;
+
+template <class _Tp, class _Up>
+[[nodiscard]] _CCCL_API constexpr auto __tuple_or_pair_impl() noexcept -> ::cuda::std::pair<_Tp, _Up>;
+
+template <class... _Iterators>
+using __tuple_or_pair = decltype(::cuda::__tuple_or_pair_impl<_Iterators...>());
+
+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> && ...);
+
+  static constexpr bool __all_nothrow_move_constructible =
+    (::cuda::std::is_nothrow_move_constructible_v<_Iterators> && ...);
+
+  static constexpr bool __all_default_initializable = (::cuda::std::default_initializable<_Iterators> && ...);
+
+  static constexpr bool __all_nothrow_default_constructible =
+    (::cuda::std::is_nothrow_default_constructible_v<_Iterators> && ...);
+};
+
+template <class... _Iterators>
+[[nodiscard]] _CCCL_API _CCCL_CONSTEVAL auto __get_zip_iterator_concept()
+{
+  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)...};
+  }
+};
+
+_CCCL_END_NAMESPACE_CUDA
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA___ITERATOR_ZIP_COMMON_H

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>
@@ -51,46 +52,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 +66,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.
@@ -270,7 +162,7 @@ public:
       : __current_(::cuda::std::move(__iters)...)
   {}
 
-  using iterator_concept = decltype(__get_zip_view_iterator_tag<_Iterators...>());
+  using iterator_concept = decltype(__get_zip_iterator_concept<_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 difference_type  = ::cuda::std::common_type_t<::cuda::std::iter_difference_t<_Iterators>...>;
@@ -595,17 +487,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 __tuple_or_pair<_Iterators...>& __iters1,
+                                        const __tuple_or_pair<_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)), ...);
     }