summaryrefslogtreecommitdiff
path: root/ext/mdspan/include/experimental/__p0009_bits
diff options
context:
space:
mode:
authorTomi Valkeinen <tomi.valkeinen@ideasonboard.com>2025-12-18 12:28:37 +0200
committerTomi Valkeinen <tomi.valkeinen@ideasonboard.com>2025-12-18 12:35:28 +0200
commit06ebb8835022b92ea64c5b10bdb3f5afbad0e5f8 (patch)
tree49066a5d691626d097169e9c8c5b051b7bf423e4 /ext/mdspan/include/experimental/__p0009_bits
parent44e660203bcbab509b0ad08b0038192ec471a8de (diff)
Update mdspan headers to 546d4dd63697c6a331554adb6fe650e09b690812
Diffstat (limited to 'ext/mdspan/include/experimental/__p0009_bits')
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp206
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/config.hpp197
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/default_accessor.hpp2
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp2
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/extents.hpp95
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp2
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/layout_left.hpp94
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/layout_right.hpp98
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/layout_stride.hpp260
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/macros.hpp363
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/mdspan.hpp280
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp72
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/trait_backports.hpp46
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/type_list.hpp67
-rw-r--r--ext/mdspan/include/experimental/__p0009_bits/utility.hpp80
15 files changed, 1035 insertions, 829 deletions
diff --git a/ext/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp b/ext/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp
index 25389a2..5a6e945 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp
@@ -18,7 +18,7 @@
#include "macros.hpp"
#include "trait_backports.hpp"
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+#if !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
# include "no_unique_address.hpp"
#endif
@@ -27,169 +27,169 @@ namespace detail {
// For no unique address emulation, this is the case taken when neither are empty.
// For real `[[no_unique_address]]`, this case is always taken.
-template <class _T1, class _T2, class _Enable = void> struct __compressed_pair {
- _MDSPAN_NO_UNIQUE_ADDRESS _T1 __t1_val{};
- _MDSPAN_NO_UNIQUE_ADDRESS _T2 __t2_val{};
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept { return __t1_val; }
- MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept {
- return __t1_val;
+template <class T1, class T2, class Enable = void> struct impl_compressed_pair {
+ MDSPAN_IMPL_NO_UNIQUE_ADDRESS T1 m_t1_val{};
+ MDSPAN_IMPL_NO_UNIQUE_ADDRESS T2 m_t2_val{};
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T1 &first() noexcept { return m_t1_val; }
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr T1 const &first() const noexcept {
+ return m_t1_val;
}
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept { return __t2_val; }
- MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept {
- return __t2_val;
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T2 &second() noexcept { return m_t2_val; }
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr T2 const &second() const noexcept {
+ return m_t2_val;
}
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair() = default;
+ constexpr impl_compressed_pair() = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair(__compressed_pair const &) = default;
+ constexpr impl_compressed_pair(impl_compressed_pair const &) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair(__compressed_pair &&) = default;
+ constexpr impl_compressed_pair(impl_compressed_pair &&) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
- operator=(__compressed_pair const &) = default;
+ MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair &
+ operator=(impl_compressed_pair const &) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
- operator=(__compressed_pair &&) = default;
+ MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair &
+ operator=(impl_compressed_pair &&) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- ~__compressed_pair() = default;
- template <class _T1Like, class _T2Like>
- MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2)
- : __t1_val((_T1Like &&) __t1), __t2_val((_T2Like &&) __t2) {}
+ ~impl_compressed_pair() = default;
+ template <class T1Like, class T2Like>
+ MDSPAN_INLINE_FUNCTION constexpr impl_compressed_pair(T1Like &&t1, T2Like &&t2)
+ : m_t1_val((T1Like &&) t1), m_t2_val((T2Like &&) t2) {}
};
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+#if !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
// First empty.
-template <class _T1, class _T2>
-struct __compressed_pair<
- _T1, _T2,
- std::enable_if_t<_MDSPAN_TRAIT(std::is_empty, _T1) && !_MDSPAN_TRAIT(std::is_empty, _T2)>>
- : private _T1 {
- _T2 __t2_val{};
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept {
- return *static_cast<_T1 *>(this);
+template <class T1, class T2>
+struct impl_compressed_pair<
+ T1, T2,
+ std::enable_if_t<MDSPAN_IMPL_TRAIT(std::is_empty, T1) && !MDSPAN_IMPL_TRAIT(std::is_empty, T2)>>
+ : private T1 {
+ T2 m_t2_val{};
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T1 &first() noexcept {
+ return *static_cast<T1 *>(this);
}
- MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept {
- return *static_cast<_T1 const *>(this);
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr T1 const &first() const noexcept {
+ return *static_cast<T1 const *>(this);
}
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept { return __t2_val; }
- MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept {
- return __t2_val;
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T2 &second() noexcept { return m_t2_val; }
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr T2 const &second() const noexcept {
+ return m_t2_val;
}
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair() = default;
+ constexpr impl_compressed_pair() = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair(__compressed_pair const &) = default;
+ constexpr impl_compressed_pair(impl_compressed_pair const &) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair(__compressed_pair &&) = default;
+ constexpr impl_compressed_pair(impl_compressed_pair &&) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
- operator=(__compressed_pair const &) = default;
+ MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair &
+ operator=(impl_compressed_pair const &) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
- operator=(__compressed_pair &&) = default;
+ MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair &
+ operator=(impl_compressed_pair &&) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- ~__compressed_pair() = default;
- template <class _T1Like, class _T2Like>
- MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2)
- : _T1((_T1Like &&) __t1), __t2_val((_T2Like &&) __t2) {}
+ ~impl_compressed_pair() = default;
+ template <class T1Like, class T2Like>
+ MDSPAN_INLINE_FUNCTION constexpr impl_compressed_pair(T1Like &&t1, T2Like &&t2)
+ : T1((T1Like &&) t1), m_t2_val((T2Like &&) t2) {}
};
// Second empty.
-template <class _T1, class _T2>
-struct __compressed_pair<
- _T1, _T2,
- std::enable_if_t<!_MDSPAN_TRAIT(std::is_empty, _T1) && _MDSPAN_TRAIT(std::is_empty, _T2)>>
- : private _T2 {
- _T1 __t1_val{};
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept { return __t1_val; }
- MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept {
- return __t1_val;
+template <class T1, class T2>
+struct impl_compressed_pair<
+ T1, T2,
+ std::enable_if_t<!MDSPAN_IMPL_TRAIT(std::is_empty, T1) && MDSPAN_IMPL_TRAIT(std::is_empty, T2)>>
+ : private T2 {
+ T1 m_t1_val{};
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T1 &first() noexcept { return m_t1_val; }
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr T1 const &first() const noexcept {
+ return m_t1_val;
}
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept {
- return *static_cast<_T2 *>(this);
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T2 &second() noexcept {
+ return *static_cast<T2 *>(this);
}
- MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept {
- return *static_cast<_T2 const *>(this);
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr T2 const &second() const noexcept {
+ return *static_cast<T2 const *>(this);
}
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair() = default;
+ constexpr impl_compressed_pair() = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair(__compressed_pair const &) = default;
+ constexpr impl_compressed_pair(impl_compressed_pair const &) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair(__compressed_pair &&) = default;
+ constexpr impl_compressed_pair(impl_compressed_pair &&) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
- operator=(__compressed_pair const &) = default;
+ MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair &
+ operator=(impl_compressed_pair const &) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
- operator=(__compressed_pair &&) = default;
+ MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair &
+ operator=(impl_compressed_pair &&) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- ~__compressed_pair() = default;
+ ~impl_compressed_pair() = default;
- template <class _T1Like, class _T2Like>
- MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2)
- : _T2((_T2Like &&) __t2), __t1_val((_T1Like &&) __t1) {}
+ template <class T1Like, class T2Like>
+ MDSPAN_INLINE_FUNCTION constexpr impl_compressed_pair(T1Like &&t1, T2Like &&t2)
+ : T2((T2Like &&) t2), m_t1_val((T1Like &&) t1) {}
};
// Both empty.
-template <class _T1, class _T2>
-struct __compressed_pair<
- _T1, _T2,
- std::enable_if_t<_MDSPAN_TRAIT(std::is_empty, _T1) && _MDSPAN_TRAIT(std::is_empty, _T2)>>
- // We need to use the __no_unique_address_emulation wrapper here to avoid
+template <class T1, class T2>
+struct impl_compressed_pair<
+ T1, T2,
+ std::enable_if_t<MDSPAN_IMPL_TRAIT(std::is_empty, T1) && MDSPAN_IMPL_TRAIT(std::is_empty, T2)>>
+ // We need to use the no_unique_address_emulation wrapper here to avoid
// base class ambiguities.
-#ifdef _MDSPAN_COMPILER_MSVC
+#ifdef MDSPAN_IMPL_COMPILER_MSVC
// MSVC doesn't allow you to access public static member functions of a type
// when you *happen* to privately inherit from that type.
- : protected __no_unique_address_emulation<_T1, 0>,
- protected __no_unique_address_emulation<_T2, 1>
+ : protected no_unique_address_emulation<T1, 0>,
+ protected no_unique_address_emulation<T2, 1>
#else
- : private __no_unique_address_emulation<_T1, 0>,
- private __no_unique_address_emulation<_T2, 1>
+ : private no_unique_address_emulation<T1, 0>,
+ private no_unique_address_emulation<T2, 1>
#endif
{
- using __first_base_t = __no_unique_address_emulation<_T1, 0>;
- using __second_base_t = __no_unique_address_emulation<_T2, 1>;
+ using first_base_t = no_unique_address_emulation<T1, 0>;
+ using second_base_t = no_unique_address_emulation<T2, 1>;
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept {
- return this->__first_base_t::__ref();
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T1 &first() noexcept {
+ return this->first_base_t::ref();
}
- MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept {
- return this->__first_base_t::__ref();
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr T1 const &first() const noexcept {
+ return this->first_base_t::ref();
}
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept {
- return this->__second_base_t::__ref();
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T2 &second() noexcept {
+ return this->second_base_t::ref();
}
- MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept {
- return this->__second_base_t::__ref();
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr T2 const &second() const noexcept {
+ return this->second_base_t::ref();
}
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair() = default;
+ constexpr impl_compressed_pair() = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair(__compressed_pair const &) = default;
+ constexpr impl_compressed_pair(impl_compressed_pair const &) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __compressed_pair(__compressed_pair &&) = default;
+ constexpr impl_compressed_pair(impl_compressed_pair &&) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
- operator=(__compressed_pair const &) = default;
+ MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair &
+ operator=(impl_compressed_pair const &) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
- operator=(__compressed_pair &&) = default;
+ MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair &
+ operator=(impl_compressed_pair &&) = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- ~__compressed_pair() = default;
- template <class _T1Like, class _T2Like>
- MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2) noexcept
- : __first_base_t(_T1((_T1Like &&) __t1)),
- __second_base_t(_T2((_T2Like &&) __t2))
+ ~impl_compressed_pair() = default;
+ template <class T1Like, class T2Like>
+ MDSPAN_INLINE_FUNCTION constexpr impl_compressed_pair(T1Like &&t1, T2Like &&t2) noexcept
+ : first_base_t(T1((T1Like &&) t1)),
+ second_base_t(T2((T2Like &&) t2))
{ }
};
-#endif // !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+#endif // !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
} // end namespace detail
} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/ext/mdspan/include/experimental/__p0009_bits/config.hpp b/ext/mdspan/include/experimental/__p0009_bits/config.hpp
index a23d013..9a00e42 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/config.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/config.hpp
@@ -15,11 +15,15 @@
//@HEADER
#pragma once
-#ifndef __has_include
-# define __has_include(x) 0
+#ifndef MDSPAN_IMPL_HAS_INCLUDE
+# ifndef __has_include
+# define MDSPAN_IMPL_HAS_INCLUDE(x) 0
+# else
+# define MDSPAN_IMPL_HAS_INCLUDE(x) __has_include(x)
+# endif
#endif
-#if __has_include(<version>)
+#if MDSPAN_IMPL_HAS_INCLUDE(<version>)
# include <version>
#else
# include <type_traits>
@@ -27,9 +31,9 @@
#endif
#ifdef _MSVC_LANG
-#define _MDSPAN_CPLUSPLUS _MSVC_LANG
+#define MDSPAN_IMPL_CPLUSPLUS _MSVC_LANG
#else
-#define _MDSPAN_CPLUSPLUS __cplusplus
+#define MDSPAN_IMPL_CPLUSPLUS __cplusplus
#endif
#define MDSPAN_CXX_STD_14 201402L
@@ -42,190 +46,201 @@
#define MDSPAN_CXX_STD_23 202100L
#endif
-#define MDSPAN_HAS_CXX_14 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14)
-#define MDSPAN_HAS_CXX_17 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_17)
-#define MDSPAN_HAS_CXX_20 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_20)
-#define MDSPAN_HAS_CXX_23 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_23)
+#define MDSPAN_HAS_CXX_14 (MDSPAN_IMPL_CPLUSPLUS >= MDSPAN_CXX_STD_14)
+#define MDSPAN_HAS_CXX_17 (MDSPAN_IMPL_CPLUSPLUS >= MDSPAN_CXX_STD_17)
+#define MDSPAN_HAS_CXX_20 (MDSPAN_IMPL_CPLUSPLUS >= MDSPAN_CXX_STD_20)
+#define MDSPAN_HAS_CXX_23 (MDSPAN_IMPL_CPLUSPLUS >= MDSPAN_CXX_STD_23)
-static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or later.");
+static_assert(MDSPAN_IMPL_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or later.");
-#ifndef _MDSPAN_COMPILER_CLANG
+#ifndef MDSPAN_IMPL_COMPILER_CLANG
# if defined(__clang__)
-# define _MDSPAN_COMPILER_CLANG __clang__
+# define MDSPAN_IMPL_COMPILER_CLANG __clang__
# endif
#endif
-#if !defined(_MDSPAN_COMPILER_MSVC) && !defined(_MDSPAN_COMPILER_MSVC_CLANG)
+#if !defined(MDSPAN_IMPL_COMPILER_MSVC) && !defined(MDSPAN_IMPL_COMPILER_MSVC_CLANG)
# if defined(_MSC_VER)
-# if !defined(_MDSPAN_COMPILER_CLANG)
-# define _MDSPAN_COMPILER_MSVC _MSC_VER
+# if !defined(MDSPAN_IMPL_COMPILER_CLANG)
+# define MDSPAN_IMPL_COMPILER_MSVC _MSC_VER
# else
-# define _MDSPAN_COMPILER_MSVC_CLANG _MSC_VER
+# define MDSPAN_IMPL_COMPILER_MSVC_CLANG _MSC_VER
# endif
# endif
#endif
-#ifndef _MDSPAN_COMPILER_INTEL
+#ifndef MDSPAN_IMPL_COMPILER_INTEL
# ifdef __INTEL_COMPILER
-# define _MDSPAN_COMPILER_INTEL __INTEL_COMPILER
+# define MDSPAN_IMPL_COMPILER_INTEL __INTEL_COMPILER
# endif
#endif
-#ifndef _MDSPAN_COMPILER_APPLECLANG
+#ifndef MDSPAN_IMPL_COMPILER_APPLECLANG
# ifdef __apple_build_version__
-# define _MDSPAN_COMPILER_APPLECLANG __apple_build_version__
+# define MDSPAN_IMPL_COMPILER_APPLECLANG __apple_build_version__
# endif
#endif
-#ifndef _MDSPAN_HAS_CUDA
+#ifndef MDSPAN_IMPL_HAS_CUDA
# if defined(__CUDACC__)
-# define _MDSPAN_HAS_CUDA __CUDACC__
+# define MDSPAN_IMPL_HAS_CUDA __CUDACC__
# endif
#endif
-#ifndef _MDSPAN_HAS_HIP
+#ifndef MDSPAN_IMPL_HAS_HIP
# if defined(__HIPCC__)
-# define _MDSPAN_HAS_HIP __HIPCC__
+# define MDSPAN_IMPL_HAS_HIP __HIPCC__
# endif
#endif
-#ifndef _MDSPAN_HAS_SYCL
+#ifndef MDSPAN_IMPL_HAS_SYCL
# if defined(SYCL_LANGUAGE_VERSION)
-# define _MDSPAN_HAS_SYCL SYCL_LANGUAGE_VERSION
+# define MDSPAN_IMPL_HAS_SYCL SYCL_LANGUAGE_VERSION
# endif
#endif
-#ifndef __has_cpp_attribute
-# define __has_cpp_attribute(x) 0
+#ifndef MDSPAN_IMPL_HAS_CPP_ATTRIBUTE
+# ifndef __has_cpp_attribute
+# define MDSPAN_IMPL_HAS_CPP_ATTRIBUTE(x) 0
+# else
+# define MDSPAN_IMPL_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+# endif
#endif
-#ifndef _MDSPAN_PRESERVE_STANDARD_LAYOUT
+#ifndef MDSPAN_IMPL_PRESERVE_STANDARD_LAYOUT
// Preserve standard layout by default, but we're not removing the old version
// that turns this off until we're sure this doesn't have an unreasonable cost
// to the compiler or optimizer.
-# define _MDSPAN_PRESERVE_STANDARD_LAYOUT 1
+# define MDSPAN_IMPL_PRESERVE_STANDARD_LAYOUT 1
#endif
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-# if ((__has_cpp_attribute(no_unique_address) >= 201803L) && \
- (!defined(__NVCC__) || MDSPAN_HAS_CXX_20) && \
- (!defined(_MDSPAN_COMPILER_MSVC) || MDSPAN_HAS_CXX_20))
-# define _MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS 1
-# define _MDSPAN_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#if !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+# if ((MDSPAN_IMPL_HAS_CPP_ATTRIBUTE(no_unique_address) >= 201803L) && \
+ (!defined(__NVCC__) || ((__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 < 1290) && MDSPAN_HAS_CXX_20)) && \
+ (!defined(MDSPAN_IMPL_COMPILER_MSVC) || MDSPAN_HAS_CXX_20))
+# define MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS 1
+# define MDSPAN_IMPL_NO_UNIQUE_ADDRESS [[no_unique_address]]
# else
-# define _MDSPAN_NO_UNIQUE_ADDRESS
+# define MDSPAN_IMPL_NO_UNIQUE_ADDRESS
# endif
#endif
// NVCC older than 11.6 chokes on the no-unique-address-emulation
// so just pretend to use it (to avoid the full blown EBO workaround
// which NVCC also doesn't like ...), and leave the macro empty
-#ifndef _MDSPAN_NO_UNIQUE_ADDRESS
+#ifndef MDSPAN_IMPL_NO_UNIQUE_ADDRESS
# if defined(__NVCC__)
-# define _MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS 1
-# define _MDSPAN_USE_FAKE_ATTRIBUTE_NO_UNIQUE_ADDRESS
+# define MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS 1
+# define MDSPAN_IMPL_USE_FAKE_ATTRIBUTE_NO_UNIQUE_ADDRESS
# endif
-# define _MDSPAN_NO_UNIQUE_ADDRESS
+# define MDSPAN_IMPL_NO_UNIQUE_ADDRESS
#endif
// AMDs HIP compiler seems to have issues with concepts
// it pretends concepts exist, but doesn't ship <concept>
#ifndef __HIPCC__
-#ifndef _MDSPAN_USE_CONCEPTS
+#ifndef MDSPAN_IMPL_USE_CONCEPTS
# if defined(__cpp_concepts) && __cpp_concepts >= 201507L
-# define _MDSPAN_USE_CONCEPTS 1
+# define MDSPAN_IMPL_USE_CONCEPTS 1
# endif
#endif
#endif
-#ifndef _MDSPAN_USE_FOLD_EXPRESSIONS
+#ifndef MDSPAN_IMPL_USE_FOLD_EXPRESSIONS
# if (defined(__cpp_fold_expressions) && __cpp_fold_expressions >= 201603L) \
|| (!defined(__cpp_fold_expressions) && MDSPAN_HAS_CXX_17)
-# define _MDSPAN_USE_FOLD_EXPRESSIONS 1
+# define MDSPAN_IMPL_USE_FOLD_EXPRESSIONS 1
# endif
#endif
-#ifndef _MDSPAN_USE_INLINE_VARIABLES
+#ifndef MDSPAN_IMPL_USE_INLINE_VARIABLES
# if defined(__cpp_inline_variables) && __cpp_inline_variables >= 201606L \
|| (!defined(__cpp_inline_variables) && MDSPAN_HAS_CXX_17)
-# define _MDSPAN_USE_INLINE_VARIABLES 1
+# define MDSPAN_IMPL_USE_INLINE_VARIABLES 1
# endif
#endif
-#ifndef _MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS
+#ifndef MDSPAN_IMPL_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS
# if (!(defined(__cpp_lib_type_trait_variable_templates) && __cpp_lib_type_trait_variable_templates >= 201510L) \
|| !MDSPAN_HAS_CXX_17)
-# if !(defined(_MDSPAN_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_17)
-# define _MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS 1
+# if !(defined(MDSPAN_IMPL_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_17)
+# define MDSPAN_IMPL_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS 1
# endif
# endif
#endif
-#ifndef _MDSPAN_USE_VARIABLE_TEMPLATES
+#ifndef MDSPAN_IMPL_USE_VARIABLE_TEMPLATES
# if (defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304 && MDSPAN_HAS_CXX_17) \
|| (!defined(__cpp_variable_templates) && MDSPAN_HAS_CXX_17)
-# define _MDSPAN_USE_VARIABLE_TEMPLATES 1
+# define MDSPAN_IMPL_USE_VARIABLE_TEMPLATES 1
# endif
-#endif // _MDSPAN_USE_VARIABLE_TEMPLATES
+#endif // MDSPAN_IMPL_USE_VARIABLE_TEMPLATES
-#ifndef _MDSPAN_USE_CONSTEXPR_14
+#ifndef MDSPAN_IMPL_USE_CONSTEXPR_14
# if (defined(__cpp_constexpr) && __cpp_constexpr >= 201304) \
|| (!defined(__cpp_constexpr) && MDSPAN_HAS_CXX_14) \
&& (!(defined(__INTEL_COMPILER) && __INTEL_COMPILER <= 1700))
-# define _MDSPAN_USE_CONSTEXPR_14 1
+# define MDSPAN_IMPL_USE_CONSTEXPR_14 1
+# endif
+#endif
+
+#ifndef MDSPAN_IMPL_USE_IF_CONSTEXPR_17
+# if (defined(__cpp_if_constexpr) && __cpp_if_constexpr >= 201606) \
+ || (!defined(__cpp_constexpr) && MDSPAN_HAS_CXX_17)
+# define MDSPAN_IMPL_USE_IF_CONSTEXPR_17 1
# endif
#endif
-#ifndef _MDSPAN_USE_INTEGER_SEQUENCE
-# if defined(_MDSPAN_COMPILER_MSVC)
+#ifndef MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14
+# if defined(MDSPAN_IMPL_COMPILER_MSVC)
# if (defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304)
-# define _MDSPAN_USE_INTEGER_SEQUENCE 1
+# define MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14 1
# endif
# endif
#endif
-#ifndef _MDSPAN_USE_INTEGER_SEQUENCE
+#ifndef MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14
# if (defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304) \
|| (!defined(__cpp_lib_integer_sequence) && MDSPAN_HAS_CXX_14) \
/* as far as I can tell, libc++ seems to think this is a C++11 feature... */ \
|| (defined(__GLIBCXX__) && __GLIBCXX__ > 20150422 && __GNUC__ < 5 && !defined(__INTEL_CXX11_MODE__))
// several compilers lie about integer_sequence working properly unless the C++14 standard is used
-# define _MDSPAN_USE_INTEGER_SEQUENCE 1
-# elif defined(_MDSPAN_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_14
+# define MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14 1
+# elif defined(MDSPAN_IMPL_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_14
// appleclang seems to be missing the __cpp_lib_... macros, but doesn't seem to lie about C++14 making
// integer_sequence work
-# define _MDSPAN_USE_INTEGER_SEQUENCE 1
+# define MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14 1
# endif
#endif
-#ifndef _MDSPAN_USE_RETURN_TYPE_DEDUCTION
+#ifndef MDSPAN_IMPL_USE_RETURN_TYPE_DEDUCTION
# if (defined(__cpp_return_type_deduction) && __cpp_return_type_deduction >= 201304) \
|| (!defined(__cpp_return_type_deduction) && MDSPAN_HAS_CXX_14)
-# define _MDSPAN_USE_RETURN_TYPE_DEDUCTION 1
+# define MDSPAN_IMPL_USE_RETURN_TYPE_DEDUCTION 1
# endif
#endif
-#ifndef _MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
+#ifndef MDSPAN_IMPL_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
# if (!defined(__NVCC__) || (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 >= 1170)) && \
((defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201703) || \
(!defined(__cpp_deduction_guides) && MDSPAN_HAS_CXX_17))
-# define _MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
+# define MDSPAN_IMPL_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
# endif
#endif
-#ifndef _MDSPAN_USE_STANDARD_TRAIT_ALIASES
+#ifndef MDSPAN_IMPL_USE_STANDARD_TRAIT_ALIASES
# if (defined(__cpp_lib_transformation_trait_aliases) && __cpp_lib_transformation_trait_aliases >= 201304) \
|| (!defined(__cpp_lib_transformation_trait_aliases) && MDSPAN_HAS_CXX_14)
-# define _MDSPAN_USE_STANDARD_TRAIT_ALIASES 1
-# elif defined(_MDSPAN_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_14
+# define MDSPAN_IMPL_USE_STANDARD_TRAIT_ALIASES 1
+# elif defined(MDSPAN_IMPL_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_14
// appleclang seems to be missing the __cpp_lib_... macros, but doesn't seem to lie about C++14
-# define _MDSPAN_USE_STANDARD_TRAIT_ALIASES 1
+# define MDSPAN_IMPL_USE_STANDARD_TRAIT_ALIASES 1
# endif
#endif
-#ifndef _MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND
+#ifndef MDSPAN_IMPL_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND
# ifdef __GNUC__
# if __GNUC__ < 9
-# define _MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND 1
+# define MDSPAN_IMPL_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND 1
# endif
# endif
#endif
@@ -242,7 +257,7 @@ static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or
# if defined(__cpp_multidimensional_subscript)
// The following if/else is necessary to workaround a clang issue
// relative to using a parameter pack inside a bracket operator in C++2b/C++23 mode
-# if defined(_MDSPAN_COMPILER_CLANG) && \
+# if defined(MDSPAN_IMPL_COMPILER_CLANG) && \
((__clang_major__ < 17) || \
(__clang_major__ == 17 && __clang_minor__ == 0 && \
__clang_patchlevel__ == 0))
@@ -264,27 +279,27 @@ static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or
#endif
#if MDSPAN_USE_BRACKET_OPERATOR
-# define __MDSPAN_OP(mds,...) mds[__VA_ARGS__]
+# define MDSPAN_IMPL_OP(mds,...) mds[__VA_ARGS__]
// Corentins demo compiler for subscript chokes on empty [] call,
// though I believe the proposal supports it?
#ifdef MDSPAN_NO_EMPTY_BRACKET_OPERATOR
-# define __MDSPAN_OP0(mds) mds.accessor().access(mds.data_handle(),0)
+# define MDSPAN_IMPL_OP0(mds) mds.accessor().access(mds.data_handle(),0)
#else
-# define __MDSPAN_OP0(mds) mds[]
-#endif
-# define __MDSPAN_OP1(mds, a) mds[a]
-# define __MDSPAN_OP2(mds, a, b) mds[a,b]
-# define __MDSPAN_OP3(mds, a, b, c) mds[a,b,c]
-# define __MDSPAN_OP4(mds, a, b, c, d) mds[a,b,c,d]
-# define __MDSPAN_OP5(mds, a, b, c, d, e) mds[a,b,c,d,e]
-# define __MDSPAN_OP6(mds, a, b, c, d, e, f) mds[a,b,c,d,e,f]
+# define MDSPAN_IMPL_OP0(mds) mds[]
+#endif
+# define MDSPAN_IMPL_OP1(mds, a) mds[a]
+# define MDSPAN_IMPL_OP2(mds, a, b) mds[a,b]
+# define MDSPAN_IMPL_OP3(mds, a, b, c) mds[a,b,c]
+# define MDSPAN_IMPL_OP4(mds, a, b, c, d) mds[a,b,c,d]
+# define MDSPAN_IMPL_OP5(mds, a, b, c, d, e) mds[a,b,c,d,e]
+# define MDSPAN_IMPL_OP6(mds, a, b, c, d, e, f) mds[a,b,c,d,e,f]
#else
-# define __MDSPAN_OP(mds,...) mds(__VA_ARGS__)
-# define __MDSPAN_OP0(mds) mds()
-# define __MDSPAN_OP1(mds, a) mds(a)
-# define __MDSPAN_OP2(mds, a, b) mds(a,b)
-# define __MDSPAN_OP3(mds, a, b, c) mds(a,b,c)
-# define __MDSPAN_OP4(mds, a, b, c, d) mds(a,b,c,d)
-# define __MDSPAN_OP5(mds, a, b, c, d, e) mds(a,b,c,d,e)
-# define __MDSPAN_OP6(mds, a, b, c, d, e, f) mds(a,b,c,d,e,f)
+# define MDSPAN_IMPL_OP(mds,...) mds(__VA_ARGS__)
+# define MDSPAN_IMPL_OP0(mds) mds()
+# define MDSPAN_IMPL_OP1(mds, a) mds(a)
+# define MDSPAN_IMPL_OP2(mds, a, b) mds(a,b)
+# define MDSPAN_IMPL_OP3(mds, a, b, c) mds(a,b,c)
+# define MDSPAN_IMPL_OP4(mds, a, b, c, d) mds(a,b,c,d)
+# define MDSPAN_IMPL_OP5(mds, a, b, c, d, e) mds(a,b,c,d,e)
+# define MDSPAN_IMPL_OP6(mds, a, b, c, d, e, f) mds(a,b,c,d,e,f)
#endif
diff --git a/ext/mdspan/include/experimental/__p0009_bits/default_accessor.hpp b/ext/mdspan/include/experimental/__p0009_bits/default_accessor.hpp
index ea0f537..b858fba 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/default_accessor.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/default_accessor.hpp
@@ -34,7 +34,7 @@ struct default_accessor {
MDSPAN_TEMPLATE_REQUIRES(
class OtherElementType,
/* requires */ (
- _MDSPAN_TRAIT(std::is_convertible, OtherElementType(*)[], element_type(*)[])
+ MDSPAN_IMPL_TRAIT(std::is_convertible, OtherElementType(*)[], element_type(*)[])
)
)
MDSPAN_INLINE_FUNCTION
diff --git a/ext/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp b/ext/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp
index 2e29da1..ffa4a6b 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp
@@ -28,7 +28,7 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
#if defined(__cpp_lib_span)
using std::dynamic_extent;
#else
-_MDSPAN_INLINE_VARIABLE constexpr auto dynamic_extent = std::numeric_limits<size_t>::max();
+MDSPAN_IMPL_INLINE_VARIABLE constexpr auto dynamic_extent = std::numeric_limits<size_t>::max();
#endif
} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/ext/mdspan/include/experimental/__p0009_bits/extents.hpp b/ext/mdspan/include/experimental/__p0009_bits/extents.hpp
index d58d377..ab10ba3 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/extents.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/extents.hpp
@@ -34,7 +34,7 @@ namespace detail {
// can't be a private member function for some reason.
template <size_t... Extents, size_t... OtherExtents>
MDSPAN_INLINE_FUNCTION
-static constexpr std::integral_constant<bool, false> __check_compatible_extents(
+constexpr std::integral_constant<bool, false> impl_check_compatible_extents(
std::integral_constant<bool, false>,
std::integer_sequence<size_t, Extents...>,
std::integer_sequence<size_t, OtherExtents...>) noexcept {
@@ -43,7 +43,7 @@ static constexpr std::integral_constant<bool, false> __check_compatible_extents(
// This helper prevents ICE's on MSVC.
template <size_t Lhs, size_t Rhs>
-struct __compare_extent_compatible : std::integral_constant<bool,
+struct impl_compare_extent_compatible : std::integral_constant<bool,
Lhs == dynamic_extent ||
Rhs == dynamic_extent ||
Lhs == Rhs>
@@ -51,9 +51,9 @@ struct __compare_extent_compatible : std::integral_constant<bool,
template <size_t... Extents, size_t... OtherExtents>
MDSPAN_INLINE_FUNCTION
-static constexpr std::integral_constant<
- bool, _MDSPAN_FOLD_AND(__compare_extent_compatible<Extents, OtherExtents>::value)>
-__check_compatible_extents(
+constexpr std::integral_constant<
+ bool, MDSPAN_IMPL_FOLD_AND(impl_compare_extent_compatible<Extents, OtherExtents>::value)>
+impl_check_compatible_extents(
std::integral_constant<bool, true>,
std::integer_sequence<size_t, Extents...>,
std::integer_sequence<size_t, OtherExtents...>) noexcept {
@@ -62,10 +62,10 @@ __check_compatible_extents(
template<class IndexType, class ... Arguments>
MDSPAN_INLINE_FUNCTION
-static constexpr bool are_valid_indices() {
+constexpr bool are_valid_indices() {
return
- _MDSPAN_FOLD_AND(std::is_convertible<Arguments, IndexType>::value) &&
- _MDSPAN_FOLD_AND(std::is_nothrow_constructible<IndexType, Arguments>::value);
+ MDSPAN_IMPL_FOLD_AND(std::is_convertible<Arguments, IndexType>::value) &&
+ MDSPAN_IMPL_FOLD_AND(std::is_nothrow_constructible<IndexType, Arguments>::value);
}
// ------------------------------------------------------------------
@@ -154,7 +154,7 @@ struct index_sequence_scan_impl<R, FirstVal, Values...> {
template <size_t R, size_t FirstVal>
struct index_sequence_scan_impl<R, FirstVal> {
#if defined(__NVCC__) || defined(__NVCOMPILER) || \
- defined(_MDSPAN_COMPILER_INTEL)
+ defined(MDSPAN_IMPL_COMPILER_INTEL)
// NVCC warns about pointless comparison with 0 for R==0 and r being const
// evaluatable and also 0.
MDSPAN_INLINE_FUNCTION
@@ -214,10 +214,10 @@ private:
using static_vals_t = static_array<TStatic, Values...>;
constexpr static size_t m_size = sizeof...(Values);
constexpr static size_t m_size_dynamic =
- _MDSPAN_FOLD_PLUS_RIGHT((Values == dyn_tag), 0);
+ MDSPAN_IMPL_FOLD_PLUS_RIGHT((Values == dyn_tag), 0);
// Dynamic values member
- _MDSPAN_NO_UNIQUE_ADDRESS possibly_empty_array<TDynamic, m_size_dynamic>
+ MDSPAN_IMPL_NO_UNIQUE_ADDRESS possibly_empty_array<TDynamic, m_size_dynamic>
m_dyn_vals;
// static mapping of indices to the position in the dynamic values array
@@ -294,7 +294,7 @@ public:
m_dyn_vals[dyn_map_t::get(r)] = values[r];
}
// Precondition check
-#ifdef _MDSPAN_DEBUG
+#ifdef MDSPAN_DEBUG
else {
assert(values[r] == static_cast<TDynamic>(static_val));
}
@@ -309,7 +309,7 @@ public:
constexpr maybe_static_array(const std::array<T, N> &vals) {
static_assert((N == m_size), "Invalid number of values.");
// Precondition check
-#ifdef _MDSPAN_DEBUG
+#ifdef MDSPAN_DEBUG
assert(N == m_size);
#endif
for (size_t r = 0; r < m_size; r++) {
@@ -318,7 +318,7 @@ public:
m_dyn_vals[dyn_map_t::get(r)] = static_cast<TDynamic>(vals[r]);
}
// Precondition check
-#ifdef _MDSPAN_DEBUG
+#ifdef MDSPAN_DEBUG
else {
assert(static_cast<TDynamic>(vals[r]) ==
static_cast<TDynamic>(static_val));
@@ -334,7 +334,7 @@ public:
MDSPAN_INLINE_FUNCTION
constexpr maybe_static_array(const std::span<T, N> &vals) {
static_assert((N == m_size) || (m_size == dynamic_extent));
-#ifdef _MDSPAN_DEBUG
+#ifdef MDSPAN_DEBUG
assert(N == m_size);
#endif
for (size_t r = 0; r < m_size; r++) {
@@ -342,7 +342,7 @@ public:
if (static_val == dyn_tag) {
m_dyn_vals[dyn_map_t::get(r)] = static_cast<TDynamic>(vals[r]);
}
-#ifdef _MDSPAN_DEBUG
+#ifdef MDSPAN_DEBUG
else {
assert(static_cast<TDynamic>(vals[r]) ==
static_cast<TDynamic>(static_val));
@@ -359,8 +359,11 @@ public:
MDSPAN_INLINE_FUNCTION
constexpr TDynamic value(size_t r) const {
TStatic static_val = static_vals_t::get(r);
- return static_val == dyn_tag ? m_dyn_vals[dyn_map_t::get(r)]
- : static_cast<TDynamic>(static_val);
+
+ // FIXME: workaround for nvhpc OpenACC compiler bug
+ TStatic dyn_tag_copy = dyn_tag;
+ return static_val == dyn_tag_copy ? m_dyn_vals[dyn_map_t::get(r)]
+ : static_cast<TDynamic>(static_val);
}
MDSPAN_INLINE_FUNCTION
constexpr TDynamic operator[](size_t r) const { return value(r); }
@@ -398,12 +401,12 @@ public:
private:
constexpr static rank_type m_rank = sizeof...(Extents);
constexpr static rank_type m_rank_dynamic =
- _MDSPAN_FOLD_PLUS_RIGHT((Extents == dynamic_extent), /* + ... + */ 0);
+ MDSPAN_IMPL_FOLD_PLUS_RIGHT((Extents == dynamic_extent), /* + ... + */ 0);
// internal storage type using maybe_static_array
using vals_t =
detail::maybe_static_array<IndexType, size_t, dynamic_extent, Extents...>;
- _MDSPAN_NO_UNIQUE_ADDRESS vals_t m_vals;
+ MDSPAN_IMPL_NO_UNIQUE_ADDRESS vals_t m_vals;
public:
// [mdspan.extents.obs], observers of multidimensional index space
@@ -428,9 +431,9 @@ public:
MDSPAN_TEMPLATE_REQUIRES(
class... OtherIndexTypes,
/* requires */ (
- _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_convertible, OtherIndexTypes,
+ MDSPAN_IMPL_FOLD_AND(MDSPAN_IMPL_TRAIT(std::is_convertible, OtherIndexTypes,
index_type) /* && ... */) &&
- _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_nothrow_constructible, index_type,
+ MDSPAN_IMPL_FOLD_AND(MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type,
OtherIndexTypes) /* && ... */) &&
(sizeof...(OtherIndexTypes) == m_rank ||
sizeof...(OtherIndexTypes) == m_rank_dynamic)))
@@ -442,8 +445,8 @@ public:
class OtherIndexType, size_t N,
/* requires */
(
- _MDSPAN_TRAIT(std::is_convertible, const OtherIndexType&, index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type,
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const OtherIndexType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type,
const OtherIndexType&) &&
(N == m_rank || N == m_rank_dynamic)))
MDSPAN_INLINE_FUNCTION
@@ -455,8 +458,8 @@ public:
MDSPAN_TEMPLATE_REQUIRES(
class OtherIndexType, size_t N,
/* requires */
- (_MDSPAN_TRAIT(std::is_convertible, const OtherIndexType&, index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const OtherIndexType&) &&
+ (MDSPAN_IMPL_TRAIT(std::is_convertible, const OtherIndexType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const OtherIndexType&) &&
(N == m_rank || N == m_rank_dynamic)))
MDSPAN_INLINE_FUNCTION
MDSPAN_CONDITIONAL_EXPLICIT(N != m_rank_dynamic)
@@ -474,11 +477,11 @@ private:
/* requires */ ((R < m_rank) && (static_extent(R) == dynamic_extent)))
MDSPAN_INLINE_FUNCTION
constexpr
- vals_t __construct_vals_from_extents(std::integral_constant<size_t, DynCount>,
+ vals_t impl_construct_vals_from_extents(std::integral_constant<size_t, DynCount>,
std::integral_constant<size_t, R>,
const OtherExtents &exts,
DynamicValues... dynamic_values) noexcept {
- return __construct_vals_from_extents(
+ return impl_construct_vals_from_extents(
std::integral_constant<size_t, DynCount + 1>(),
std::integral_constant<size_t, R + 1>(), exts, dynamic_values...,
exts.extent(R));
@@ -489,11 +492,11 @@ private:
/* requires */ ((R < m_rank) && (static_extent(R) != dynamic_extent)))
MDSPAN_INLINE_FUNCTION
constexpr
- vals_t __construct_vals_from_extents(std::integral_constant<size_t, DynCount>,
+ vals_t impl_construct_vals_from_extents(std::integral_constant<size_t, DynCount>,
std::integral_constant<size_t, R>,
const OtherExtents &exts,
DynamicValues... dynamic_values) noexcept {
- return __construct_vals_from_extents(
+ return impl_construct_vals_from_extents(
std::integral_constant<size_t, DynCount>(),
std::integral_constant<size_t, R + 1>(), exts, dynamic_values...);
}
@@ -503,7 +506,7 @@ private:
/* requires */ ((R == m_rank) && (DynCount == m_rank_dynamic)))
MDSPAN_INLINE_FUNCTION
constexpr
- vals_t __construct_vals_from_extents(std::integral_constant<size_t, DynCount>,
+ vals_t impl_construct_vals_from_extents(std::integral_constant<size_t, DynCount>,
std::integral_constant<size_t, R>,
const OtherExtents &,
DynamicValues... dynamic_values) noexcept {
@@ -519,7 +522,7 @@ public:
(
/* multi-stage check to protect from invalid pack expansion when sizes
don't match? */
- decltype(detail::__check_compatible_extents(
+ decltype(detail::impl_check_compatible_extents(
// using: sizeof...(Extents) == sizeof...(OtherExtents) as the second argument fails with MSVC+NVCC with some obscure expansion error
// MSVC: 19.38.33133 NVCC: 12.0
std::integral_constant<bool, extents<int, Extents...>::rank() == extents<int, OtherExtents...>::rank()>{},
@@ -534,7 +537,7 @@ public:
(std::numeric_limits<index_type>::max() <
std::numeric_limits<OtherIndexType>::max()))
constexpr extents(const extents<OtherIndexType, OtherExtents...> &other) noexcept
- : m_vals(__construct_vals_from_extents(
+ : m_vals(impl_construct_vals_from_extents(
std::integral_constant<size_t, 0>(),
std::integral_constant<size_t, 0>(), other)) {}
@@ -563,13 +566,13 @@ namespace detail {
template <class IndexType, size_t Rank,
class Extents = ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType>>
-struct __make_dextents;
+struct impl_make_dextents;
template <class IndexType, size_t Rank, size_t... ExtentsPack>
-struct __make_dextents<
+struct impl_make_dextents<
IndexType, Rank, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType, ExtentsPack...>>
{
- using type = typename __make_dextents<
+ using type = typename impl_make_dextents<
IndexType, Rank - 1,
::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType,
::MDSPAN_IMPL_STANDARD_NAMESPACE::dynamic_extent,
@@ -577,7 +580,7 @@ struct __make_dextents<
};
template <class IndexType, size_t... ExtentsPack>
-struct __make_dextents<
+struct impl_make_dextents<
IndexType, 0, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType, ExtentsPack...>>
{
using type = ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType, ExtentsPack...>;
@@ -587,10 +590,10 @@ struct __make_dextents<
// [mdspan.extents.dextents], alias template
template <class IndexType, size_t Rank>
-using dextents = typename detail::__make_dextents<IndexType, Rank>::type;
+using dextents = typename detail::impl_make_dextents<IndexType, Rank>::type;
// Deduction guide for extents
-#if defined(_MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
+#if defined(MDSPAN_IMPL_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
template <class... IndexTypes>
extents(IndexTypes...)
-> extents<size_t,
@@ -600,10 +603,10 @@ extents(IndexTypes...)
// Helper type traits for identifying a class as extents.
namespace detail {
-template <class T> struct __is_extents : ::std::false_type {};
+template <class T> struct impl_is_extents : ::std::false_type {};
template <class IndexType, size_t... ExtentsPack>
-struct __is_extents<::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType, ExtentsPack...>>
+struct impl_is_extents<::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType, ExtentsPack...>>
: ::std::true_type {};
template <class T>
@@ -612,7 +615,7 @@ inline
#else
static
#endif
-constexpr bool __is_extents_v = __is_extents<T>::value;
+constexpr bool impl_is_extents_v = impl_is_extents<T>::value;
template<class InputIndexType, class ExtentsIndexType>
MDSPAN_INLINE_FUNCTION
@@ -622,7 +625,7 @@ check_lower_bound(InputIndexType user_index,
std::true_type /* is_signed */)
{
(void) user_index; // prevent unused variable warning
-#ifdef _MDSPAN_DEBUG
+#ifdef MDSPAN_DEBUG
assert(static_cast<ExtentsIndexType>(user_index) >= 0);
#endif
}
@@ -643,14 +646,14 @@ check_upper_bound(InputIndexType user_index,
{
(void) user_index; // prevent unused variable warnings
(void) current_extent;
-#ifdef _MDSPAN_DEBUG
+#ifdef MDSPAN_DEBUG
assert(static_cast<ExtentsIndexType>(user_index) < current_extent);
#endif
}
// Returning true to use AND fold instead of comma
// CPP14 mode doesn't like the use of void expressions
-// with the way the _MDSPAN_FOLD_AND is set up
+// with the way the MDSPAN_IMPL_FOLD_AND is set up
template<class InputIndex, class ExtentsIndexType>
MDSPAN_INLINE_FUNCTION
constexpr bool
@@ -673,7 +676,7 @@ check_all_indices_helper(std::index_sequence<RankIndices...>,
Indices... indices)
{
// Suppress warning about statement has no effect
- (void) _MDSPAN_FOLD_AND(
+ (void) MDSPAN_IMPL_FOLD_AND(
(check_one_index(indices, exts.extent(RankIndices)))
);
}
diff --git a/ext/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp b/ext/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp
index bd4b5c6..a1e296a 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp
@@ -21,6 +21,6 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
struct full_extent_t { explicit full_extent_t() = default; };
-_MDSPAN_INLINE_VARIABLE constexpr auto full_extent = full_extent_t{ };
+MDSPAN_IMPL_INLINE_VARIABLE constexpr auto full_extent = full_extent_t{ };
} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/ext/mdspan/include/experimental/__p0009_bits/layout_left.hpp b/ext/mdspan/include/experimental/__p0009_bits/layout_left.hpp
index ed8aae0..e119800 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/layout_left.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/layout_left.hpp
@@ -39,7 +39,7 @@ class layout_left::mapping {
using layout_type = layout_left;
private:
- static_assert(detail::__is_extents_v<extents_type>,
+ static_assert(detail::impl_is_extents_v<extents_type>,
MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_left::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents.");
template <class>
@@ -47,25 +47,25 @@ class layout_left::mapping {
// i0+(i1 + E(1)*(i2 + E(2)*i3))
template <size_t r, size_t Rank>
- struct __rank_count {};
+ struct rank_count {};
template <size_t r, size_t Rank, class I, class... Indices>
- _MDSPAN_HOST_DEVICE
- constexpr index_type __compute_offset(
- __rank_count<r,Rank>, const I& i, Indices... idx) const {
- return __compute_offset(__rank_count<r+1,Rank>(), idx...) *
- __extents.extent(r) + i;
+ MDSPAN_IMPL_HOST_DEVICE
+ constexpr index_type compute_offset(
+ rank_count<r,Rank>, const I& i, Indices... idx) const {
+ return compute_offset(rank_count<r+1,Rank>(), idx...) *
+ m_extents.extent(r) + i;
}
template<class I>
- _MDSPAN_HOST_DEVICE
- constexpr index_type __compute_offset(
- __rank_count<extents_type::rank()-1,extents_type::rank()>, const I& i) const {
+ MDSPAN_IMPL_HOST_DEVICE
+ constexpr index_type compute_offset(
+ rank_count<extents_type::rank()-1,extents_type::rank()>, const I& i) const {
return i;
}
- _MDSPAN_HOST_DEVICE
- constexpr index_type __compute_offset(__rank_count<0,0>) const { return 0; }
+ MDSPAN_IMPL_HOST_DEVICE
+ constexpr index_type compute_offset(rank_count<0,0>) const { return 0; }
public:
@@ -74,21 +74,21 @@ class layout_left::mapping {
MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default;
- _MDSPAN_HOST_DEVICE
- constexpr mapping(extents_type const& __exts) noexcept
- :__extents(__exts)
+ MDSPAN_IMPL_HOST_DEVICE
+ constexpr mapping(extents_type const& exts) noexcept
+ :m_extents(exts)
{ }
MDSPAN_TEMPLATE_REQUIRES(
class OtherExtents,
/* requires */ (
- _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents)
+ MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents)
)
)
MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
- MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
+ MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14
mapping(mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
- :__extents(other.extents())
+ :m_extents(other.extents())
{
/*
* TODO: check precondition
@@ -99,14 +99,14 @@ class layout_left::mapping {
MDSPAN_TEMPLATE_REQUIRES(
class OtherExtents,
/* requires */ (
- _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents) &&
+ MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents) &&
(extents_type::rank() <= 1)
)
)
MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
- MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
+ MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14
mapping(layout_right::mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
- :__extents(other.extents())
+ :m_extents(other.extents())
{
/*
* TODO: check precondition
@@ -118,61 +118,62 @@ class layout_left::mapping {
/**
* Converting constructor from `layout_left_padded::mapping`.
*
- * This overload participates in overload resolution only if _Mapping is a layout_left_padded mapping and
- * extents_type is constructible from _Mapping::extents_type.
+ * This overload participates in overload resolution only if Mapping is a layout_left_padded mapping and
+ * extents_type is constructible from Mapping::extents_type.
*
* \note There is currently a difference from p2642r2, where this function is specified as taking
* `layout_left_padded< padding_value >::mapping< Extents>`. However, this makes `padding_value` non-deducible.
*/
MDSPAN_TEMPLATE_REQUIRES(
- class _Mapping,
+ class Mapping,
/* requires */ (
- MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_left_padded_mapping<_Mapping>::value
- && std::is_constructible_v<extents_type, typename _Mapping::extents_type>
+ MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_left_padded_mapping<Mapping>::value
+ && std::is_constructible_v<extents_type, typename Mapping::extents_type>
)
)
- MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v<typename _Mapping::extents_type, extents_type>))
- mapping(const _Mapping& __other) noexcept
- : __extents(__other.extents())
+ MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v<typename Mapping::extents_type, extents_type>))
+ MDSPAN_INLINE_FUNCTION constexpr
+ mapping(const Mapping& other) noexcept
+ : m_extents(other.extents())
{
MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::
check_padded_layout_converting_constructor_mandates<
- extents_type, _Mapping>(detail::with_rank<extents_type::rank()>{});
+ extents_type, Mapping>(detail::with_rank<extents_type::rank()>{});
MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::
check_padded_layout_converting_constructor_preconditions<
- extents_type>(detail::with_rank<extents_type::rank()>{}, __other);
+ extents_type>(detail::with_rank<extents_type::rank()>{}, other);
}
#endif
MDSPAN_TEMPLATE_REQUIRES(
class OtherExtents,
/* requires */ (
- _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents)
+ MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents)
)
)
MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0))
- MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
+ MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14
mapping(layout_stride::mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
- :__extents(other.extents())
+ :m_extents(other.extents())
{
/*
* TODO: check precondition
* other.required_span_size() is a representable value of type index_type
*/
- detail::validate_strides(detail::with_rank<extents_type::rank()>{}, layout_left{}, __extents, other);
+ detail::validate_strides(detail::with_rank<extents_type::rank()>{}, layout_left{}, m_extents, other);
}
- MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default;
+ MDSPAN_INLINE_FUNCTION_DEFAULTED MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default;
MDSPAN_INLINE_FUNCTION
constexpr const extents_type& extents() const noexcept {
- return __extents;
+ return m_extents;
}
MDSPAN_INLINE_FUNCTION
constexpr index_type required_span_size() const noexcept {
index_type value = 1;
- for(rank_type r=0; r<extents_type::rank(); r++) value*=__extents.extent(r);
+ for(rank_type r=0; r<extents_type::rank(); r++) value*=m_extents.extent(r);
return value;
}
@@ -185,12 +186,12 @@ class layout_left::mapping {
(detail::are_valid_indices<index_type, Indices...>())
)
)
- _MDSPAN_HOST_DEVICE
+ MDSPAN_IMPL_HOST_DEVICE
constexpr index_type operator()(Indices... idxs) const noexcept {
#if ! defined(NDEBUG)
detail::check_all_indices(this->extents(), idxs...);
#endif // ! NDEBUG
- return __compute_offset(__rank_count<0, extents_type::rank()>(), static_cast<index_type>(idxs)...);
+ return compute_offset(rank_count<0, extents_type::rank()>(), static_cast<index_type>(idxs)...);
}
@@ -210,7 +211,7 @@ class layout_left::mapping {
#endif
{
index_type value = 1;
- for(rank_type r=0; r<i; r++) value*=__extents.extent(r);
+ for(rank_type r=0; r<i; r++) value*=m_extents.extent(r);
return value;
}
@@ -238,17 +239,17 @@ class layout_left::mapping {
// Not really public, but currently needed to implement fully constexpr useable submdspan:
template<size_t N, class SizeType, size_t ... E, size_t ... Idx>
MDSPAN_INLINE_FUNCTION
- constexpr index_type __get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents<SizeType, E...>,std::integer_sequence<size_t, Idx...>) const {
- return _MDSPAN_FOLD_TIMES_RIGHT((Idx<N? __extents.template __extent<Idx>():1),1);
+ constexpr index_type impl_get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents<SizeType, E...>,std::integer_sequence<size_t, Idx...>) const {
+ return MDSPAN_IMPL_FOLD_TIMES_RIGHT((Idx<N? m_extents.template extent<Idx>():1),1);
}
template<size_t N>
MDSPAN_INLINE_FUNCTION
- constexpr index_type __stride() const noexcept {
- return __get_stride<N>(__extents, std::make_index_sequence<extents_type::rank()>());
+ constexpr index_type impl_stide() const noexcept {
+ return impl_get_stride<N>(m_extents, std::make_index_sequence<extents_type::rank()>());
}
private:
- _MDSPAN_NO_UNIQUE_ADDRESS extents_type __extents{};
+ MDSPAN_IMPL_NO_UNIQUE_ADDRESS extents_type m_extents{};
// [mdspan.submdspan.mapping], submdspan mapping specialization
template<class... SliceSpecifiers>
@@ -266,4 +267,3 @@ private:
} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
-
diff --git a/ext/mdspan/include/experimental/__p0009_bits/layout_right.hpp b/ext/mdspan/include/experimental/__p0009_bits/layout_right.hpp
index 26115e7..d95c180 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/layout_right.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/layout_right.hpp
@@ -37,7 +37,7 @@ class layout_right::mapping {
using layout_type = layout_right;
private:
- static_assert(detail::__is_extents_v<extents_type>,
+ static_assert(detail::impl_is_extents_v<extents_type>,
MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_right::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents.");
template <class>
@@ -45,29 +45,29 @@ class layout_right::mapping {
// i0+(i1 + E(1)*(i2 + E(2)*i3))
template <size_t r, size_t Rank>
- struct __rank_count {};
+ struct rank_count {};
template <size_t r, size_t Rank, class I, class... Indices>
- _MDSPAN_HOST_DEVICE
- constexpr index_type __compute_offset(
- index_type offset, __rank_count<r,Rank>, const I& i, Indices... idx) const {
- return __compute_offset(offset * __extents.extent(r) + i,__rank_count<r+1,Rank>(), idx...);
+ MDSPAN_IMPL_HOST_DEVICE
+ constexpr index_type compute_offset(
+ index_type offset, rank_count<r,Rank>, const I& i, Indices... idx) const {
+ return compute_offset(offset * m_extents.extent(r) + i,rank_count<r+1,Rank>(), idx...);
}
template<class I, class ... Indices>
- _MDSPAN_HOST_DEVICE
- constexpr index_type __compute_offset(
- __rank_count<0,extents_type::rank()>, const I& i, Indices... idx) const {
- return __compute_offset(i,__rank_count<1,extents_type::rank()>(),idx...);
+ MDSPAN_IMPL_HOST_DEVICE
+ constexpr index_type compute_offset(
+ rank_count<0,extents_type::rank()>, const I& i, Indices... idx) const {
+ return compute_offset(i,rank_count<1,extents_type::rank()>(),idx...);
}
- _MDSPAN_HOST_DEVICE
- constexpr index_type __compute_offset(size_t offset, __rank_count<extents_type::rank(), extents_type::rank()>) const {
+ MDSPAN_IMPL_HOST_DEVICE
+ constexpr index_type compute_offset(size_t offset, rank_count<extents_type::rank(), extents_type::rank()>) const {
return static_cast<index_type>(offset);
}
- _MDSPAN_HOST_DEVICE
- constexpr index_type __compute_offset(__rank_count<0,0>) const { return 0; }
+ MDSPAN_IMPL_HOST_DEVICE
+ constexpr index_type compute_offset(rank_count<0,0>) const { return 0; }
public:
@@ -76,21 +76,21 @@ class layout_right::mapping {
MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default;
- _MDSPAN_HOST_DEVICE
- constexpr mapping(extents_type const& __exts) noexcept
- :__extents(__exts)
+ MDSPAN_IMPL_HOST_DEVICE
+ constexpr mapping(extents_type const& exts) noexcept
+ :m_extents(exts)
{ }
MDSPAN_TEMPLATE_REQUIRES(
class OtherExtents,
/* requires */ (
- _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents)
+ MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents)
)
)
MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
- MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
+ MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14
mapping(mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
- :__extents(other.extents())
+ :m_extents(other.extents())
{
/*
* TODO: check precondition
@@ -101,14 +101,14 @@ class layout_right::mapping {
MDSPAN_TEMPLATE_REQUIRES(
class OtherExtents,
/* requires */ (
- _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents) &&
+ MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents) &&
(extents_type::rank() <= 1)
)
)
MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
- MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
+ MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14
mapping(layout_left::mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
- :__extents(other.extents())
+ :m_extents(other.extents())
{
/*
* TODO: check precondition
@@ -119,60 +119,61 @@ class layout_right::mapping {
/**
* Converting constructor from `layout_right_padded::mapping`.
*
- * This overload participates in overload resolution only if _Mapping is a layout_right_padded mapping and
- * extents_type is constructible from _Mapping::extents_type.
+ * This overload participates in overload resolution only if Mapping is a layout_right_padded mapping and
+ * extents_type is constructible from Mapping::extents_type.
*
* \note There is currently a difference from p2642r2, where this function is specified as taking
* `layout_right_padded< padding_value >::mapping< Extents>`. However, this makes `padding_value` non-deducible.
*/
#if MDSPAN_HAS_CXX_17
MDSPAN_TEMPLATE_REQUIRES(
- class _Mapping,
+ class Mapping,
/* requires */ (
- MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_right_padded_mapping<_Mapping>::value
- && std::is_constructible_v<extents_type, typename _Mapping::extents_type>))
- MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v<typename _Mapping::extents_type, extents_type>))
- mapping(const _Mapping &__other) noexcept
- : __extents(__other.extents())
+ MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_right_padded_mapping<Mapping>::value
+ && std::is_constructible_v<extents_type, typename Mapping::extents_type>))
+ MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v<typename Mapping::extents_type, extents_type>))
+ MDSPAN_INLINE_FUNCTION constexpr
+ mapping(const Mapping &other) noexcept
+ : m_extents(other.extents())
{
MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::
check_padded_layout_converting_constructor_mandates<
- extents_type, _Mapping>(detail::with_rank<extents_type::rank()>{});
+ extents_type, Mapping>(detail::with_rank<extents_type::rank()>{});
MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::
check_padded_layout_converting_constructor_preconditions<
- extents_type>(detail::with_rank<extents_type::rank()>{}, __other);
+ extents_type>(detail::with_rank<extents_type::rank()>{}, other);
}
#endif
MDSPAN_TEMPLATE_REQUIRES(
class OtherExtents,
/* requires */ (
- _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents)
+ MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents)
)
)
MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0))
- MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
+ MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14
mapping(layout_stride::mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
- :__extents(other.extents())
+ :m_extents(other.extents())
{
/*
* TODO: check precondition
* other.required_span_size() is a representable value of type index_type
*/
- detail::validate_strides(detail::with_rank<extents_type::rank()>{}, layout_right{}, __extents, other);
+ detail::validate_strides(detail::with_rank<extents_type::rank()>{}, layout_right{}, m_extents, other);
}
- MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default;
+ MDSPAN_INLINE_FUNCTION_DEFAULTED MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default;
MDSPAN_INLINE_FUNCTION
constexpr const extents_type& extents() const noexcept {
- return __extents;
+ return m_extents;
}
MDSPAN_INLINE_FUNCTION
constexpr index_type required_span_size() const noexcept {
index_type value = 1;
- for(rank_type r=0; r != extents_type::rank(); ++r) value*=__extents.extent(r);
+ for(rank_type r=0; r != extents_type::rank(); ++r) value*=m_extents.extent(r);
return value;
}
@@ -185,12 +186,12 @@ class layout_right::mapping {
(detail::are_valid_indices<index_type, Indices...>())
)
)
- _MDSPAN_HOST_DEVICE
+ MDSPAN_IMPL_HOST_DEVICE
constexpr index_type operator()(Indices... idxs) const noexcept {
#if ! defined(NDEBUG)
detail::check_all_indices(this->extents(), idxs...);
#endif // ! NDEBUG
- return __compute_offset(__rank_count<0, extents_type::rank()>(), static_cast<index_type>(idxs)...);
+ return compute_offset(rank_count<0, extents_type::rank()>(), static_cast<index_type>(idxs)...);
}
MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; }
@@ -207,7 +208,7 @@ class layout_right::mapping {
#endif
{
index_type value = 1;
- for(rank_type r=extents_type::rank()-1; r>i; r--) value*=__extents.extent(r);
+ for(rank_type r=extents_type::rank()-1; r>i; r--) value*=m_extents.extent(r);
return value;
}
@@ -235,17 +236,17 @@ class layout_right::mapping {
// Not really public, but currently needed to implement fully constexpr useable submdspan:
template<size_t N, class SizeType, size_t ... E, size_t ... Idx>
MDSPAN_INLINE_FUNCTION
- constexpr index_type __get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents<SizeType, E...>,std::integer_sequence<size_t, Idx...>) const {
- return _MDSPAN_FOLD_TIMES_RIGHT((Idx>N? __extents.template __extent<Idx>():1),1);
+ constexpr index_type impl_get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents<SizeType, E...>,std::integer_sequence<size_t, Idx...>) const {
+ return MDSPAN_IMPL_FOLD_TIMES_RIGHT((Idx>N? m_extents.template extent<Idx>():1),1);
}
template<size_t N>
MDSPAN_INLINE_FUNCTION
- constexpr index_type __stride() const noexcept {
- return __get_stride<N>(__extents, std::make_index_sequence<extents_type::rank()>());
+ constexpr index_type impl_stide() const noexcept {
+ return impl_get_stride<N>(m_extents, std::make_index_sequence<extents_type::rank()>());
}
private:
- _MDSPAN_NO_UNIQUE_ADDRESS extents_type __extents{};
+ MDSPAN_IMPL_NO_UNIQUE_ADDRESS extents_type m_extents{};
// [mdspan.submdspan.mapping], submdspan mapping specialization
template<class... SliceSpecifiers>
@@ -262,4 +263,3 @@ private:
};
} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
-
diff --git a/ext/mdspan/include/experimental/__p0009_bits/layout_stride.hpp b/ext/mdspan/include/experimental/__p0009_bits/layout_stride.hpp
index 47ef268..7f301a9 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/layout_stride.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/layout_stride.hpp
@@ -21,7 +21,7 @@
#include "compressed_pair.hpp"
#include "utility.hpp"
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+#if !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
# include "no_unique_address.hpp"
#endif
@@ -32,7 +32,7 @@
#ifdef __cpp_lib_span
#include <span>
#endif
-#if defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20 && defined(__cpp_lib_concepts)
+#if defined(MDSPAN_IMPL_USE_CONCEPTS) && MDSPAN_HAS_CXX_20 && defined(__cpp_lib_concepts)
# include <concepts>
#endif
@@ -48,33 +48,51 @@ struct layout_right {
};
namespace detail {
+#if MDSPAN_HAS_CXX_17
+ using std::void_t;
+#else
+ template<class...> using void_t = void;
+#endif
+ // FIXME GCC <= 12: workaround gcc-12 bug that shows up in Kokkos; compilation fails when Mapping doesn't have
+ // extents_type. Normally this should just be a substitution failure, but causes an error with GCC <= 12
+ // FIXME MSVC: I guess MSVC has a similar issue when it hits Layout::template mapping
+ template<class, class, class = void, class = void>
+ struct is_mapping_of_impl : std::false_type {};
+
+ // FIXME GCC <= 12: We can't just do a conjunction of the two conditions, because the affected GCC versions seem to not
+ // short-circuit when resolving the substitution of Mapping
+ template<class Mapping, class Layout>
+ struct is_mapping_of_impl<Mapping, Layout, void_t<typename Mapping::extents_type>, void_t< typename Layout::template mapping<typename Mapping::extents_type> >>
+ : std::is_same<typename Layout::template mapping<typename Mapping::extents_type>, Mapping>
+ {};
+
template<class Layout, class Mapping>
- constexpr bool __is_mapping_of =
- std::is_same<typename Layout::template mapping<typename Mapping::extents_type>, Mapping>::value;
+ constexpr bool is_mapping_of =
+ is_mapping_of_impl<Mapping, Layout>::value;
-#if defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20
+#if defined(MDSPAN_IMPL_USE_CONCEPTS) && MDSPAN_HAS_CXX_20
# if !defined(__cpp_lib_concepts)
namespace internal {
namespace detail {
- template <typename _Tp, typename _Up>
- concept __same_as = std::is_same_v<_Tp, _Up>;
+ template <typename Tp, typename _Up>
+ concept same_as = std::is_same_v<Tp, _Up>;
} // namespace detail
template <class T, class U>
- concept __same_as = detail::__same_as<T, U> && detail::__same_as<U, T>;
+ concept same_as = detail::same_as<T, U> && detail::same_as<U, T>;
} // namespace internal
# endif
template<class M>
- concept __layout_mapping_alike = requires {
- requires __is_extents<typename M::extents_type>::value;
+ concept layout_mapping_alike = requires {
+ requires impl_is_extents<typename M::extents_type>::value;
#if defined(__cpp_lib_concepts)
{ M::is_always_strided() } -> std::same_as<bool>;
{ M::is_always_exhaustive() } -> std::same_as<bool>;
{ M::is_always_unique() } -> std::same_as<bool>;
#else
- { M::is_always_strided() } -> internal::__same_as<bool>;
- { M::is_always_exhaustive() } -> internal::__same_as<bool>;
- { M::is_always_unique() } -> internal::__same_as<bool>;
+ { M::is_always_strided() } -> internal::same_as<bool>;
+ { M::is_always_exhaustive() } -> internal::same_as<bool>;
+ { M::is_always_unique() } -> internal::same_as<bool>;
#endif
std::bool_constant<M::is_always_strided()>::value;
std::bool_constant<M::is_always_exhaustive()>::value;
@@ -87,9 +105,9 @@ namespace detail {
struct layout_stride {
template <class Extents>
class mapping
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
- : private detail::__no_unique_address_emulation<
- detail::__compressed_pair<
+#if !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ : private detail::no_unique_address_emulation<
+ detail::impl_compressed_pair<
Extents,
detail::possibly_empty_array<typename Extents::index_type, Extents::rank()>
>
@@ -104,7 +122,7 @@ struct layout_stride {
using layout_type = layout_stride;
// This could be a `requires`, but I think it's better and clearer as a `static_assert`.
- static_assert(detail::__is_extents_v<Extents>,
+ static_assert(detail::impl_is_extents_v<Extents>,
MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_stride::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents.");
@@ -112,36 +130,36 @@ struct layout_stride {
//----------------------------------------------------------------------------
- using __strides_storage_t = detail::possibly_empty_array<index_type, extents_type::rank()>;
- using __member_pair_t = detail::__compressed_pair<extents_type, __strides_storage_t>;
+ using strides_storage_t = detail::possibly_empty_array<index_type, extents_type::rank()>;
+ using member_pair_t = detail::impl_compressed_pair<extents_type, strides_storage_t>;
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
- _MDSPAN_NO_UNIQUE_ADDRESS __member_pair_t __members;
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ MDSPAN_IMPL_NO_UNIQUE_ADDRESS member_pair_t m_members;
#else
- using __base_t = detail::__no_unique_address_emulation<__member_pair_t>;
+ using base_t = detail::no_unique_address_emulation<member_pair_t>;
#endif
- MDSPAN_FORCE_INLINE_FUNCTION constexpr __strides_storage_t const&
- __strides_storage() const noexcept {
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
- return __members.__second();
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr strides_storage_t const&
+ strides_storage() const noexcept {
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ return m_members.second();
#else
- return this->__base_t::__ref().__second();
+ return this->base_t::ref().second();
#endif
}
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 __strides_storage_t&
- __strides_storage() noexcept {
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
- return __members.__second();
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 strides_storage_t&
+ strides_storage() noexcept {
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ return m_members.second();
#else
- return this->__base_t::__ref().__second();
+ return this->base_t::ref().second();
#endif
}
template<class SizeType, size_t ... Ep, size_t ... Idx>
- _MDSPAN_HOST_DEVICE
- constexpr index_type __get_size(::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<SizeType, Ep...>,std::integer_sequence<size_t, Idx...>) const {
- return _MDSPAN_FOLD_TIMES_RIGHT( static_cast<index_type>(extents().extent(Idx)), 1 );
+ MDSPAN_IMPL_HOST_DEVICE
+ constexpr index_type get_size(::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<SizeType, Ep...>,std::integer_sequence<size_t, Idx...>) const {
+ return MDSPAN_IMPL_FOLD_TIMES_RIGHT( static_cast<index_type>(extents().extent(Idx)), 1 );
}
//----------------------------------------------------------------------------
@@ -153,52 +171,52 @@ struct layout_stride {
// Workaround for non-deducibility of the index sequence template parameter if it's given at the top level
template <class>
- struct __deduction_workaround;
+ struct deduction_workaround;
template <size_t... Idxs>
- struct __deduction_workaround<std::index_sequence<Idxs...>>
+ struct deduction_workaround<std::index_sequence<Idxs...>>
{
template <class OtherExtents>
MDSPAN_INLINE_FUNCTION
static constexpr bool _eq_impl(mapping const& self, mapping<OtherExtents> const& other) noexcept {
using common_t = std::common_type_t<index_type, typename OtherExtents::index_type>;
- return _MDSPAN_FOLD_AND((static_cast<common_t>(self.stride(Idxs)) == static_cast<common_t>(other.stride(Idxs))) /* && ... */)
- && _MDSPAN_FOLD_AND((static_cast<common_t>(self.extents().extent(Idxs)) == static_cast<common_t>(other.extents().extent(Idxs))) /* || ... */);
+ return MDSPAN_IMPL_FOLD_AND((static_cast<common_t>(self.stride(Idxs)) == static_cast<common_t>(other.stride(Idxs))) /* && ... */)
+ && MDSPAN_IMPL_FOLD_AND((static_cast<common_t>(self.extents().extent(Idxs)) == static_cast<common_t>(other.extents().extent(Idxs))) /* || ... */);
}
template <class OtherExtents>
MDSPAN_INLINE_FUNCTION
static constexpr bool _not_eq_impl(mapping const& self, mapping<OtherExtents> const& other) noexcept {
using common_t = std::common_type_t<index_type, typename OtherExtents::index_type>;
- return _MDSPAN_FOLD_OR((static_cast<common_t>(self.stride(Idxs)) != static_cast<common_t>(other.stride(Idxs))) /* || ... */)
- || _MDSPAN_FOLD_OR((static_cast<common_t>(self.extents().extent(Idxs)) != static_cast<common_t>(other.extents().extent(Idxs))) /* || ... */);
+ return MDSPAN_IMPL_FOLD_OR((static_cast<common_t>(self.stride(Idxs)) != static_cast<common_t>(other.stride(Idxs))) /* || ... */)
+ || MDSPAN_IMPL_FOLD_OR((static_cast<common_t>(self.extents().extent(Idxs)) != static_cast<common_t>(other.extents().extent(Idxs))) /* || ... */);
}
template <class... Integral>
MDSPAN_FORCE_INLINE_FUNCTION
static constexpr size_t _call_op_impl(mapping const& self, Integral... idxs) noexcept {
- return _MDSPAN_FOLD_PLUS_RIGHT((idxs * self.stride(Idxs)), /* + ... + */ 0);
+ return MDSPAN_IMPL_FOLD_PLUS_RIGHT((idxs * self.stride(Idxs)), /* + ... + */ 0);
}
MDSPAN_INLINE_FUNCTION
static constexpr size_t _req_span_size_impl(mapping const& self) noexcept {
// assumes no negative strides; not sure if I'm allowed to assume that or not
- return __impl::_call_op_impl(self, (self.extents().template __extent<Idxs>() - 1)...) + 1;
+ return deduction_workaround_impl::_call_op_impl(self, (self.extents().template extent<Idxs>() - 1)...) + 1;
}
template<class OtherMapping>
MDSPAN_INLINE_FUNCTION
- static constexpr const __strides_storage_t fill_strides(const OtherMapping& map) {
- return __strides_storage_t{static_cast<index_type>(map.stride(Idxs))...};
+ static constexpr const strides_storage_t fill_strides(const OtherMapping& map) {
+ return strides_storage_t{static_cast<index_type>(map.stride(Idxs))...};
}
MDSPAN_INLINE_FUNCTION
- static constexpr const __strides_storage_t& fill_strides(const __strides_storage_t& s) {
+ static constexpr const strides_storage_t& fill_strides(const strides_storage_t& s) {
return s;
}
template<class IntegralType>
- static constexpr const __strides_storage_t fill_strides(const std::array<IntegralType,extents_type::rank()>& s) {
- return __strides_storage_t{static_cast<index_type>(s[Idxs])...};
+ static constexpr const strides_storage_t fill_strides(const std::array<IntegralType,extents_type::rank()>& s) {
+ return strides_storage_t{static_cast<index_type>(s[Idxs])...};
}
MDSPAN_TEMPLATE_REQUIRES(
@@ -207,44 +225,44 @@ struct layout_stride {
)
MDSPAN_INLINE_FUNCTION
// Need to avoid zero length c-array
- static constexpr const __strides_storage_t fill_strides(mdspan_non_standard_tag, const IntegralType (&s)[extents_type::rank()>0?extents_type::rank():1]) {
- return __strides_storage_t{static_cast<index_type>(s[Idxs])...};
+ static constexpr const strides_storage_t fill_strides(mdspan_non_standard_tag, const IntegralType (&s)[extents_type::rank()>0?extents_type::rank():1]) {
+ return strides_storage_t{static_cast<index_type>(s[Idxs])...};
}
#ifdef __cpp_lib_span
template<class IntegralType>
- static constexpr const __strides_storage_t fill_strides(const std::span<IntegralType,extents_type::rank()>& s) {
- return __strides_storage_t{static_cast<index_type>(s[Idxs])...};
+ static constexpr const strides_storage_t fill_strides(const std::span<IntegralType,extents_type::rank()>& s) {
+ return strides_storage_t{static_cast<index_type>(s[Idxs])...};
}
#endif
MDSPAN_INLINE_FUNCTION
- static constexpr std::array<index_type, extents_type::rank()> return_strides(const __strides_storage_t& s) {
+ static constexpr std::array<index_type, extents_type::rank()> return_strides(const strides_storage_t& s) {
return std::array<index_type, extents_type::rank()>{s[Idxs]...};
}
template<size_t K>
MDSPAN_INLINE_FUNCTION
- static constexpr size_t __return_zero() { return 0; }
+ static constexpr size_t return_zero() { return 0; }
template<class Mapping>
MDSPAN_INLINE_FUNCTION
static constexpr typename Mapping::index_type
- __OFFSET(const Mapping& m) { return m(__return_zero<Idxs>()...); }
+ offset(const Mapping& m) { return m(return_zero<Idxs>()...); }
};
- // Can't use defaulted parameter in the __deduction_workaround template because of a bug in MSVC warning C4348.
- using __impl = __deduction_workaround<std::make_index_sequence<Extents::rank()>>;
+ // Can't use defaulted parameter in the deduction_workaround template because of a bug in MSVC warning C4348.
+ using deduction_workaround_impl = deduction_workaround<std::make_index_sequence<Extents::rank()>>;
MDSPAN_FUNCTION
- static constexpr __strides_storage_t strides_storage(detail::with_rank<0>) {
+ static constexpr strides_storage_t strides_storage(detail::with_rank<0>) {
return {};
}
template <std::size_t N>
MDSPAN_FUNCTION
- static constexpr __strides_storage_t strides_storage(detail::with_rank<N>) {
- __strides_storage_t s{};
+ static constexpr strides_storage_t strides_storage(detail::with_rank<N>) {
+ strides_storage_t s{};
extents_type e;
index_type stride = 1;
@@ -258,12 +276,12 @@ struct layout_stride {
//----------------------------------------------------------------------------
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
MDSPAN_INLINE_FUNCTION constexpr explicit
- mapping(__member_pair_t&& __m) : __members(::std::move(__m)) {}
+ mapping(member_pair_t&& m) : m_members(::std::move(m)) {}
#else
MDSPAN_INLINE_FUNCTION constexpr explicit
- mapping(__base_t&& __b) : __base_t(::std::move(__b)) {}
+ mapping(base_t&& __b) : base_t(::std::move(__b)) {}
#endif
public:
@@ -271,14 +289,14 @@ struct layout_stride {
//--------------------------------------------------------------------------------
MDSPAN_INLINE_FUNCTION constexpr mapping() noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
- : __members{
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ : m_members{
#else
- : __base_t(__base_t{__member_pair_t(
+ : base_t(base_t{member_pair_t(
#endif
extents_type(),
- __strides_storage_t(strides_storage(detail::with_rank<extents_type::rank()>{}))
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ strides_storage_t(strides_storage(detail::with_rank<extents_type::rank()>{}))
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
}
#else
)})
@@ -292,8 +310,8 @@ struct layout_stride {
/* requires */ (
// MSVC 19.32 does not like using index_type here, requires the typename Extents::index_type
// error C2641: cannot deduce template arguments for 'MDSPAN_IMPL_STANDARD_NAMESPACE::layout_stride::mapping'
- _MDSPAN_TRAIT(std::is_convertible, const std::remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t<IntegralTypes>&)
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const std::remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t<IntegralTypes>&)
)
)
constexpr
@@ -301,13 +319,13 @@ struct layout_stride {
extents_type const& e,
std::array<IntegralTypes, extents_type::rank()> const& s
) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
- : __members{
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ : m_members{
#else
- : __base_t(__base_t{__member_pair_t(
+ : base_t(base_t{member_pair_t(
#endif
- e, __strides_storage_t(__impl::fill_strides(s))
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ e, strides_storage_t(deduction_workaround_impl::fill_strides(s))
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
}
#else
)})
@@ -328,8 +346,8 @@ struct layout_stride {
/* requires */ (
// MSVC 19.32 does not like using index_type here, requires the typename Extents::index_type
// error C2641: cannot deduce template arguments for 'MDSPAN_IMPL_STANDARD_NAMESPACE::layout_stride::mapping'
- _MDSPAN_TRAIT(std::is_convertible, const std::remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t<IntegralTypes>&)
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const std::remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t<IntegralTypes>&)
)
)
MDSPAN_INLINE_FUNCTION
@@ -340,13 +358,13 @@ struct layout_stride {
// Need to avoid zero-length c-array
const IntegralTypes (&s)[extents_type::rank()>0?extents_type::rank():1]
) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
- : __members{
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ : m_members{
#else
- : __base_t(__base_t{__member_pair_t(
+ : base_t(base_t{member_pair_t(
#endif
- e, __strides_storage_t(__impl::fill_strides(mdspan_non_standard, s))
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ e, strides_storage_t(deduction_workaround_impl::fill_strides(mdspan_non_standard, s))
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
}
#else
)})
@@ -368,8 +386,8 @@ struct layout_stride {
/* requires */ (
// MSVC 19.32 does not like using index_type here, requires the typename Extents::index_type
// error C2641: cannot deduce template arguments for 'MDSPAN_IMPL_STANDARD_NAMESPACE::layout_stride::mapping'
- _MDSPAN_TRAIT(std::is_convertible, const std::remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t<IntegralTypes>&)
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const std::remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t<IntegralTypes>&)
)
)
constexpr
@@ -377,13 +395,13 @@ struct layout_stride {
extents_type const& e,
std::span<IntegralTypes, extents_type::rank()> const& s
) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
- : __members{
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ : m_members{
#else
- : __base_t(__base_t{__member_pair_t(
+ : base_t(base_t{member_pair_t(
#endif
- e, __strides_storage_t(__impl::fill_strides(s))
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ e, strides_storage_t(deduction_workaround_impl::fill_strides(s))
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
}
#else
)})
@@ -400,12 +418,12 @@ struct layout_stride {
}
#endif // __cpp_lib_span
-#if !(defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20)
+#if !(defined(MDSPAN_IMPL_USE_CONCEPTS) && MDSPAN_HAS_CXX_20)
MDSPAN_TEMPLATE_REQUIRES(
class StridedLayoutMapping,
/* requires */ (
- _MDSPAN_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) &&
- detail::__is_mapping_of<typename StridedLayoutMapping::layout_type, StridedLayoutMapping> &&
+ MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) &&
+ detail::is_mapping_of<typename StridedLayoutMapping::layout_type, StridedLayoutMapping> &&
StridedLayoutMapping::is_always_unique() &&
StridedLayoutMapping::is_always_strided()
)
@@ -413,27 +431,27 @@ struct layout_stride {
#else
template<class StridedLayoutMapping>
requires(
- detail::__layout_mapping_alike<StridedLayoutMapping> &&
- _MDSPAN_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) &&
+ detail::layout_mapping_alike<StridedLayoutMapping> &&
+ MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) &&
StridedLayoutMapping::is_always_unique() &&
StridedLayoutMapping::is_always_strided()
)
#endif
MDSPAN_CONDITIONAL_EXPLICIT(
!(std::is_convertible<typename StridedLayoutMapping::extents_type, extents_type>::value &&
- (detail::__is_mapping_of<layout_left, StridedLayoutMapping> ||
- detail::__is_mapping_of<layout_right, StridedLayoutMapping> ||
- detail::__is_mapping_of<layout_stride, StridedLayoutMapping>))
+ (detail::is_mapping_of<layout_left, StridedLayoutMapping> ||
+ detail::is_mapping_of<layout_right, StridedLayoutMapping> ||
+ detail::is_mapping_of<layout_stride, StridedLayoutMapping>))
) // needs two () due to comma
- MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
+ MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14
mapping(StridedLayoutMapping const& other) noexcept // NOLINT(google-explicit-constructor)
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
- : __members{
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ : m_members{
#else
- : __base_t(__base_t{__member_pair_t(
+ : base_t(base_t{member_pair_t(
#endif
- other.extents(), __strides_storage_t(__impl::fill_strides(other))
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ other.extents(), strides_storage_t(deduction_workaround_impl::fill_strides(other))
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
}
#else
)})
@@ -449,20 +467,20 @@ struct layout_stride {
//--------------------------------------------------------------------------------
- MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED
+ MDSPAN_INLINE_FUNCTION_DEFAULTED MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED
mapping& operator=(mapping const&) noexcept = default;
MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept {
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
- return __members.__first();
+#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+ return m_members.first();
#else
- return this->__base_t::__ref().__first();
+ return this->base_t::ref().first();
#endif
- };
+ }
MDSPAN_INLINE_FUNCTION
constexpr std::array< index_type, extents_type::rank() > strides() const noexcept {
- return __impl::return_strides(__strides_storage());
+ return deduction_workaround_impl::return_strides(strides_storage());
}
MDSPAN_INLINE_FUNCTION
@@ -472,7 +490,7 @@ struct layout_stride {
for(int r = 0; r < static_cast<int>(extents_type::rank()); r++) {
// Return early if any of the extents are zero
if(extents().extent(r)==0) return 0;
- span_size += ( static_cast<index_type>(extents().extent(r) - 1 ) * __strides_storage()[r]);
+ span_size += ( static_cast<index_type>(extents().extent(r) - 1 ) * strides_storage()[r]);
}
return span_size;
}
@@ -490,7 +508,7 @@ struct layout_stride {
#if ! defined(NDEBUG)
detail::check_all_indices(this->extents(), idxs...);
#endif // ! NDEBUG
- return static_cast<index_type>(__impl::_call_op_impl(*this, static_cast<index_type>(idxs)...));
+ return static_cast<index_type>(deduction_workaround_impl::_call_op_impl(*this, static_cast<index_type>(idxs)...));
}
MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; }
@@ -505,7 +523,7 @@ struct layout_stride {
MDSPAN_INLINE_FUNCTION
constexpr bool exhaustive_for_nonzero_span_size() const
{
- return required_span_size() == __get_size(extents(), std::make_index_sequence<extents_type::rank()>());
+ return required_span_size() == get_size(extents(), std::make_index_sequence<extents_type::rank()>());
}
MDSPAN_INLINE_FUNCTION
@@ -544,7 +562,7 @@ struct layout_stride {
}
public:
- MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 bool is_exhaustive() const noexcept {
+ MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 bool is_exhaustive() const noexcept {
return is_exhaustive_impl(detail::with_rank<extents_type::rank()>{});
}
MDSPAN_INLINE_FUNCTION static constexpr bool is_strided() noexcept { return true; }
@@ -552,14 +570,14 @@ struct layout_stride {
MDSPAN_INLINE_FUNCTION
constexpr index_type stride(rank_type r) const noexcept {
- return __strides_storage()[r];
+ return strides_storage()[r];
}
-#if !(defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20)
+#if !(defined(MDSPAN_IMPL_USE_CONCEPTS) && MDSPAN_HAS_CXX_20)
MDSPAN_TEMPLATE_REQUIRES(
class StridedLayoutMapping,
/* requires */ (
- detail::__is_mapping_of<typename StridedLayoutMapping::layout_type, StridedLayoutMapping> &&
+ detail::is_mapping_of<typename StridedLayoutMapping::layout_type, StridedLayoutMapping> &&
(extents_type::rank() == StridedLayoutMapping::extents_type::rank()) &&
StridedLayoutMapping::is_always_strided()
)
@@ -567,7 +585,7 @@ struct layout_stride {
#else
template<class StridedLayoutMapping>
requires(
- detail::__layout_mapping_alike<StridedLayoutMapping> &&
+ detail::layout_mapping_alike<StridedLayoutMapping> &&
(extents_type::rank() == StridedLayoutMapping::extents_type::rank()) &&
StridedLayoutMapping::is_always_strided()
)
@@ -575,7 +593,7 @@ struct layout_stride {
MDSPAN_INLINE_FUNCTION
friend constexpr bool operator==(const mapping& x, const StridedLayoutMapping& y) noexcept {
return (x.extents() == y.extents()) &&
- (__impl::__OFFSET(y) == static_cast<typename StridedLayoutMapping::index_type>(0)) &&
+ (deduction_workaround_impl::offset(y) == static_cast<typename StridedLayoutMapping::index_type>(0)) &&
detail::rankwise_equal(detail::with_rank<extents_type::rank()>{}, x, y, detail::stride);
}
@@ -588,14 +606,14 @@ struct layout_stride {
)
MDSPAN_INLINE_FUNCTION
friend constexpr bool operator==(mapping const& lhs, mapping<OtherExtents> const& rhs) noexcept {
- return __impl::_eq_impl(lhs, rhs);
+ return deduction_workaround_impl::_eq_impl(lhs, rhs);
}
#if !MDSPAN_HAS_CXX_20
MDSPAN_TEMPLATE_REQUIRES(
class StridedLayoutMapping,
/* requires */ (
- detail::__is_mapping_of<typename StridedLayoutMapping::layout_type, StridedLayoutMapping> &&
+ detail::is_mapping_of<typename StridedLayoutMapping::layout_type, StridedLayoutMapping> &&
(extents_type::rank() == StridedLayoutMapping::extents_type::rank()) &&
StridedLayoutMapping::is_always_strided()
)
@@ -613,7 +631,7 @@ struct layout_stride {
)
MDSPAN_INLINE_FUNCTION
friend constexpr bool operator!=(mapping const& lhs, mapping<OtherExtents> const& rhs) noexcept {
- return __impl::_not_eq_impl(lhs, rhs);
+ return deduction_workaround_impl::_not_eq_impl(lhs, rhs);
}
#endif
diff --git a/ext/mdspan/include/experimental/__p0009_bits/macros.hpp b/ext/mdspan/include/experimental/__p0009_bits/macros.hpp
index b60c426..7f288dc 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/macros.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/macros.hpp
@@ -21,36 +21,39 @@
#include <cstdio>
#include <cstdlib>
#include <type_traits> // std::is_void
-#if defined(_MDSPAN_HAS_CUDA) || defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_SYCL)
+#if defined(MDSPAN_IMPL_HAS_SYCL)
+#include <sycl/sycl.hpp> // sycl::ext::oneapi::experimental::printf
+#endif
+#if defined(MDSPAN_IMPL_HAS_CUDA) || defined(MDSPAN_IMPL_HAS_HIP) || defined(MDSPAN_IMPL_HAS_SYCL)
#include "assert.h"
#endif
-#ifndef _MDSPAN_HOST_DEVICE
-# if defined(_MDSPAN_HAS_CUDA) || defined(_MDSPAN_HAS_HIP)
-# define _MDSPAN_HOST_DEVICE __host__ __device__
+#ifndef MDSPAN_IMPL_HOST_DEVICE
+# if defined(MDSPAN_IMPL_HAS_CUDA) || defined(MDSPAN_IMPL_HAS_HIP)
+# define MDSPAN_IMPL_HOST_DEVICE __host__ __device__
# else
-# define _MDSPAN_HOST_DEVICE
+# define MDSPAN_IMPL_HOST_DEVICE
# endif
#endif
#ifndef MDSPAN_FORCE_INLINE_FUNCTION
-# ifdef _MDSPAN_COMPILER_MSVC // Microsoft compilers
-# define MDSPAN_FORCE_INLINE_FUNCTION __forceinline _MDSPAN_HOST_DEVICE
+# ifdef MDSPAN_IMPL_COMPILER_MSVC // Microsoft compilers
+# define MDSPAN_FORCE_INLINE_FUNCTION __forceinline MDSPAN_IMPL_HOST_DEVICE
# else
-# define MDSPAN_FORCE_INLINE_FUNCTION __attribute__((always_inline)) _MDSPAN_HOST_DEVICE
+# define MDSPAN_FORCE_INLINE_FUNCTION __attribute__((always_inline)) MDSPAN_IMPL_HOST_DEVICE
# endif
#endif
#ifndef MDSPAN_INLINE_FUNCTION
-# define MDSPAN_INLINE_FUNCTION inline _MDSPAN_HOST_DEVICE
+# define MDSPAN_INLINE_FUNCTION inline MDSPAN_IMPL_HOST_DEVICE
#endif
#ifndef MDSPAN_FUNCTION
-# define MDSPAN_FUNCTION _MDSPAN_HOST_DEVICE
+# define MDSPAN_FUNCTION MDSPAN_IMPL_HOST_DEVICE
#endif
-#ifdef _MDSPAN_HAS_HIP
-# define MDSPAN_DEDUCTION_GUIDE _MDSPAN_HOST_DEVICE
+#ifdef MDSPAN_IMPL_HAS_HIP
+# define MDSPAN_DEDUCTION_GUIDE MDSPAN_IMPL_HOST_DEVICE
#else
# define MDSPAN_DEDUCTION_GUIDE
#endif
@@ -64,15 +67,15 @@
// <editor-fold desc="Preprocessor helpers"> {{{1
#define MDSPAN_PP_COUNT(...) \
- _MDSPAN_PP_INTERNAL_EXPAND_ARGS_PRIVATE( \
- _MDSPAN_PP_INTERNAL_ARGS_AUGMENTER(__VA_ARGS__) \
+ MDSPAN_IMPL_PP_INTERNAL_EXPAND_ARGS( \
+ MDSPAN_IMPL_PP_INTERNAL_ARGS_AUGMENTER(__VA_ARGS__) \
)
-#define _MDSPAN_PP_INTERNAL_ARGS_AUGMENTER(...) unused, __VA_ARGS__
-#define _MDSPAN_PP_INTERNAL_EXPAND(x) x
-#define _MDSPAN_PP_INTERNAL_EXPAND_ARGS_PRIVATE(...) \
- _MDSPAN_PP_INTERNAL_EXPAND( \
- _MDSPAN_PP_INTERNAL_COUNT_PRIVATE( \
+#define MDSPAN_IMPL_PP_INTERNAL_ARGS_AUGMENTER(...) unused, __VA_ARGS__
+#define MDSPAN_IMPL_PP_INTERNAL_EXPAND(x) x
+#define MDSPAN_IMPL_PP_INTERNAL_EXPAND_ARGS(...) \
+ MDSPAN_IMPL_PP_INTERNAL_EXPAND( \
+ MDSPAN_IMPL_PP_INTERNAL_COUNT( \
__VA_ARGS__, 69, 68, 67, 66, 65, 64, 63, 62, 61, \
60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, \
48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, \
@@ -81,7 +84,7 @@
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 \
) \
)
-# define _MDSPAN_PP_INTERNAL_COUNT_PRIVATE( \
+# define MDSPAN_IMPL_PP_INTERNAL_COUNT( \
_1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, \
_10, _11, _12, _13, _14, _15, _16, _17, _18, _19, \
_20, _21, _22, _23, _24, _25, _26, _27, _28, _29, \
@@ -109,16 +112,22 @@
namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
namespace detail {
-#if defined(_MDSPAN_HAS_CUDA) || defined(_MDSPAN_HAS_HIP)
+#if defined(MDSPAN_IMPL_HAS_CUDA) || defined(MDSPAN_IMPL_HAS_HIP)
MDSPAN_FUNCTION inline void default_precondition_violation_handler(const char* cond, const char* file, unsigned line)
{
- printf("%s:%u: precondition failure: `%s`\n", file, line, cond);
+ ::printf("%s:%u: precondition failure: `%s`\n", file, line, cond);
assert(0);
}
-#elif defined(_MDSPAN_HAS_SYCL)
+#elif defined(MDSPAN_IMPL_HAS_SYCL)
MDSPAN_FUNCTION inline void default_precondition_violation_handler(const char* cond, const char* file, unsigned line)
{
+#ifdef __INTEL_LLVM_COMPILER
sycl::ext::oneapi::experimental::printf("%s:%u: precondition failure: `%s`\n", file, line, cond);
+#else
+ (void) cond;
+ (void) file;
+ (void) line;
+#endif
assert(0);
}
#else
@@ -177,7 +186,7 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file,
// These compatibility macros don't help with partial ordering, but they should do the trick
// for what we need to do with concepts in mdspan
-#ifdef _MDSPAN_USE_CONCEPTS
+#ifdef MDSPAN_IMPL_USE_CONCEPTS
# define MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) > requires REQ
# define MDSPAN_FUNCTION_REQUIRES(PAREN_PREQUALS, FNAME, PAREN_PARAMS, QUALS, REQ) \
MDSPAN_PP_REMOVE_PARENS(PAREN_PREQUALS) FNAME PAREN_PARAMS QUALS requires REQ \
@@ -186,13 +195,13 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file,
# define MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) , typename ::std::enable_if<(REQ), int>::type = 0>
# define MDSPAN_FUNCTION_REQUIRES(PAREN_PREQUALS, FNAME, PAREN_PARAMS, QUALS, REQ) \
MDSPAN_TEMPLATE_REQUIRES( \
- class __function_requires_ignored=void, \
- (std::is_void<__function_requires_ignored>::value && REQ) \
+ class function_requires_ignored=void, \
+ (std::is_void<function_requires_ignored>::value && REQ) \
) MDSPAN_PP_REMOVE_PARENS(PAREN_PREQUALS) FNAME PAREN_PARAMS QUALS \
/**/
#endif
-#if defined(_MDSPAN_COMPILER_MSVC) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL)
+#if defined(MDSPAN_IMPL_COMPILER_MSVC) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL)
# define MDSPAN_TEMPLATE_REQUIRES(...) \
MDSPAN_PP_CAT( \
MDSPAN_PP_CAT(MDSPAN_TEMPLATE_REQUIRES_, MDSPAN_PP_COUNT(__VA_ARGS__))\
@@ -287,8 +296,8 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file,
#define MDSPAN_INSTANTIATE_ONLY_IF_USED \
MDSPAN_TEMPLATE_REQUIRES( \
- class __instantiate_only_if_used_tparam=void, \
- ( _MDSPAN_TRAIT(std::is_void, __instantiate_only_if_used_tparam) ) \
+ class instantiate_only_if_used_tparam=void, \
+ ( MDSPAN_IMPL_TRAIT(std::is_void, instantiate_only_if_used_tparam) ) \
) \
/**/
@@ -298,10 +307,10 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file,
//==============================================================================
// <editor-fold desc="inline variables"> {{{1
-#ifdef _MDSPAN_USE_INLINE_VARIABLES
-# define _MDSPAN_INLINE_VARIABLE inline
+#ifdef MDSPAN_IMPL_USE_INLINE_VARIABLES
+# define MDSPAN_IMPL_INLINE_VARIABLE inline
#else
-# define _MDSPAN_INLINE_VARIABLE
+# define MDSPAN_IMPL_INLINE_VARIABLE
#endif
// </editor-fold> end inline variables }}}1
@@ -310,17 +319,17 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file,
//==============================================================================
// <editor-fold desc="Return type deduction"> {{{1
-#if _MDSPAN_USE_RETURN_TYPE_DEDUCTION
-# define _MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
+#if MDSPAN_IMPL_USE_RETURN_TYPE_DEDUCTION
+# define MDSPAN_IMPL_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
auto MDSPAN_PP_REMOVE_PARENS(SIGNATURE) { return MDSPAN_PP_REMOVE_PARENS(BODY); }
-# define _MDSPAN_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
+# define MDSPAN_IMPL_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
decltype(auto) MDSPAN_PP_REMOVE_PARENS(SIGNATURE) { return MDSPAN_PP_REMOVE_PARENS(BODY); }
#else
-# define _MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
+# define MDSPAN_IMPL_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
auto MDSPAN_PP_REMOVE_PARENS(SIGNATURE) \
-> std::remove_cv_t<std::remove_reference_t<decltype(BODY)>> \
{ return MDSPAN_PP_REMOVE_PARENS(BODY); }
-# define _MDSPAN_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
+# define MDSPAN_IMPL_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
auto MDSPAN_PP_REMOVE_PARENS(SIGNATURE) \
-> decltype(BODY) \
{ return MDSPAN_PP_REMOVE_PARENS(BODY); }
@@ -333,96 +342,96 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file,
//==============================================================================
// <editor-fold desc="fold expressions"> {{{1
-struct __mdspan_enable_fold_comma { };
-
-#ifdef _MDSPAN_USE_FOLD_EXPRESSIONS
-# define _MDSPAN_FOLD_AND(...) ((__VA_ARGS__) && ...)
-# define _MDSPAN_FOLD_AND_TEMPLATE(...) ((__VA_ARGS__) && ...)
-# define _MDSPAN_FOLD_OR(...) ((__VA_ARGS__) || ...)
-# define _MDSPAN_FOLD_ASSIGN_LEFT(INIT, ...) (INIT = ... = (__VA_ARGS__))
-# define _MDSPAN_FOLD_ASSIGN_RIGHT(PACK, ...) (PACK = ... = (__VA_ARGS__))
-# define _MDSPAN_FOLD_TIMES_RIGHT(PACK, ...) (PACK * ... * (__VA_ARGS__))
-# define _MDSPAN_FOLD_PLUS_RIGHT(PACK, ...) (PACK + ... + (__VA_ARGS__))
-# define _MDSPAN_FOLD_COMMA(...) ((__VA_ARGS__), ...)
+struct enable_fold_comma { };
+
+#ifdef MDSPAN_IMPL_USE_FOLD_EXPRESSIONS
+# define MDSPAN_IMPL_FOLD_AND(...) ((__VA_ARGS__) && ...)
+# define MDSPAN_IMPL_FOLD_AND_TEMPLATE(...) ((__VA_ARGS__) && ...)
+# define MDSPAN_IMPL_FOLD_OR(...) ((__VA_ARGS__) || ...)
+# define MDSPAN_IMPL_FOLD_ASSIGN_LEFT(INIT, ...) (INIT = ... = (__VA_ARGS__))
+# define MDSPAN_IMPL_FOLD_ASSIGN_RIGHT(PACK, ...) (PACK = ... = (__VA_ARGS__))
+# define MDSPAN_IMPL_FOLD_TIMES_RIGHT(PACK, ...) (PACK * ... * (__VA_ARGS__))
+# define MDSPAN_IMPL_FOLD_PLUS_RIGHT(PACK, ...) (PACK + ... + (__VA_ARGS__))
+# define MDSPAN_IMPL_FOLD_COMMA(...) ((__VA_ARGS__), ...)
#else
namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
-namespace __fold_compatibility_impl {
+namespace fold_compatibility_impl {
// We could probably be more clever here, but at the (small) risk of losing some compiler understanding. For the
// few operations we need, it's not worth generalizing over the operation
-#if _MDSPAN_USE_RETURN_TYPE_DEDUCTION
+#if MDSPAN_IMPL_USE_RETURN_TYPE_DEDUCTION
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr decltype(auto) __fold_right_and_impl() {
+constexpr decltype(auto) fold_right_and_impl() {
return true;
}
template <class Arg, class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr decltype(auto) __fold_right_and_impl(Arg&& arg, Args&&... args) {
- return ((Arg&&)arg) && __fold_compatibility_impl::__fold_right_and_impl((Args&&)args...);
+constexpr decltype(auto) fold_right_and_impl(Arg&& arg, Args&&... args) {
+ return ((Arg&&)arg) && fold_compatibility_impl::fold_right_and_impl((Args&&)args...);
}
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr decltype(auto) __fold_right_or_impl() {
+constexpr decltype(auto) fold_right_or_impl() {
return false;
}
template <class Arg, class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr auto __fold_right_or_impl(Arg&& arg, Args&&... args) {
- return ((Arg&&)arg) || __fold_compatibility_impl::__fold_right_or_impl((Args&&)args...);
+constexpr auto fold_right_or_impl(Arg&& arg, Args&&... args) {
+ return ((Arg&&)arg) || fold_compatibility_impl::fold_right_or_impl((Args&&)args...);
}
template <class Arg1>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr auto __fold_left_assign_impl(Arg1&& arg1) {
+constexpr auto fold_left_assign_impl(Arg1&& arg1) {
return (Arg1&&)arg1;
}
template <class Arg1, class Arg2, class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr auto __fold_left_assign_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) {
- return __fold_compatibility_impl::__fold_left_assign_impl((((Arg1&&)arg1) = ((Arg2&&)arg2)), (Args&&)args...);
+constexpr auto fold_left_assign_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) {
+ return fold_compatibility_impl::fold_left_assign_impl((((Arg1&&)arg1) = ((Arg2&&)arg2)), (Args&&)args...);
}
template <class Arg1>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr auto __fold_right_assign_impl(Arg1&& arg1) {
+constexpr auto fold_right_assign_impl(Arg1&& arg1) {
return (Arg1&&)arg1;
}
template <class Arg1, class Arg2, class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr auto __fold_right_assign_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) {
- return ((Arg1&&)arg1) = __fold_compatibility_impl::__fold_right_assign_impl((Arg2&&)arg2, (Args&&)args...);
+constexpr auto fold_right_assign_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) {
+ return ((Arg1&&)arg1) = fold_compatibility_impl::fold_right_assign_impl((Arg2&&)arg2, (Args&&)args...);
}
template <class Arg1>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr auto __fold_right_plus_impl(Arg1&& arg1) {
+constexpr auto fold_right_plus_impl(Arg1&& arg1) {
return (Arg1&&)arg1;
}
template <class Arg1, class Arg2, class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr auto __fold_right_plus_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) {
- return ((Arg1&&)arg1) + __fold_compatibility_impl::__fold_right_plus_impl((Arg2&&)arg2, (Args&&)args...);
+constexpr auto fold_right_plus_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) {
+ return ((Arg1&&)arg1) + fold_compatibility_impl::fold_right_plus_impl((Arg2&&)arg2, (Args&&)args...);
}
template <class Arg1>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr auto __fold_right_times_impl(Arg1&& arg1) {
+constexpr auto fold_right_times_impl(Arg1&& arg1) {
return (Arg1&&)arg1;
}
template <class Arg1, class Arg2, class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr auto __fold_right_times_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) {
- return ((Arg1&&)arg1) * __fold_compatibility_impl::__fold_right_times_impl((Arg2&&)arg2, (Args&&)args...);
+constexpr auto fold_right_times_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) {
+ return ((Arg1&&)arg1) * fold_compatibility_impl::fold_right_times_impl((Arg2&&)arg2, (Args&&)args...);
}
#else
@@ -431,32 +440,32 @@ constexpr auto __fold_right_times_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args)
// <editor-fold desc="right and"> {{{2
template <class... Args>
-struct __fold_right_and_impl_;
+struct fold_right_and_impl_;
template <>
-struct __fold_right_and_impl_<> {
- using __rv = bool;
+struct fold_right_and_impl_<> {
+ using rv = bool;
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl() noexcept {
+ static constexpr rv
+ impl() noexcept {
return true;
}
};
template <class Arg, class... Args>
-struct __fold_right_and_impl_<Arg, Args...> {
- using __next_t = __fold_right_and_impl_<Args...>;
- using __rv = decltype(std::declval<Arg>() && std::declval<typename __next_t::__rv>());
+struct fold_right_and_impl_<Arg, Args...> {
+ using next_t = fold_right_and_impl_<Args...>;
+ using rv = decltype(std::declval<Arg>() && std::declval<typename next_t::rv>());
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl(Arg&& arg, Args&&... args) noexcept {
- return ((Arg&&)arg) && __next_t::__impl((Args&&)args...);
+ static constexpr rv
+ impl(Arg&& arg, Args&&... args) noexcept {
+ return ((Arg&&)arg) && next_t::impl((Args&&)args...);
}
};
template <class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr typename __fold_right_and_impl_<Args...>::__rv
-__fold_right_and_impl(Args&&... args) {
- return __fold_right_and_impl_<Args...>::__impl((Args&&)args...);
+constexpr typename fold_right_and_impl_<Args...>::rv
+fold_right_and_impl(Args&&... args) {
+ return fold_right_and_impl_<Args...>::impl((Args&&)args...);
}
// </editor-fold> end right and }}}2
@@ -466,32 +475,32 @@ __fold_right_and_impl(Args&&... args) {
// <editor-fold desc="right or"> {{{2
template <class... Args>
-struct __fold_right_or_impl_;
+struct fold_right_or_impl_;
template <>
-struct __fold_right_or_impl_<> {
- using __rv = bool;
+struct fold_right_or_impl_<> {
+ using rv = bool;
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl() noexcept {
+ static constexpr rv
+ impl() noexcept {
return false;
}
};
template <class Arg, class... Args>
-struct __fold_right_or_impl_<Arg, Args...> {
- using __next_t = __fold_right_or_impl_<Args...>;
- using __rv = decltype(std::declval<Arg>() || std::declval<typename __next_t::__rv>());
+struct fold_right_or_impl_<Arg, Args...> {
+ using next_t = fold_right_or_impl_<Args...>;
+ using rv = decltype(std::declval<Arg>() || std::declval<typename next_t::rv>());
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl(Arg&& arg, Args&&... args) noexcept {
- return ((Arg&&)arg) || __next_t::__impl((Args&&)args...);
+ static constexpr rv
+ impl(Arg&& arg, Args&&... args) noexcept {
+ return ((Arg&&)arg) || next_t::impl((Args&&)args...);
}
};
template <class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr typename __fold_right_or_impl_<Args...>::__rv
-__fold_right_or_impl(Args&&... args) {
- return __fold_right_or_impl_<Args...>::__impl((Args&&)args...);
+constexpr typename fold_right_or_impl_<Args...>::rv
+fold_right_or_impl(Args&&... args) {
+ return fold_right_or_impl_<Args...>::impl((Args&&)args...);
}
// </editor-fold> end right or }}}2
@@ -501,32 +510,32 @@ __fold_right_or_impl(Args&&... args) {
// <editor-fold desc="right plus"> {{{2
template <class... Args>
-struct __fold_right_plus_impl_;
+struct fold_right_plus_impl_;
template <class Arg>
-struct __fold_right_plus_impl_<Arg> {
- using __rv = Arg&&;
+struct fold_right_plus_impl_<Arg> {
+ using rv = Arg&&;
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl(Arg&& arg) noexcept {
+ static constexpr rv
+ impl(Arg&& arg) noexcept {
return (Arg&&)arg;
}
};
template <class Arg1, class Arg2, class... Args>
-struct __fold_right_plus_impl_<Arg1, Arg2, Args...> {
- using __next_t = __fold_right_plus_impl_<Arg2, Args...>;
- using __rv = decltype(std::declval<Arg1>() + std::declval<typename __next_t::__rv>());
+struct fold_right_plus_impl_<Arg1, Arg2, Args...> {
+ using next_t = fold_right_plus_impl_<Arg2, Args...>;
+ using rv = decltype(std::declval<Arg1>() + std::declval<typename next_t::rv>());
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept {
- return ((Arg1&&)arg) + __next_t::__impl((Arg2&&)arg2, (Args&&)args...);
+ static constexpr rv
+ impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept {
+ return ((Arg1&&)arg) + next_t::impl((Arg2&&)arg2, (Args&&)args...);
}
};
template <class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr typename __fold_right_plus_impl_<Args...>::__rv
-__fold_right_plus_impl(Args&&... args) {
- return __fold_right_plus_impl_<Args...>::__impl((Args&&)args...);
+constexpr typename fold_right_plus_impl_<Args...>::rv
+fold_right_plus_impl(Args&&... args) {
+ return fold_right_plus_impl_<Args...>::impl((Args&&)args...);
}
// </editor-fold> end right plus }}}2
@@ -536,32 +545,32 @@ __fold_right_plus_impl(Args&&... args) {
// <editor-fold desc="right times"> {{{2
template <class... Args>
-struct __fold_right_times_impl_;
+struct fold_right_times_impl_;
template <class Arg>
-struct __fold_right_times_impl_<Arg> {
- using __rv = Arg&&;
+struct fold_right_times_impl_<Arg> {
+ using rv = Arg&&;
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl(Arg&& arg) noexcept {
+ static constexpr rv
+ impl(Arg&& arg) noexcept {
return (Arg&&)arg;
}
};
template <class Arg1, class Arg2, class... Args>
-struct __fold_right_times_impl_<Arg1, Arg2, Args...> {
- using __next_t = __fold_right_times_impl_<Arg2, Args...>;
- using __rv = decltype(std::declval<Arg1>() * std::declval<typename __next_t::__rv>());
+struct fold_right_times_impl_<Arg1, Arg2, Args...> {
+ using next_t = fold_right_times_impl_<Arg2, Args...>;
+ using rv = decltype(std::declval<Arg1>() * std::declval<typename next_t::rv>());
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept {
- return ((Arg1&&)arg) * __next_t::__impl((Arg2&&)arg2, (Args&&)args...);
+ static constexpr rv
+ impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept {
+ return ((Arg1&&)arg) * next_t::impl((Arg2&&)arg2, (Args&&)args...);
}
};
template <class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr typename __fold_right_times_impl_<Args...>::__rv
-__fold_right_times_impl(Args&&... args) {
- return __fold_right_times_impl_<Args...>::__impl((Args&&)args...);
+constexpr typename fold_right_times_impl_<Args...>::rv
+fold_right_times_impl(Args&&... args) {
+ return fold_right_times_impl_<Args...>::impl((Args&&)args...);
}
// </editor-fold> end right times }}}2
@@ -571,32 +580,32 @@ __fold_right_times_impl(Args&&... args) {
// <editor-fold desc="right assign"> {{{2
template <class... Args>
-struct __fold_right_assign_impl_;
+struct fold_right_assign_impl_;
template <class Arg>
-struct __fold_right_assign_impl_<Arg> {
- using __rv = Arg&&;
+struct fold_right_assign_impl_<Arg> {
+ using rv = Arg&&;
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl(Arg&& arg) noexcept {
+ static constexpr rv
+ impl(Arg&& arg) noexcept {
return (Arg&&)arg;
}
};
template <class Arg1, class Arg2, class... Args>
-struct __fold_right_assign_impl_<Arg1, Arg2, Args...> {
- using __next_t = __fold_right_assign_impl_<Arg2, Args...>;
- using __rv = decltype(std::declval<Arg1>() = std::declval<typename __next_t::__rv>());
+struct fold_right_assign_impl_<Arg1, Arg2, Args...> {
+ using next_t = fold_right_assign_impl_<Arg2, Args...>;
+ using rv = decltype(std::declval<Arg1>() = std::declval<typename next_t::rv>());
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept {
- return ((Arg1&&)arg) = __next_t::__impl((Arg2&&)arg2, (Args&&)args...);
+ static constexpr rv
+ impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept {
+ return ((Arg1&&)arg) = next_t::impl((Arg2&&)arg2, (Args&&)args...);
}
};
template <class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr typename __fold_right_assign_impl_<Args...>::__rv
-__fold_right_assign_impl(Args&&... args) {
- return __fold_right_assign_impl_<Args...>::__impl((Args&&)args...);
+constexpr typename fold_right_assign_impl_<Args...>::rv
+fold_right_assign_impl(Args&&... args) {
+ return fold_right_assign_impl_<Args...>::impl((Args&&)args...);
}
// </editor-fold> end right assign }}}2
@@ -606,33 +615,33 @@ __fold_right_assign_impl(Args&&... args) {
// <editor-fold desc="left assign"> {{{2
template <class... Args>
-struct __fold_left_assign_impl_;
+struct fold_left_assign_impl_;
template <class Arg>
-struct __fold_left_assign_impl_<Arg> {
- using __rv = Arg&&;
+struct fold_left_assign_impl_<Arg> {
+ using rv = Arg&&;
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl(Arg&& arg) noexcept {
+ static constexpr rv
+ impl(Arg&& arg) noexcept {
return (Arg&&)arg;
}
};
template <class Arg1, class Arg2, class... Args>
-struct __fold_left_assign_impl_<Arg1, Arg2, Args...> {
- using __assign_result_t = decltype(std::declval<Arg1>() = std::declval<Arg2>());
- using __next_t = __fold_left_assign_impl_<__assign_result_t, Args...>;
- using __rv = typename __next_t::__rv;
+struct fold_left_assign_impl_<Arg1, Arg2, Args...> {
+ using assign_result_t = decltype(std::declval<Arg1>() = std::declval<Arg2>());
+ using next_t = fold_left_assign_impl_<assign_result_t, Args...>;
+ using rv = typename next_t::rv;
MDSPAN_FORCE_INLINE_FUNCTION
- static constexpr __rv
- __impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept {
- return __next_t::__impl(((Arg1&&)arg) = (Arg2&&)arg2, (Args&&)args...);
+ static constexpr rv
+ impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept {
+ return next_t::impl(((Arg1&&)arg) = (Arg2&&)arg2, (Args&&)args...);
}
};
template <class... Args>
MDSPAN_FORCE_INLINE_FUNCTION
-constexpr typename __fold_left_assign_impl_<Args...>::__rv
-__fold_left_assign_impl(Args&&... args) {
- return __fold_left_assign_impl_<Args...>::__impl((Args&&)args...);
+constexpr typename fold_left_assign_impl_<Args...>::rv
+fold_left_assign_impl(Args&&... args) {
+ return fold_left_assign_impl_<Args...>::impl((Args&&)args...);
}
// </editor-fold> end left assign }}}2
@@ -642,25 +651,25 @@ __fold_left_assign_impl(Args&&... args) {
template <class... Args>
-constexpr __mdspan_enable_fold_comma __fold_comma_impl(Args&&...) noexcept { return { }; }
+constexpr enable_fold_comma fold_comma_impl(Args&&...) noexcept { return { }; }
template <bool... Bs>
-struct __bools;
+struct fold_bools;
-} // __fold_compatibility_impl
+} // fold_compatibility_impl
} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
-# define _MDSPAN_FOLD_AND(...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_and_impl((__VA_ARGS__)...)
-# define _MDSPAN_FOLD_OR(...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_or_impl((__VA_ARGS__)...)
-# define _MDSPAN_FOLD_ASSIGN_LEFT(INIT, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_left_assign_impl(INIT, (__VA_ARGS__)...)
-# define _MDSPAN_FOLD_ASSIGN_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_assign_impl((PACK)..., __VA_ARGS__)
-# define _MDSPAN_FOLD_TIMES_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_times_impl((PACK)..., __VA_ARGS__)
-# define _MDSPAN_FOLD_PLUS_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_plus_impl((PACK)..., __VA_ARGS__)
-# define _MDSPAN_FOLD_COMMA(...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_comma_impl((__VA_ARGS__)...)
+# define MDSPAN_IMPL_FOLD_AND(...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_right_and_impl((__VA_ARGS__)...)
+# define MDSPAN_IMPL_FOLD_OR(...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_right_or_impl((__VA_ARGS__)...)
+# define MDSPAN_IMPL_FOLD_ASSIGN_LEFT(INIT, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_left_assign_impl(INIT, (__VA_ARGS__)...)
+# define MDSPAN_IMPL_FOLD_ASSIGN_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_right_assign_impl((PACK)..., __VA_ARGS__)
+# define MDSPAN_IMPL_FOLD_TIMES_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_right_times_impl((PACK)..., __VA_ARGS__)
+# define MDSPAN_IMPL_FOLD_PLUS_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_right_plus_impl((PACK)..., __VA_ARGS__)
+# define MDSPAN_IMPL_FOLD_COMMA(...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_comma_impl((__VA_ARGS__)...)
-# define _MDSPAN_FOLD_AND_TEMPLATE(...) \
- _MDSPAN_TRAIT(std::is_same, __fold_compatibility_impl::__bools<(__VA_ARGS__)..., true>, __fold_compatibility_impl::__bools<true, (__VA_ARGS__)...>)
+# define MDSPAN_IMPL_FOLD_AND_TEMPLATE(...) \
+ MDSPAN_IMPL_TRAIT(std::is_same, fold_compatibility_impl::fold_bools<(__VA_ARGS__)..., true>, fold_compatibility_impl::fold_bools<true, (__VA_ARGS__)...>)
#endif
@@ -670,10 +679,10 @@ struct __bools;
//==============================================================================
// <editor-fold desc="Variable template compatibility"> {{{1
-#if _MDSPAN_USE_VARIABLE_TEMPLATES
-# define _MDSPAN_TRAIT(TRAIT, ...) TRAIT##_v<__VA_ARGS__>
+#if MDSPAN_IMPL_USE_VARIABLE_TEMPLATES
+# define MDSPAN_IMPL_TRAIT(TRAIT, ...) TRAIT##_v<__VA_ARGS__>
#else
-# define _MDSPAN_TRAIT(TRAIT, ...) TRAIT<__VA_ARGS__>::value
+# define MDSPAN_IMPL_TRAIT(TRAIT, ...) TRAIT<__VA_ARGS__>::value
#endif
// </editor-fold> end Variable template compatibility }}}1
@@ -682,18 +691,24 @@ struct __bools;
//==============================================================================
// <editor-fold desc="Pre-C++14 constexpr"> {{{1
-#if _MDSPAN_USE_CONSTEXPR_14
-# define _MDSPAN_CONSTEXPR_14 constexpr
+#if MDSPAN_IMPL_USE_CONSTEXPR_14
+# define MDSPAN_IMPL_CONSTEXPR_14 constexpr
// Workaround for a bug (I think?) in EDG frontends
# ifdef __EDG__
-# define _MDSPAN_CONSTEXPR_14_DEFAULTED
+# define MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED
# else
-# define _MDSPAN_CONSTEXPR_14_DEFAULTED constexpr
+# define MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED constexpr
# endif
#else
-# define _MDSPAN_CONSTEXPR_14
-# define _MDSPAN_CONSTEXPR_14_DEFAULTED
+# define MDSPAN_IMPL_CONSTEXPR_14
+# define MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED
#endif
// </editor-fold> end Pre-C++14 constexpr }}}1
//==============================================================================
+
+#if MDSPAN_IMPL_USE_IF_CONSTEXPR_17
+# define MDSPAN_IMPL_IF_CONSTEXPR_17 constexpr
+#else
+# define MDSPAN_IMPL_IF_CONSTEXPR_17
+#endif
diff --git a/ext/mdspan/include/experimental/__p0009_bits/mdspan.hpp b/ext/mdspan/include/experimental/__p0009_bits/mdspan.hpp
index 23114aa..b4da258 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/mdspan.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/mdspan.hpp
@@ -18,10 +18,15 @@
#include "default_accessor.hpp"
#include "layout_right.hpp"
+#include "macros.hpp"
#include "extents.hpp"
#include "trait_backports.hpp"
#include "compressed_pair.hpp"
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
template <
class ElementType,
@@ -32,36 +37,36 @@ template <
class mdspan
{
private:
- static_assert(detail::__is_extents_v<Extents>,
+ static_assert(detail::impl_is_extents_v<Extents>,
MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::mdspan's Extents template parameter must be a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents.");
static_assert(std::is_same<ElementType, typename AccessorPolicy::element_type>::value,
MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::mdspan's ElementType template parameter must be the same as its AccessorPolicy::element_type.");
// Workaround for non-deducibility of the index sequence template parameter if it's given at the top level
template <class>
- struct __deduction_workaround;
+ struct deduction_workaround;
template <size_t... Idxs>
- struct __deduction_workaround<std::index_sequence<Idxs...>>
+ struct deduction_workaround<std::index_sequence<Idxs...>>
{
MDSPAN_FORCE_INLINE_FUNCTION static constexpr
- size_t __size(mdspan const& __self) noexcept {
- return _MDSPAN_FOLD_TIMES_RIGHT((__self.__mapping_ref().extents().extent(Idxs)), /* * ... * */ size_t(1));
+ size_t size(mdspan const& self) noexcept {
+ return MDSPAN_IMPL_FOLD_TIMES_RIGHT((self.mapping_ref().extents().extent(Idxs)), /* * ... * */ size_t(1));
}
MDSPAN_FORCE_INLINE_FUNCTION static constexpr
- bool __empty(mdspan const& __self) noexcept {
- return (__self.rank()>0) && _MDSPAN_FOLD_OR((__self.__mapping_ref().extents().extent(Idxs)==index_type(0)));
+ bool empty(mdspan const& self) noexcept {
+ return (self.rank()>0) && MDSPAN_IMPL_FOLD_OR((self.mapping_ref().extents().extent(Idxs)==index_type(0)));
}
template <class ReferenceType, class SizeType, size_t N>
MDSPAN_FORCE_INLINE_FUNCTION static constexpr
- ReferenceType __callop(mdspan const& __self, const std::array<SizeType, N>& indices) noexcept {
- return __self.__accessor_ref().access(__self.__ptr_ref(), __self.__mapping_ref()(indices[Idxs]...));
+ ReferenceType callop(mdspan const& self, const std::array<SizeType, N>& indices) noexcept {
+ return self.accessor_ref().access(self.ptr_ref(), self.mapping_ref()(indices[Idxs]...));
}
#ifdef __cpp_lib_span
template <class ReferenceType, class SizeType, size_t N>
MDSPAN_FORCE_INLINE_FUNCTION static constexpr
- ReferenceType __callop(mdspan const& __self, const std::span<SizeType, N>& indices) noexcept {
- return __self.__accessor_ref().access(__self.__ptr_ref(), __self.__mapping_ref()(indices[Idxs]...));
+ ReferenceType callop(mdspan const& self, const std::span<SizeType, N>& indices) noexcept {
+ return self.accessor_ref().access(self.ptr_ref(), self.mapping_ref()(indices[Idxs]...));
}
#endif
};
@@ -83,17 +88,17 @@ public:
using data_handle_type = typename accessor_type::data_handle_type;
using reference = typename accessor_type::reference;
- MDSPAN_INLINE_FUNCTION static constexpr size_t rank() noexcept { return extents_type::rank(); }
- MDSPAN_INLINE_FUNCTION static constexpr size_t rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
+ MDSPAN_INLINE_FUNCTION static constexpr rank_type rank() noexcept { return extents_type::rank(); }
+ MDSPAN_INLINE_FUNCTION static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
MDSPAN_INLINE_FUNCTION static constexpr size_t static_extent(size_t r) noexcept { return extents_type::static_extent(r); }
- MDSPAN_INLINE_FUNCTION constexpr index_type extent(size_t r) const noexcept { return __mapping_ref().extents().extent(r); };
+ MDSPAN_INLINE_FUNCTION constexpr index_type extent(size_t r) const noexcept { return mapping_ref().extents().extent(r); }
private:
- // Can't use defaulted parameter in the __deduction_workaround template because of a bug in MSVC warning C4348.
- using __impl = __deduction_workaround<std::make_index_sequence<extents_type::rank()>>;
+ // Can't use defaulted parameter in the deduction_workaround template because of a bug in MSVC warning C4348.
+ using deduction_workaround_impl = deduction_workaround<std::make_index_sequence<extents_type::rank()>>;
- using __map_acc_pair_t = detail::__compressed_pair<mapping_type, accessor_type>;
+ using map_acc_pair_t = detail::impl_compressed_pair<mapping_type, accessor_type>;
public:
@@ -107,9 +112,9 @@ public:
requires(
// nvhpc has a bug where using just rank_dynamic() here doesn't work ...
(extents_type::rank_dynamic() > 0) &&
- _MDSPAN_TRAIT(std::is_default_constructible, data_handle_type) &&
- _MDSPAN_TRAIT(std::is_default_constructible, mapping_type) &&
- _MDSPAN_TRAIT(std::is_default_constructible, accessor_type)
+ MDSPAN_IMPL_TRAIT(std::is_default_constructible, data_handle_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_default_constructible, mapping_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type)
) = default;
#endif
MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mdspan(const mdspan&) = default;
@@ -120,87 +125,87 @@ public:
/* requires */ (
((sizeof...(SizeTypes) == rank()) || (sizeof...(SizeTypes) == rank_dynamic())) &&
(detail::are_valid_indices<index_type, SizeTypes...>()) &&
- _MDSPAN_TRAIT(std::is_constructible, mapping_type, extents_type) &&
- _MDSPAN_TRAIT(std::is_default_constructible, accessor_type)
+ MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, extents_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type)
)
)
MDSPAN_INLINE_FUNCTION
explicit constexpr mdspan(data_handle_type p, SizeTypes... dynamic_extents)
// TODO @proposal-bug shouldn't I be allowed to do `move(p)` here?
- : __members(std::move(p), __map_acc_pair_t(mapping_type(extents_type(static_cast<index_type>(std::move(dynamic_extents))...)), accessor_type()))
+ : m_members(std::move(p), map_acc_pair_t(mapping_type(extents_type(static_cast<index_type>(std::move(dynamic_extents))...)), accessor_type()))
{ }
MDSPAN_TEMPLATE_REQUIRES(
class SizeType, size_t N,
/* requires */ (
- _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) &&
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) &&
((N == rank()) || (N == rank_dynamic())) &&
- _MDSPAN_TRAIT(std::is_constructible, mapping_type, extents_type) &&
- _MDSPAN_TRAIT(std::is_default_constructible, accessor_type)
+ MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, extents_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type)
)
)
MDSPAN_CONDITIONAL_EXPLICIT(N != rank_dynamic())
MDSPAN_INLINE_FUNCTION
constexpr mdspan(data_handle_type p, const std::array<SizeType, N>& dynamic_extents)
- : __members(std::move(p), __map_acc_pair_t(mapping_type(extents_type(dynamic_extents)), accessor_type()))
+ : m_members(std::move(p), map_acc_pair_t(mapping_type(extents_type(dynamic_extents)), accessor_type()))
{ }
#ifdef __cpp_lib_span
MDSPAN_TEMPLATE_REQUIRES(
class SizeType, size_t N,
/* requires */ (
- _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) &&
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) &&
((N == rank()) || (N == rank_dynamic())) &&
- _MDSPAN_TRAIT(std::is_constructible, mapping_type, extents_type) &&
- _MDSPAN_TRAIT(std::is_default_constructible, accessor_type)
+ MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, extents_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type)
)
)
MDSPAN_CONDITIONAL_EXPLICIT(N != rank_dynamic())
MDSPAN_INLINE_FUNCTION
constexpr mdspan(data_handle_type p, std::span<SizeType, N> dynamic_extents)
- : __members(std::move(p), __map_acc_pair_t(mapping_type(extents_type(as_const(dynamic_extents))), accessor_type()))
+ : m_members(std::move(p), map_acc_pair_t(mapping_type(extents_type(as_const(dynamic_extents))), accessor_type()))
{ }
#endif
MDSPAN_FUNCTION_REQUIRES(
(MDSPAN_INLINE_FUNCTION constexpr),
mdspan, (data_handle_type p, const extents_type& exts), ,
- /* requires */ (_MDSPAN_TRAIT(std::is_default_constructible, accessor_type) &&
- _MDSPAN_TRAIT(std::is_constructible, mapping_type, const extents_type&))
- ) : __members(std::move(p), __map_acc_pair_t(mapping_type(exts), accessor_type()))
+ /* requires */ (MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, const extents_type&))
+ ) : m_members(std::move(p), map_acc_pair_t(mapping_type(exts), accessor_type()))
{ }
MDSPAN_FUNCTION_REQUIRES(
(MDSPAN_INLINE_FUNCTION constexpr),
mdspan, (data_handle_type p, const mapping_type& m), ,
- /* requires */ (_MDSPAN_TRAIT(std::is_default_constructible, accessor_type))
- ) : __members(std::move(p), __map_acc_pair_t(m, accessor_type()))
+ /* requires */ (MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type))
+ ) : m_members(std::move(p), map_acc_pair_t(m, accessor_type()))
{ }
MDSPAN_INLINE_FUNCTION
constexpr mdspan(data_handle_type p, const mapping_type& m, const accessor_type& a)
- : __members(std::move(p), __map_acc_pair_t(m, a))
+ : m_members(std::move(p), map_acc_pair_t(m, a))
{ }
MDSPAN_TEMPLATE_REQUIRES(
class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherAccessor,
/* requires */ (
- _MDSPAN_TRAIT(std::is_constructible, mapping_type, const typename OtherLayoutPolicy::template mapping<OtherExtents>&) &&
- _MDSPAN_TRAIT(std::is_constructible, accessor_type, const OtherAccessor&)
+ MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, const typename OtherLayoutPolicy::template mapping<OtherExtents>&) &&
+ MDSPAN_IMPL_TRAIT(std::is_constructible, accessor_type, const OtherAccessor&)
)
)
MDSPAN_CONDITIONAL_EXPLICIT(
- !_MDSPAN_TRAIT(std::is_convertible, const typename OtherLayoutPolicy::template mapping<OtherExtents>&, mapping_type) ||
- !_MDSPAN_TRAIT(std::is_convertible, const OtherAccessor&, accessor_type)
+ !MDSPAN_IMPL_TRAIT(std::is_convertible, const typename OtherLayoutPolicy::template mapping<OtherExtents>&, mapping_type) ||
+ !MDSPAN_IMPL_TRAIT(std::is_convertible, const OtherAccessor&, accessor_type)
)
MDSPAN_INLINE_FUNCTION
constexpr mdspan(const mdspan<OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessor>& other)
- : __members(other.__ptr_ref(), __map_acc_pair_t(other.__mapping_ref(), other.__accessor_ref()))
+ : m_members(other.ptr_ref(), map_acc_pair_t(other.mapping_ref(), other.accessor_ref()))
{
- static_assert(_MDSPAN_TRAIT(std::is_constructible, data_handle_type, typename OtherAccessor::data_handle_type),"Incompatible data_handle_type for mdspan construction");
- static_assert(_MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents),"Incompatible extents for mdspan construction");
+ static_assert(MDSPAN_IMPL_TRAIT(std::is_constructible, data_handle_type, typename OtherAccessor::data_handle_type),"Incompatible data_handle_type for mdspan construction");
+ static_assert(MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents),"Incompatible extents for mdspan construction");
/*
* TODO: Check precondition
* For each rank index r of extents_type, static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r) is true.
@@ -212,54 +217,114 @@ public:
~mdspan() = default;
*/
- MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED mdspan& operator=(const mdspan&) = default;
- MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED mdspan& operator=(mdspan&&) = default;
+ MDSPAN_INLINE_FUNCTION_DEFAULTED MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED mdspan& operator=(const mdspan&) = default;
+ MDSPAN_INLINE_FUNCTION_DEFAULTED MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED mdspan& operator=(mdspan&&) = default;
//--------------------------------------------------------------------------------
// [mdspan.basic.mapping], mdspan mapping domain multidimensional index to access codomain element
+ MDSPAN_TEMPLATE_REQUIRES(
+ class... SizeTypes,
+ /* requires */ (
+ extents_type::rank() == sizeof...(SizeTypes) &&
+ (detail::are_valid_indices<index_type, SizeTypes...>())
+ )
+ )
+ constexpr reference at(SizeTypes... indices) const
+ {
+ size_t r = 0;
+ for (const auto& index : {indices...}) {
+ if (is_index_oor(index, mapping_ref().extents().extent(r))) {
+ throw std::out_of_range(
+ "mdspan::at(...," + std::to_string(index) + ",...) out-of-range at rank index " + std::to_string(r) +
+ " for mdspan with extent {...," + std::to_string(mapping_ref().extents().extent(r)) + ",...}");
+ }
+ ++r;
+ }
+ return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast<index_type>(std::move(indices))...));
+ }
+
+ MDSPAN_TEMPLATE_REQUIRES(
+ class SizeType,
+ /* requires */ (
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
+ )
+ )
+ constexpr reference at(const std::array<SizeType, rank()>& indices) const
+ {
+ for (size_t r = 0; r < indices.size(); ++r) {
+ if (is_index_oor(indices[r], mapping_ref().extents().extent(r))) {
+ throw std::out_of_range(
+ "mdspan::at({...," + std::to_string(indices[r]) + ",...}) out-of-range at rank index " + std::to_string(r) +
+ " for mdspan with extent {...," + std::to_string(mapping_ref().extents().extent(r)) + ",...}");
+ }
+ }
+ return deduction_workaround_impl::template callop<reference>(*this, indices);
+ }
+
+ #ifdef __cpp_lib_span
+ MDSPAN_TEMPLATE_REQUIRES(
+ class SizeType,
+ /* requires */ (
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
+ )
+ )
+ constexpr reference at(std::span<SizeType, rank()> indices) const
+ {
+ for (size_t r = 0; r < indices.size(); ++r) {
+ if (is_index_oor(indices[r], mapping_ref().extents().extent(r))) {
+ throw std::out_of_range(
+ "mdspan::at({...," + std::to_string(indices[r]) + ",...}) out-of-range at rank index " + std::to_string(r) +
+ " for mdspan with extent {...," + std::to_string(mapping_ref().extents().extent(r)) + ",...}");
+ }
+ }
+ return deduction_workaround_impl::template callop<reference>(*this, indices);
+ }
+ #endif // __cpp_lib_span
+
#if MDSPAN_USE_BRACKET_OPERATOR
MDSPAN_TEMPLATE_REQUIRES(
class... SizeTypes,
/* requires */ (
- _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_convertible, SizeTypes, index_type) /* && ... */) &&
- _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, SizeTypes) /* && ... */) &&
- (rank() == sizeof...(SizeTypes))
+ extents_type::rank() == sizeof...(SizeTypes) &&
+ (detail::are_valid_indices<index_type, SizeTypes...>())
)
)
MDSPAN_FORCE_INLINE_FUNCTION
constexpr reference operator[](SizeTypes... indices) const
{
- return __accessor_ref().access(__ptr_ref(), __mapping_ref()(static_cast<index_type>(std::move(indices))...));
+ return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast<index_type>(std::move(indices))...));
}
#endif
MDSPAN_TEMPLATE_REQUIRES(
class SizeType,
/* requires */ (
- _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
)
)
MDSPAN_FORCE_INLINE_FUNCTION
- constexpr reference operator[](const std::array< SizeType, rank()>& indices) const
+ constexpr reference operator[](const std::array<SizeType, rank()>& indices) const
{
- return __impl::template __callop<reference>(*this, indices);
+ return deduction_workaround_impl::template callop<reference>(*this, indices);
}
#ifdef __cpp_lib_span
MDSPAN_TEMPLATE_REQUIRES(
class SizeType,
/* requires */ (
- _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
)
)
MDSPAN_FORCE_INLINE_FUNCTION
constexpr reference operator[](std::span<SizeType, rank()> indices) const
{
- return __impl::template __callop<reference>(*this, indices);
+ return deduction_workaround_impl::template callop<reference>(*this, indices);
}
#endif // __cpp_lib_span
@@ -267,15 +332,15 @@ public:
MDSPAN_TEMPLATE_REQUIRES(
class Index,
/* requires */ (
- _MDSPAN_TRAIT(std::is_convertible, Index, index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, Index) &&
+ MDSPAN_IMPL_TRAIT(std::is_convertible, Index, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, Index) &&
extents_type::rank() == 1
)
)
MDSPAN_FORCE_INLINE_FUNCTION
constexpr reference operator[](Index idx) const
{
- return __accessor_ref().access(__ptr_ref(), __mapping_ref()(static_cast<index_type>(std::move(idx))));
+ return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast<index_type>(std::move(idx))));
}
#endif
@@ -290,54 +355,54 @@ public:
MDSPAN_FORCE_INLINE_FUNCTION
constexpr reference operator()(SizeTypes... indices) const
{
- return __accessor_ref().access(__ptr_ref(), __mapping_ref()(static_cast<index_type>(std::move(indices))...));
+ return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast<index_type>(std::move(indices))...));
}
MDSPAN_TEMPLATE_REQUIRES(
class SizeType,
/* requires */ (
- _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
)
)
MDSPAN_FORCE_INLINE_FUNCTION
constexpr reference operator()(const std::array<SizeType, rank()>& indices) const
{
- return __impl::template __callop<reference>(*this, indices);
+ return deduction_workaround_impl::template callop<reference>(*this, indices);
}
#ifdef __cpp_lib_span
MDSPAN_TEMPLATE_REQUIRES(
class SizeType,
/* requires */ (
- _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
- _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
)
)
MDSPAN_FORCE_INLINE_FUNCTION
constexpr reference operator()(std::span<SizeType, rank()> indices) const
{
- return __impl::template __callop<reference>(*this, indices);
+ return deduction_workaround_impl::template callop<reference>(*this, indices);
}
#endif // __cpp_lib_span
#endif // MDSPAN_USE_PAREN_OPERATOR
MDSPAN_INLINE_FUNCTION constexpr size_type size() const noexcept {
- return static_cast<size_type>(__impl::__size(*this));
- };
+ return static_cast<size_type>(deduction_workaround_impl::size(*this));
+ }
MDSPAN_INLINE_FUNCTION constexpr bool empty() const noexcept {
- return __impl::__empty(*this);
- };
+ return deduction_workaround_impl::empty(*this);
+ }
MDSPAN_INLINE_FUNCTION
friend constexpr void swap(mdspan& x, mdspan& y) noexcept {
// can't call the std::swap inside on HIP
- #if !defined(_MDSPAN_HAS_HIP) && !defined(_MDSPAN_HAS_CUDA)
+ #if !defined(MDSPAN_IMPL_HAS_HIP) && !defined(MDSPAN_IMPL_HAS_CUDA)
using std::swap;
- swap(x.__ptr_ref(), y.__ptr_ref());
- swap(x.__mapping_ref(), y.__mapping_ref());
- swap(x.__accessor_ref(), y.__accessor_ref());
+ swap(x.ptr_ref(), y.ptr_ref());
+ swap(x.mapping_ref(), y.mapping_ref());
+ swap(x.accessor_ref(), y.accessor_ref());
#else
mdspan tmp = y;
y = x;
@@ -349,43 +414,60 @@ public:
// [mdspan.basic.domobs], mdspan observers of the domain multidimensional index space
- MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { return __mapping_ref().extents(); };
- MDSPAN_INLINE_FUNCTION constexpr const data_handle_type& data_handle() const noexcept { return __ptr_ref(); };
- MDSPAN_INLINE_FUNCTION constexpr const mapping_type& mapping() const noexcept { return __mapping_ref(); };
- MDSPAN_INLINE_FUNCTION constexpr const accessor_type& accessor() const noexcept { return __accessor_ref(); };
+ MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { return mapping_ref().extents(); }
+ MDSPAN_INLINE_FUNCTION constexpr const data_handle_type& data_handle() const noexcept { return ptr_ref(); }
+ MDSPAN_INLINE_FUNCTION constexpr const mapping_type& mapping() const noexcept { return mapping_ref(); }
+ MDSPAN_INLINE_FUNCTION constexpr const accessor_type& accessor() const noexcept { return accessor_ref(); }
//--------------------------------------------------------------------------------
// [mdspan.basic.obs], mdspan observers of the mapping
- MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() { return mapping_type::is_always_unique(); };
- MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() { return mapping_type::is_always_exhaustive(); };
- MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() { return mapping_type::is_always_strided(); };
+ MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() { return mapping_type::is_always_unique(); }
+ MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() { return mapping_type::is_always_exhaustive(); }
+ MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() { return mapping_type::is_always_strided(); }
- MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const { return __mapping_ref().is_unique(); };
- MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const { return __mapping_ref().is_exhaustive(); };
- MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const { return __mapping_ref().is_strided(); };
- MDSPAN_INLINE_FUNCTION constexpr index_type stride(size_t r) const { return __mapping_ref().stride(r); };
+ MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const { return mapping_ref().is_unique(); }
+ MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const { return mapping_ref().is_exhaustive(); }
+ MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const { return mapping_ref().is_strided(); }
+ MDSPAN_INLINE_FUNCTION constexpr index_type stride(size_t r) const { return mapping_ref().stride(r); }
private:
- detail::__compressed_pair<data_handle_type, __map_acc_pair_t> __members{};
+ detail::impl_compressed_pair<data_handle_type, map_acc_pair_t> m_members{};
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 data_handle_type& __ptr_ref() noexcept { return __members.__first(); }
- MDSPAN_FORCE_INLINE_FUNCTION constexpr data_handle_type const& __ptr_ref() const noexcept { return __members.__first(); }
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 mapping_type& __mapping_ref() noexcept { return __members.__second().__first(); }
- MDSPAN_FORCE_INLINE_FUNCTION constexpr mapping_type const& __mapping_ref() const noexcept { return __members.__second().__first(); }
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 accessor_type& __accessor_ref() noexcept { return __members.__second().__second(); }
- MDSPAN_FORCE_INLINE_FUNCTION constexpr accessor_type const& __accessor_ref() const noexcept { return __members.__second().__second(); }
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 data_handle_type& ptr_ref() noexcept { return m_members.first(); }
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr data_handle_type const& ptr_ref() const noexcept { return m_members.first(); }
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping_type& mapping_ref() noexcept { return m_members.second().first(); }
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr mapping_type const& mapping_ref() const noexcept { return m_members.second().first(); }
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 accessor_type& accessor_ref() noexcept { return m_members.second().second(); }
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr accessor_type const& accessor_ref() const noexcept { return m_members.second().second(); }
+
+ MDSPAN_TEMPLATE_REQUIRES(
+ class SizeType,
+ /* requires */ (
+ MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+ MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
+ )
+ )
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr bool is_index_oor(SizeType index, index_type extent) const noexcept {
+ // Check for negative indices
+ if MDSPAN_IMPL_IF_CONSTEXPR_17 (MDSPAN_IMPL_TRAIT(std::is_signed, SizeType)) {
+ if(index < 0) {
+ return true;
+ }
+ }
+ return static_cast<index_type>(index) >= extent;
+ }
template <class, class, class, class>
friend class mdspan;
};
-#if defined(_MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
+#if defined(MDSPAN_IMPL_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
MDSPAN_TEMPLATE_REQUIRES(
class ElementType, class... SizeTypes,
- /* requires */ _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_convertible, SizeTypes, size_t) /* && ... */) &&
+ /* requires */ MDSPAN_IMPL_FOLD_AND(MDSPAN_IMPL_TRAIT(std::is_convertible, SizeTypes, size_t) /* && ... */) &&
(sizeof...(SizeTypes) > 0)
)
MDSPAN_DEDUCTION_GUIDE explicit mdspan(ElementType*, SizeTypes...)
@@ -393,13 +475,13 @@ MDSPAN_DEDUCTION_GUIDE explicit mdspan(ElementType*, SizeTypes...)
MDSPAN_TEMPLATE_REQUIRES(
class Pointer,
- (_MDSPAN_TRAIT(std::is_pointer, std::remove_reference_t<Pointer>))
+ (MDSPAN_IMPL_TRAIT(std::is_pointer, std::remove_reference_t<Pointer>))
)
MDSPAN_DEDUCTION_GUIDE mdspan(Pointer&&) -> mdspan<std::remove_pointer_t<std::remove_reference_t<Pointer>>, extents<size_t>>;
MDSPAN_TEMPLATE_REQUIRES(
class CArray,
- (_MDSPAN_TRAIT(std::is_array, CArray) && (std::rank_v<CArray> == 1))
+ (MDSPAN_IMPL_TRAIT(std::is_array, CArray) && (std::rank_v<CArray> == 1))
)
MDSPAN_DEDUCTION_GUIDE mdspan(CArray&) -> mdspan<std::remove_all_extents_t<CArray>, extents<size_t, ::std::extent_v<CArray,0>>>;
diff --git a/ext/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp b/ext/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp
index 36e64ee..b7b07c6 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp
@@ -23,72 +23,72 @@ namespace detail {
//==============================================================================
-template <class _T, size_t _Disambiguator = 0, class _Enable = void>
-struct __no_unique_address_emulation {
- using __stored_type = _T;
- _T __v;
- MDSPAN_FORCE_INLINE_FUNCTION constexpr _T const &__ref() const noexcept {
- return __v;
+template <class T, size_t Disambiguator = 0, class Enable = void>
+struct no_unique_address_emulation {
+ using stored_type = T;
+ T m_v;
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr T const &ref() const noexcept {
+ return m_v;
}
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T &__ref() noexcept {
- return __v;
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T &ref() noexcept {
+ return m_v;
}
};
// Empty case
-// This doesn't work if _T is final, of course, but we're not using anything
+// This doesn't work if T is final, of course, but we're not using anything
// like that currently. That kind of thing could be added pretty easily though
-template <class _T, size_t _Disambiguator>
-struct __no_unique_address_emulation<
- _T, _Disambiguator,
- std::enable_if_t<_MDSPAN_TRAIT(std::is_empty, _T) &&
+template <class T, size_t Disambiguator>
+struct no_unique_address_emulation<
+ T, Disambiguator,
+ std::enable_if_t<MDSPAN_IMPL_TRAIT(std::is_empty, T) &&
// If the type isn't trivially destructible, its destructor
// won't be called at the right time, so don't use this
// specialization
- _MDSPAN_TRAIT(std::is_trivially_destructible, _T)>> :
-#ifdef _MDSPAN_COMPILER_MSVC
+ MDSPAN_IMPL_TRAIT(std::is_trivially_destructible, T)>> :
+#ifdef MDSPAN_IMPL_COMPILER_MSVC
// MSVC doesn't allow you to access public static member functions of a type
// when you *happen* to privately inherit from that type.
protected
#else
// But we still want this to be private if possible so that we don't accidentally
- // access members of _T directly rather than calling __ref() first, which wouldn't
- // work if _T happens to be stateful and thus we're using the unspecialized definition
- // of __no_unique_address_emulation above.
+ // access members of T directly rather than calling ref() first, which wouldn't
+ // work if T happens to be stateful and thus we're using the unspecialized definition
+ // of no_unique_address_emulation above.
private
#endif
- _T {
- using __stored_type = _T;
- MDSPAN_FORCE_INLINE_FUNCTION constexpr _T const &__ref() const noexcept {
- return *static_cast<_T const *>(this);
+ T {
+ using stored_type = T;
+ MDSPAN_FORCE_INLINE_FUNCTION constexpr T const &ref() const noexcept {
+ return *static_cast<T const *>(this);
}
- MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T &__ref() noexcept {
- return *static_cast<_T *>(this);
+ MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T &ref() noexcept {
+ return *static_cast<T *>(this);
}
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __no_unique_address_emulation() noexcept = default;
+ constexpr no_unique_address_emulation() noexcept = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __no_unique_address_emulation(
- __no_unique_address_emulation const &) noexcept = default;
+ constexpr no_unique_address_emulation(
+ no_unique_address_emulation const &) noexcept = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- constexpr __no_unique_address_emulation(
- __no_unique_address_emulation &&) noexcept = default;
+ constexpr no_unique_address_emulation(
+ no_unique_address_emulation &&) noexcept = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- _MDSPAN_CONSTEXPR_14_DEFAULTED __no_unique_address_emulation &
- operator=(__no_unique_address_emulation const &) noexcept = default;
+ MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED no_unique_address_emulation &
+ operator=(no_unique_address_emulation const &) noexcept = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- _MDSPAN_CONSTEXPR_14_DEFAULTED __no_unique_address_emulation &
- operator=(__no_unique_address_emulation &&) noexcept = default;
+ MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED no_unique_address_emulation &
+ operator=(no_unique_address_emulation &&) noexcept = default;
MDSPAN_INLINE_FUNCTION_DEFAULTED
- ~__no_unique_address_emulation() noexcept = default;
+ ~no_unique_address_emulation() noexcept = default;
// Explicitly make this not a reference so that the copy or move
// constructor still gets called.
MDSPAN_INLINE_FUNCTION
- explicit constexpr __no_unique_address_emulation(_T const& __v) noexcept : _T(__v) {}
+ explicit constexpr no_unique_address_emulation(T const& v) noexcept : T(v) {}
MDSPAN_INLINE_FUNCTION
- explicit constexpr __no_unique_address_emulation(_T&& __v) noexcept : _T(::std::move(__v)) {}
+ explicit constexpr no_unique_address_emulation(T&& v) noexcept : T(::std::move(v)) {}
};
//==============================================================================
diff --git a/ext/mdspan/include/experimental/__p0009_bits/trait_backports.hpp b/ext/mdspan/include/experimental/__p0009_bits/trait_backports.hpp
index 4933dd9..70651a7 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/trait_backports.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/trait_backports.hpp
@@ -25,30 +25,30 @@
//==============================================================================
// <editor-fold desc="Variable template trait backports (e.g., is_void_v)"> {{{1
-#ifdef _MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS
+#ifdef MDSPAN_IMPL_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS
-#if _MDSPAN_USE_VARIABLE_TEMPLATES
+#if MDSPAN_IMPL_USE_VARIABLE_TEMPLATES
namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
-#define _MDSPAN_BACKPORT_TRAIT(TRAIT) \
- template <class... Args> _MDSPAN_INLINE_VARIABLE constexpr auto TRAIT##_v = TRAIT<Args...>::value;
+#define MDSPAN_IMPL_BACKPORT_TRAIT(TRAIT) \
+ template <class... Args> MDSPAN_IMPL_INLINE_VARIABLE constexpr auto TRAIT##_v = TRAIT<Args...>::value;
-_MDSPAN_BACKPORT_TRAIT(is_assignable)
-_MDSPAN_BACKPORT_TRAIT(is_constructible)
-_MDSPAN_BACKPORT_TRAIT(is_convertible)
-_MDSPAN_BACKPORT_TRAIT(is_default_constructible)
-_MDSPAN_BACKPORT_TRAIT(is_trivially_destructible)
-_MDSPAN_BACKPORT_TRAIT(is_same)
-_MDSPAN_BACKPORT_TRAIT(is_empty)
-_MDSPAN_BACKPORT_TRAIT(is_void)
+MDSPAN_IMPL_BACKPORT_TRAIT(is_assignable)
+MDSPAN_IMPL_BACKPORT_TRAIT(is_constructible)
+MDSPAN_IMPL_BACKPORT_TRAIT(is_convertible)
+MDSPAN_IMPL_BACKPORT_TRAIT(is_default_constructible)
+MDSPAN_IMPL_BACKPORT_TRAIT(is_trivially_destructible)
+MDSPAN_IMPL_BACKPORT_TRAIT(is_same)
+MDSPAN_IMPL_BACKPORT_TRAIT(is_empty)
+MDSPAN_IMPL_BACKPORT_TRAIT(is_void)
-#undef _MDSPAN_BACKPORT_TRAIT
+#undef MDSPAN_IMPL_BACKPORT_TRAIT
} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
-#endif // _MDSPAN_USE_VARIABLE_TEMPLATES
+#endif // MDSPAN_IMPL_USE_VARIABLE_TEMPLATES
-#endif // _MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS
+#endif // MDSPAN_IMPL_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS
// </editor-fold> end Variable template trait backports (e.g., is_void_v) }}}1
//==============================================================================
@@ -56,7 +56,7 @@ _MDSPAN_BACKPORT_TRAIT(is_void)
//==============================================================================
// <editor-fold desc="integer sequence (ugh...)"> {{{1
-#if !defined(_MDSPAN_USE_INTEGER_SEQUENCE) || !_MDSPAN_USE_INTEGER_SEQUENCE
+#if !defined(MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14) || !MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14
namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
@@ -107,20 +107,20 @@ using index_sequence_for = make_index_sequence<sizeof...(T)>;
//==============================================================================
// <editor-fold desc="standard trait aliases"> {{{1
-#if !defined(_MDSPAN_USE_STANDARD_TRAIT_ALIASES) || !_MDSPAN_USE_STANDARD_TRAIT_ALIASES
+#if !defined(MDSPAN_IMPL_USE_STANDARD_TRAIT_ALIASES) || !MDSPAN_IMPL_USE_STANDARD_TRAIT_ALIASES
namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
-#define _MDSPAN_BACKPORT_TRAIT_ALIAS(TRAIT) \
+#define MDSPAN_IMPL_BACKPORT_TRAIT_ALIAS(TRAIT) \
template <class... Args> using TRAIT##_t = typename TRAIT<Args...>::type;
-_MDSPAN_BACKPORT_TRAIT_ALIAS(remove_cv)
-_MDSPAN_BACKPORT_TRAIT_ALIAS(remove_reference)
+MDSPAN_IMPL_BACKPORT_TRAIT_ALIAS(remove_cv)
+MDSPAN_IMPL_BACKPORT_TRAIT_ALIAS(remove_reference)
-template <bool _B, class _T=void>
-using enable_if_t = typename enable_if<_B, _T>::type;
+template <bool _B, class T=void>
+using enable_if_t = typename enable_if<_B, T>::type;
-#undef _MDSPAN_BACKPORT_TRAIT_ALIAS
+#undef MDSPAN_IMPL_BACKPORT_TRAIT_ALIAS
} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/ext/mdspan/include/experimental/__p0009_bits/type_list.hpp b/ext/mdspan/include/experimental/__p0009_bits/type_list.hpp
index deca7c1..23d5856 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/type_list.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/type_list.hpp
@@ -23,59 +23,59 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
namespace detail {
-template <class... _Ts> struct __type_list { static constexpr auto __size = sizeof...(_Ts); };
+template <class... Ts> struct type_list { static constexpr auto size = sizeof...(Ts); };
// Implementation of type_list at() that's heavily optimized for small typelists
-template <size_t, class> struct __type_at;
-template <size_t, class _Seq, class=std::make_index_sequence<_Seq::__size>> struct __type_at_large_impl;
+template <size_t, class> struct type_at;
+template <size_t, class Seq, class=std::make_index_sequence<Seq::size>> struct type_at_large_impl;
-template <size_t _I, size_t _Idx, class _T>
-struct __type_at_entry { };
+template <size_t I, size_t Idx, class T>
+struct type_at_entry { };
-template <class _Result>
-struct __type_at_assign_op_ignore_rest {
- template <class _T>
- __type_at_assign_op_ignore_rest<_Result> operator=(_T&&);
- using type = _Result;
+template <class Result>
+struct type_at_assign_op_ignore_rest {
+ template <class T>
+ type_at_assign_op_ignore_rest<Result> operator=(T&&);
+ using type = Result;
};
-struct __type_at_assign_op_impl {
- template <size_t _I, size_t _Idx, class _T>
- __type_at_assign_op_impl operator=(__type_at_entry<_I, _Idx, _T>&&);
- template <size_t _I, class _T>
- __type_at_assign_op_ignore_rest<_T> operator=(__type_at_entry<_I, _I, _T>&&);
+struct type_at_assign_op_impl {
+ template <size_t I, size_t Idx, class T>
+ type_at_assign_op_impl operator=(type_at_entry<I, Idx, T>&&);
+ template <size_t I, class T>
+ type_at_assign_op_ignore_rest<T> operator=(type_at_entry<I, I, T>&&);
};
-template <size_t _I, class... _Ts, size_t... _Idxs>
-struct __type_at_large_impl<_I, __type_list<_Ts...>, std::integer_sequence<size_t, _Idxs...>>
+template <size_t I, class... Ts, size_t... Idxs>
+struct type_at_large_impl<I, type_list<Ts...>, std::integer_sequence<size_t, Idxs...>>
: decltype(
- _MDSPAN_FOLD_ASSIGN_LEFT(__type_at_assign_op_impl{}, /* = ... = */ __type_at_entry<_I, _Idxs, _Ts>{})
+ MDSPAN_IMPL_FOLD_ASSIGN_LEFT(type_at_assign_op_impl{}, /* = ... = */ type_at_entry<I, Idxs, Ts>{})
)
{ };
-template <size_t _I, class... _Ts>
-struct __type_at<_I, __type_list<_Ts...>>
- : __type_at_large_impl<_I, __type_list<_Ts...>>
+template <size_t I, class... Ts>
+struct type_at<I, type_list<Ts...>>
+ : type_at_large_impl<I, type_list<Ts...>>
{ };
-template <class _T0, class... _Ts>
-struct __type_at<0, __type_list<_T0, _Ts...>> {
- using type = _T0;
+template <class T0, class... Ts>
+struct type_at<0, type_list<T0, Ts...>> {
+ using type = T0;
};
-template <class _T0, class _T1, class... _Ts>
-struct __type_at<1, __type_list<_T0, _T1, _Ts...>> {
- using type = _T1;
+template <class T0, class T1, class... Ts>
+struct type_at<1, type_list<T0, T1, Ts...>> {
+ using type = T1;
};
-template <class _T0, class _T1, class _T2, class... _Ts>
-struct __type_at<2, __type_list<_T0, _T1, _T2, _Ts...>> {
- using type = _T2;
+template <class T0, class T1, class T2, class... Ts>
+struct type_at<2, type_list<T0, T1, T2, Ts...>> {
+ using type = T2;
};
-template <class _T0, class _T1, class _T2, class _T3, class... _Ts>
-struct __type_at<3, __type_list<_T0, _T1, _T2, _T3, _Ts...>> {
- using type = _T3;
+template <class T0, class T1, class T2, class T3, class... Ts>
+struct type_at<3, type_list<T0, T1, T2, T3, Ts...>> {
+ using type = T3;
};
@@ -84,4 +84,3 @@ struct __type_at<3, __type_list<_T0, _T1, _T2, _T3, _Ts...>> {
//==============================================================================
} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
-
diff --git a/ext/mdspan/include/experimental/__p0009_bits/utility.hpp b/ext/mdspan/include/experimental/__p0009_bits/utility.hpp
index a078eeb..2d8a938 100644
--- a/ext/mdspan/include/experimental/__p0009_bits/utility.hpp
+++ b/ext/mdspan/include/experimental/__p0009_bits/utility.hpp
@@ -4,6 +4,12 @@
#include <type_traits>
#include <array>
#include <utility>
+#if defined(MDSPAN_IMPL_HAS_CUDA) && defined(__NVCC__) && (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 >= 1260)
+#include <cuda/std/limits>
+#else
+#include <limits>
+#endif
+#include "macros.hpp"
namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
namespace detail {
@@ -46,7 +52,10 @@ constexpr bool rankwise_equal(with_rank<N>, const T1& x, const T2& y, F func)
return match;
}
-constexpr struct
+#if MDSPAN_HAS_CXX_17
+inline
+#endif
+constexpr struct extent_functor
{
template <class T, class I>
MDSPAN_INLINE_FUNCTION
@@ -56,7 +65,10 @@ constexpr struct
}
} extent;
-constexpr struct
+#if MDSPAN_HAS_CXX_17
+inline
+#endif
+constexpr struct stride_functor
{
template <class T, class I>
MDSPAN_INLINE_FUNCTION
@@ -81,7 +93,7 @@ struct integral_constant {
// These interop functions work, because other than the value_type operator
// everything of std::integral_constant works on device (defaulted functions)
MDSPAN_FUNCTION
- constexpr integral_constant(std::integral_constant<T,v>) {};
+ constexpr integral_constant(std::integral_constant<T,v>) {}
MDSPAN_FUNCTION constexpr operator std::integral_constant<T,v>() const noexcept {
return std::integral_constant<T,v>{};
@@ -164,8 +176,70 @@ constexpr const auto& get(const tuple<Args...>& vals) { return vals.template get
template<class ... Elements>
tuple(Elements ...) -> tuple<Elements...>;
#endif
+
+#if MDSPAN_HAS_CXX_17
+// std::in_range and friends, tagged for device execution
+// Backport from https://en.cppreference.com/w/cpp/utility/intcmp
+// and https://en.cppreference.com/w/cpp/utility/in_range
+template <class T, class U>
+MDSPAN_INLINE_FUNCTION constexpr bool cmp_less(T t, U u) noexcept {
+ if constexpr (std::is_signed_v<T> == std::is_signed_v<U>)
+ return t < u;
+ else if constexpr (std::is_signed_v<T>)
+ return t < 0 || std::make_unsigned_t<T>(t) < u;
+ else
+ return u >= 0 && t < std::make_unsigned_t<U>(u);
+}
+
+template <class T, class U>
+MDSPAN_INLINE_FUNCTION constexpr bool cmp_less_equal(T t, U u) noexcept {
+ return !cmp_less(u, t);
+}
+
+template <class T, class U>
+MDSPAN_INLINE_FUNCTION constexpr bool cmp_greater_equal(T t, U u) noexcept {
+ return !cmp_less(t, u);
+}
+
+template <class R, class T>
+MDSPAN_INLINE_FUNCTION constexpr bool in_range(T t) noexcept {
+#if defined(MDSPAN_IMPL_HAS_CUDA) && defined(__NVCC__) && (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 >= 1260)
+ using cuda::std::numeric_limits;
+#else
+ using std::numeric_limits;
+#endif
+ return cmp_greater_equal(t, numeric_limits<R>::min()) &&
+ cmp_less_equal(t, numeric_limits<R>::max());
+}
+
+template <typename T >
+MDSPAN_INLINE_FUNCTION constexpr bool
+check_mul_result_is_nonnegative_and_representable(T a, T b) {
+// FIXME_SYCL The code below compiles to old_llvm.umul.with.overflow.i64
+// which isn't defined in device code
+#ifdef __SYCL_DEVICE_ONLY__
+ return true;
+#else
+ if (b == 0 || a == 0)
+ return true;
+
+ if constexpr (std::is_signed_v<T>) {
+ if ( a < 0 || b < 0 ) return false;
+ }
+#if defined(MDSPAN_IMPL_HAS_CUDA) && defined(__NVCC__) && (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 >= 1260)
+ using cuda::std::numeric_limits;
+#else
+ using std::numeric_limits;
+#endif
+ return a <= numeric_limits<T>::max() / b;
+#endif
+}
+#endif
} // namespace detail
+#if MDSPAN_HAS_CXX_17
+inline
+#endif
constexpr struct mdspan_non_standard_tag {
} mdspan_non_standard;
generated by cgit v1.2.3 (git 2.25.1) at 2026-07-01 21:59:20 +0000