From 06ebb8835022b92ea64c5b10bdb3f5afbad0e5f8 Mon Sep 17 00:00:00 2001 From: Tomi Valkeinen Date: Thu, 18 Dec 2025 12:28:37 +0200 Subject: Update mdspan headers to 546d4dd63697c6a331554adb6fe650e09b690812 --- .../experimental/__p0009_bits/compressed_pair.hpp | 206 ++++++------ .../include/experimental/__p0009_bits/config.hpp | 197 +++++------ .../experimental/__p0009_bits/default_accessor.hpp | 2 +- .../experimental/__p0009_bits/dynamic_extent.hpp | 2 +- .../include/experimental/__p0009_bits/extents.hpp | 95 +++--- .../experimental/__p0009_bits/full_extent_t.hpp | 2 +- .../experimental/__p0009_bits/layout_left.hpp | 94 +++--- .../experimental/__p0009_bits/layout_right.hpp | 98 +++--- .../experimental/__p0009_bits/layout_stride.hpp | 260 ++++++++------- .../include/experimental/__p0009_bits/macros.hpp | 363 +++++++++++---------- .../include/experimental/__p0009_bits/mdspan.hpp | 280 ++++++++++------ .../__p0009_bits/no_unique_address.hpp | 72 ++-- .../experimental/__p0009_bits/trait_backports.hpp | 46 +-- .../experimental/__p0009_bits/type_list.hpp | 67 ++-- .../include/experimental/__p0009_bits/utility.hpp | 80 ++++- 15 files changed, 1035 insertions(+), 829 deletions(-) (limited to 'ext/mdspan/include/experimental/__p0009_bits') 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 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 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 - MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2) - : __t1_val((_T1Like &&) __t1), __t2_val((_T2Like &&) __t2) {} + ~impl_compressed_pair() = default; + template + 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 -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 +struct impl_compressed_pair< + T1, T2, + std::enable_if_t> + : private T1 { + T2 m_t2_val{}; + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T1 &first() noexcept { + return *static_cast(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(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 - MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2) - : _T1((_T1Like &&) __t1), __t2_val((_T2Like &&) __t2) {} + ~impl_compressed_pair() = default; + template + MDSPAN_INLINE_FUNCTION constexpr impl_compressed_pair(T1Like &&t1, T2Like &&t2) + : T1((T1Like &&) t1), m_t2_val((T2Like &&) t2) {} }; // Second empty. -template -struct __compressed_pair< - _T1, _T2, - std::enable_if_t> - : 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 +struct impl_compressed_pair< + T1, T2, + std::enable_if_t> + : 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(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(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 - MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2) - : _T2((_T2Like &&) __t2), __t1_val((_T1Like &&) __t1) {} + template + MDSPAN_INLINE_FUNCTION constexpr impl_compressed_pair(T1Like &&t1, T2Like &&t2) + : T2((T2Like &&) t2), m_t1_val((T1Like &&) t1) {} }; // Both empty. -template -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 +struct impl_compressed_pair< + T1, T2, + std::enable_if_t> + // 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, + protected no_unique_address_emulation #else - : private __no_unique_address_emulation<_T1, 0>, - private __no_unique_address_emulation<_T2, 1> + : private no_unique_address_emulation, + private no_unique_address_emulation #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; + using second_base_t = no_unique_address_emulation; - 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 - 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 + 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() +#if MDSPAN_IMPL_HAS_INCLUDE() # include #else # include @@ -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 #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::max(); +MDSPAN_IMPL_INLINE_VARIABLE constexpr auto dynamic_extent = std::numeric_limits::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 MDSPAN_INLINE_FUNCTION -static constexpr std::integral_constant __check_compatible_extents( +constexpr std::integral_constant impl_check_compatible_extents( std::integral_constant, std::integer_sequence, std::integer_sequence) noexcept { @@ -43,7 +43,7 @@ static constexpr std::integral_constant __check_compatible_extents( // This helper prevents ICE's on MSVC. template -struct __compare_extent_compatible : std::integral_constant @@ -51,9 +51,9 @@ struct __compare_extent_compatible : std::integral_constant MDSPAN_INLINE_FUNCTION -static constexpr std::integral_constant< - bool, _MDSPAN_FOLD_AND(__compare_extent_compatible::value)> -__check_compatible_extents( +constexpr std::integral_constant< + bool, MDSPAN_IMPL_FOLD_AND(impl_compare_extent_compatible::value)> +impl_check_compatible_extents( std::integral_constant, std::integer_sequence, std::integer_sequence) noexcept { @@ -62,10 +62,10 @@ __check_compatible_extents( template MDSPAN_INLINE_FUNCTION -static constexpr bool are_valid_indices() { +constexpr bool are_valid_indices() { return - _MDSPAN_FOLD_AND(std::is_convertible::value) && - _MDSPAN_FOLD_AND(std::is_nothrow_constructible::value); + MDSPAN_IMPL_FOLD_AND(std::is_convertible::value) && + MDSPAN_IMPL_FOLD_AND(std::is_nothrow_constructible::value); } // ------------------------------------------------------------------ @@ -154,7 +154,7 @@ struct index_sequence_scan_impl { template struct index_sequence_scan_impl { #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; 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 + MDSPAN_IMPL_NO_UNIQUE_ADDRESS possibly_empty_array 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(static_val)); } @@ -309,7 +309,7 @@ public: constexpr maybe_static_array(const std::array &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(vals[r]); } // Precondition check -#ifdef _MDSPAN_DEBUG +#ifdef MDSPAN_DEBUG else { assert(static_cast(vals[r]) == static_cast(static_val)); @@ -334,7 +334,7 @@ public: MDSPAN_INLINE_FUNCTION constexpr maybe_static_array(const std::span &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(vals[r]); } -#ifdef _MDSPAN_DEBUG +#ifdef MDSPAN_DEBUG else { assert(static_cast(vals[r]) == static_cast(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(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(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; - _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, + vals_t impl_construct_vals_from_extents(std::integral_constant, std::integral_constant, const OtherExtents &exts, DynamicValues... dynamic_values) noexcept { - return __construct_vals_from_extents( + return impl_construct_vals_from_extents( std::integral_constant(), std::integral_constant(), 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, + vals_t impl_construct_vals_from_extents(std::integral_constant, std::integral_constant, const OtherExtents &exts, DynamicValues... dynamic_values) noexcept { - return __construct_vals_from_extents( + return impl_construct_vals_from_extents( std::integral_constant(), std::integral_constant(), 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, + vals_t impl_construct_vals_from_extents(std::integral_constant, std::integral_constant, 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::rank() == extents::rank()>{}, @@ -534,7 +537,7 @@ public: (std::numeric_limits::max() < std::numeric_limits::max())) constexpr extents(const extents &other) noexcept - : m_vals(__construct_vals_from_extents( + : m_vals(impl_construct_vals_from_extents( std::integral_constant(), std::integral_constant(), other)) {} @@ -563,13 +566,13 @@ namespace detail { template > -struct __make_dextents; +struct impl_make_dextents; template -struct __make_dextents< +struct impl_make_dextents< IndexType, Rank, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents> { - using type = typename __make_dextents< + using type = typename impl_make_dextents< IndexType, Rank - 1, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents -struct __make_dextents< +struct impl_make_dextents< IndexType, 0, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents> { using type = ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents; @@ -587,10 +590,10 @@ struct __make_dextents< // [mdspan.extents.dextents], alias template template -using dextents = typename detail::__make_dextents::type; +using dextents = typename detail::impl_make_dextents::type; // Deduction guide for extents -#if defined(_MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION) +#if defined(MDSPAN_IMPL_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION) template extents(IndexTypes...) -> extents struct __is_extents : ::std::false_type {}; +template struct impl_is_extents : ::std::false_type {}; template -struct __is_extents<::MDSPAN_IMPL_STANDARD_NAMESPACE::extents> +struct impl_is_extents<::MDSPAN_IMPL_STANDARD_NAMESPACE::extents> : ::std::true_type {}; template @@ -612,7 +615,7 @@ inline #else static #endif -constexpr bool __is_extents_v = __is_extents::value; +constexpr bool impl_is_extents_v = impl_is_extents::value; template 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(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(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 MDSPAN_INLINE_FUNCTION constexpr bool @@ -673,7 +676,7 @@ check_all_indices_helper(std::index_sequence, 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, + static_assert(detail::impl_is_extents_v, MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_left::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents."); template @@ -47,25 +47,25 @@ class layout_left::mapping { // i0+(i1 + E(1)*(i2 + E(2)*i3)) template - struct __rank_count {}; + struct rank_count {}; template - _MDSPAN_HOST_DEVICE - constexpr index_type __compute_offset( - __rank_count, const I& i, Indices... idx) const { - return __compute_offset(__rank_count(), idx...) * - __extents.extent(r) + i; + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset( + rank_count, const I& i, Indices... idx) const { + return compute_offset(rank_count(), idx...) * + m_extents.extent(r) + i; } template - _MDSPAN_HOST_DEVICE - constexpr index_type __compute_offset( - __rank_count, const I& i) const { + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset( + rank_count, 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::value)) // needs two () due to comma - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(mapping 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::value)) // needs two () due to comma - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(layout_right::mapping 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 + MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_left_padded_mapping::value + && std::is_constructible_v ) ) - MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v)) - mapping(const _Mapping& __other) noexcept - : __extents(__other.extents()) + MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v)) + 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, Mapping>(detail::with_rank{}); MDSPAN_IMPL_PROPOSED_NAMESPACE::detail:: check_padded_layout_converting_constructor_preconditions< - extents_type>(detail::with_rank{}, __other); + extents_type>(detail::with_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 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{}, layout_left{}, __extents, other); + detail::validate_strides(detail::with_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()) ) ) - _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(idxs)...); + return compute_offset(rank_count<0, extents_type::rank()>(), static_cast(idxs)...); } @@ -210,7 +211,7 @@ class layout_left::mapping { #endif { index_type value = 1; - for(rank_type r=0; r MDSPAN_INLINE_FUNCTION - constexpr index_type __get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { - return _MDSPAN_FOLD_TIMES_RIGHT((Idx():1),1); + constexpr index_type impl_get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { + return MDSPAN_IMPL_FOLD_TIMES_RIGHT((Idx():1),1); } template MDSPAN_INLINE_FUNCTION - constexpr index_type __stride() const noexcept { - return __get_stride(__extents, std::make_index_sequence()); + constexpr index_type impl_stide() const noexcept { + return impl_get_stride(m_extents, std::make_index_sequence()); } private: - _MDSPAN_NO_UNIQUE_ADDRESS extents_type __extents{}; + MDSPAN_IMPL_NO_UNIQUE_ADDRESS extents_type m_extents{}; // [mdspan.submdspan.mapping], submdspan mapping specialization template @@ -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, + static_assert(detail::impl_is_extents_v, MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_right::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents."); template @@ -45,29 +45,29 @@ class layout_right::mapping { // i0+(i1 + E(1)*(i2 + E(2)*i3)) template - struct __rank_count {}; + struct rank_count {}; template - _MDSPAN_HOST_DEVICE - constexpr index_type __compute_offset( - index_type offset, __rank_count, const I& i, Indices... idx) const { - return __compute_offset(offset * __extents.extent(r) + i,__rank_count(), idx...); + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset( + index_type offset, rank_count, const I& i, Indices... idx) const { + return compute_offset(offset * m_extents.extent(r) + i,rank_count(), idx...); } template - _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) const { + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset(size_t offset, rank_count) const { return static_cast(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::value)) // needs two () due to comma - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(mapping 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::value)) // needs two () due to comma - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(layout_left::mapping 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)) - MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v)) - mapping(const _Mapping &__other) noexcept - : __extents(__other.extents()) + MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_right_padded_mapping::value + && std::is_constructible_v)) + MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v)) + 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, Mapping>(detail::with_rank{}); MDSPAN_IMPL_PROPOSED_NAMESPACE::detail:: check_padded_layout_converting_constructor_preconditions< - extents_type>(detail::with_rank{}, __other); + extents_type>(detail::with_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 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{}, layout_right{}, __extents, other); + detail::validate_strides(detail::with_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()) ) ) - _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(idxs)...); + return compute_offset(rank_count<0, extents_type::rank()>(), static_cast(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 MDSPAN_INLINE_FUNCTION - constexpr index_type __get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { - return _MDSPAN_FOLD_TIMES_RIGHT((Idx>N? __extents.template __extent():1),1); + constexpr index_type impl_get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { + return MDSPAN_IMPL_FOLD_TIMES_RIGHT((Idx>N? m_extents.template extent():1),1); } template MDSPAN_INLINE_FUNCTION - constexpr index_type __stride() const noexcept { - return __get_stride(__extents, std::make_index_sequence()); + constexpr index_type impl_stide() const noexcept { + return impl_get_stride(m_extents, std::make_index_sequence()); } private: - _MDSPAN_NO_UNIQUE_ADDRESS extents_type __extents{}; + MDSPAN_IMPL_NO_UNIQUE_ADDRESS extents_type m_extents{}; // [mdspan.submdspan.mapping], submdspan mapping specialization template @@ -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 #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 #endif @@ -48,33 +48,51 @@ struct layout_right { }; namespace detail { +#if MDSPAN_HAS_CXX_17 + using std::void_t; +#else + template 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 + 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 + struct is_mapping_of_impl, void_t< typename Layout::template mapping >> + : std::is_same, Mapping> + {}; + template - constexpr bool __is_mapping_of = - std::is_same, Mapping>::value; + constexpr bool is_mapping_of = + is_mapping_of_impl::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 - concept __same_as = std::is_same_v<_Tp, _Up>; + template + concept same_as = std::is_same_v; } // namespace detail template - concept __same_as = detail::__same_as && detail::__same_as; + concept same_as = detail::same_as && detail::same_as; } // namespace internal # endif template - concept __layout_mapping_alike = requires { - requires __is_extents::value; + concept layout_mapping_alike = requires { + requires impl_is_extents::value; #if defined(__cpp_lib_concepts) { M::is_always_strided() } -> std::same_as; { M::is_always_exhaustive() } -> std::same_as; { M::is_always_unique() } -> std::same_as; #else - { M::is_always_strided() } -> internal::__same_as; - { M::is_always_exhaustive() } -> internal::__same_as; - { M::is_always_unique() } -> internal::__same_as; + { M::is_always_strided() } -> internal::same_as; + { M::is_always_exhaustive() } -> internal::same_as; + { M::is_always_unique() } -> internal::same_as; #endif std::bool_constant::value; std::bool_constant::value; @@ -87,9 +105,9 @@ namespace detail { struct layout_stride { template 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 > @@ -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, + static_assert(detail::impl_is_extents_v, 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; - using __member_pair_t = detail::__compressed_pair; + using strides_storage_t = detail::possibly_empty_array; + using member_pair_t = detail::impl_compressed_pair; -#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; #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 - _MDSPAN_HOST_DEVICE - constexpr index_type __get_size(::MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { - return _MDSPAN_FOLD_TIMES_RIGHT( static_cast(extents().extent(Idx)), 1 ); + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type get_size(::MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { + return MDSPAN_IMPL_FOLD_TIMES_RIGHT( static_cast(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 - struct __deduction_workaround; + struct deduction_workaround; template - struct __deduction_workaround> + struct deduction_workaround> { template MDSPAN_INLINE_FUNCTION static constexpr bool _eq_impl(mapping const& self, mapping const& other) noexcept { using common_t = std::common_type_t; - return _MDSPAN_FOLD_AND((static_cast(self.stride(Idxs)) == static_cast(other.stride(Idxs))) /* && ... */) - && _MDSPAN_FOLD_AND((static_cast(self.extents().extent(Idxs)) == static_cast(other.extents().extent(Idxs))) /* || ... */); + return MDSPAN_IMPL_FOLD_AND((static_cast(self.stride(Idxs)) == static_cast(other.stride(Idxs))) /* && ... */) + && MDSPAN_IMPL_FOLD_AND((static_cast(self.extents().extent(Idxs)) == static_cast(other.extents().extent(Idxs))) /* || ... */); } template MDSPAN_INLINE_FUNCTION static constexpr bool _not_eq_impl(mapping const& self, mapping const& other) noexcept { using common_t = std::common_type_t; - return _MDSPAN_FOLD_OR((static_cast(self.stride(Idxs)) != static_cast(other.stride(Idxs))) /* || ... */) - || _MDSPAN_FOLD_OR((static_cast(self.extents().extent(Idxs)) != static_cast(other.extents().extent(Idxs))) /* || ... */); + return MDSPAN_IMPL_FOLD_OR((static_cast(self.stride(Idxs)) != static_cast(other.stride(Idxs))) /* || ... */) + || MDSPAN_IMPL_FOLD_OR((static_cast(self.extents().extent(Idxs)) != static_cast(other.extents().extent(Idxs))) /* || ... */); } template 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() - 1)...) + 1; + return deduction_workaround_impl::_call_op_impl(self, (self.extents().template extent() - 1)...) + 1; } template MDSPAN_INLINE_FUNCTION - static constexpr const __strides_storage_t fill_strides(const OtherMapping& map) { - return __strides_storage_t{static_cast(map.stride(Idxs))...}; + static constexpr const strides_storage_t fill_strides(const OtherMapping& map) { + return strides_storage_t{static_cast(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 - static constexpr const __strides_storage_t fill_strides(const std::array& s) { - return __strides_storage_t{static_cast(s[Idxs])...}; + static constexpr const strides_storage_t fill_strides(const std::array& s) { + return strides_storage_t{static_cast(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(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(s[Idxs])...}; } #ifdef __cpp_lib_span template - static constexpr const __strides_storage_t fill_strides(const std::span& s) { - return __strides_storage_t{static_cast(s[Idxs])...}; + static constexpr const strides_storage_t fill_strides(const std::span& s) { + return strides_storage_t{static_cast(s[Idxs])...}; } #endif MDSPAN_INLINE_FUNCTION - static constexpr std::array return_strides(const __strides_storage_t& s) { + static constexpr std::array return_strides(const strides_storage_t& s) { return std::array{s[Idxs]...}; } template MDSPAN_INLINE_FUNCTION - static constexpr size_t __return_zero() { return 0; } + static constexpr size_t return_zero() { return 0; } template MDSPAN_INLINE_FUNCTION static constexpr typename Mapping::index_type - __OFFSET(const Mapping& m) { return m(__return_zero()...); } + offset(const Mapping& m) { return m(return_zero()...); } }; - // Can't use defaulted parameter in the __deduction_workaround template because of a bug in MSVC warning C4348. - using __impl = __deduction_workaround>; + // Can't use defaulted parameter in the deduction_workaround template because of a bug in MSVC warning C4348. + using deduction_workaround_impl = deduction_workaround>; 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 MDSPAN_FUNCTION - static constexpr __strides_storage_t strides_storage(detail::with_rank) { - __strides_storage_t s{}; + static constexpr strides_storage_t strides_storage(detail::with_rank) { + 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{})) -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + strides_storage_t(strides_storage(detail::with_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&, typename Extents::index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) + MDSPAN_IMPL_TRAIT(std::is_convertible, const std::remove_const_t&, typename Extents::index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) ) ) constexpr @@ -301,13 +319,13 @@ struct layout_stride { extents_type const& e, std::array 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&, typename Extents::index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) + MDSPAN_IMPL_TRAIT(std::is_convertible, const std::remove_const_t&, typename Extents::index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) ) ) 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&, typename Extents::index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) + MDSPAN_IMPL_TRAIT(std::is_convertible, const std::remove_const_t&, typename Extents::index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) ) ) constexpr @@ -377,13 +395,13 @@ struct layout_stride { extents_type const& e, std::span 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 && + MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) && + detail::is_mapping_of && StridedLayoutMapping::is_always_unique() && StridedLayoutMapping::is_always_strided() ) @@ -413,27 +431,27 @@ struct layout_stride { #else template requires( - detail::__layout_mapping_alike && - _MDSPAN_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) && + detail::layout_mapping_alike && + 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::value && - (detail::__is_mapping_of || - detail::__is_mapping_of || - detail::__is_mapping_of)) + (detail::is_mapping_of || + detail::is_mapping_of || + detail::is_mapping_of)) ) // 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(extents_type::rank()); r++) { // Return early if any of the extents are zero if(extents().extent(r)==0) return 0; - span_size += ( static_cast(extents().extent(r) - 1 ) * __strides_storage()[r]); + span_size += ( static_cast(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(__impl::_call_op_impl(*this, static_cast(idxs)...)); + return static_cast(deduction_workaround_impl::_call_op_impl(*this, static_cast(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()); + return required_span_size() == get_size(extents(), std::make_index_sequence()); } 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{}); } 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 && + detail::is_mapping_of && (extents_type::rank() == StridedLayoutMapping::extents_type::rank()) && StridedLayoutMapping::is_always_strided() ) @@ -567,7 +585,7 @@ struct layout_stride { #else template requires( - detail::__layout_mapping_alike && + detail::layout_mapping_alike && (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(0)) && + (deduction_workaround_impl::offset(y) == static_cast(0)) && detail::rankwise_equal(detail::with_rank{}, x, y, detail::stride); } @@ -588,14 +606,14 @@ struct layout_stride { ) MDSPAN_INLINE_FUNCTION friend constexpr bool operator==(mapping const& lhs, mapping 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 && + detail::is_mapping_of && (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 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 #include #include // std::is_void -#if defined(_MDSPAN_HAS_CUDA) || defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_SYCL) +#if defined(MDSPAN_IMPL_HAS_SYCL) +#include // 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 @@ // {{{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::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, //============================================================================== // {{{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 // end inline variables }}}1 @@ -310,17 +319,17 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file, //============================================================================== // {{{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> \ { 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, //============================================================================== // {{{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 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 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 MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_left_assign_impl(Arg1&& arg1) { +constexpr auto fold_left_assign_impl(Arg1&& arg1) { return (Arg1&&)arg1; } template 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 MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_right_assign_impl(Arg1&& arg1) { +constexpr auto fold_right_assign_impl(Arg1&& arg1) { return (Arg1&&)arg1; } template 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 MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_right_plus_impl(Arg1&& arg1) { +constexpr auto fold_right_plus_impl(Arg1&& arg1) { return (Arg1&&)arg1; } template 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 MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_right_times_impl(Arg1&& arg1) { +constexpr auto fold_right_times_impl(Arg1&& arg1) { return (Arg1&&)arg1; } template 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) // {{{2 template -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 -struct __fold_right_and_impl_ { - using __next_t = __fold_right_and_impl_; - using __rv = decltype(std::declval() && std::declval()); +struct fold_right_and_impl_ { + using next_t = fold_right_and_impl_; + using rv = decltype(std::declval() && std::declval()); 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 MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_right_and_impl_::__rv -__fold_right_and_impl(Args&&... args) { - return __fold_right_and_impl_::__impl((Args&&)args...); +constexpr typename fold_right_and_impl_::rv +fold_right_and_impl(Args&&... args) { + return fold_right_and_impl_::impl((Args&&)args...); } // end right and }}}2 @@ -466,32 +475,32 @@ __fold_right_and_impl(Args&&... args) { // {{{2 template -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 -struct __fold_right_or_impl_ { - using __next_t = __fold_right_or_impl_; - using __rv = decltype(std::declval() || std::declval()); +struct fold_right_or_impl_ { + using next_t = fold_right_or_impl_; + using rv = decltype(std::declval() || std::declval()); 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 MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_right_or_impl_::__rv -__fold_right_or_impl(Args&&... args) { - return __fold_right_or_impl_::__impl((Args&&)args...); +constexpr typename fold_right_or_impl_::rv +fold_right_or_impl(Args&&... args) { + return fold_right_or_impl_::impl((Args&&)args...); } // end right or }}}2 @@ -501,32 +510,32 @@ __fold_right_or_impl(Args&&... args) { // {{{2 template -struct __fold_right_plus_impl_; +struct fold_right_plus_impl_; template -struct __fold_right_plus_impl_ { - using __rv = Arg&&; +struct fold_right_plus_impl_ { + 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 -struct __fold_right_plus_impl_ { - using __next_t = __fold_right_plus_impl_; - using __rv = decltype(std::declval() + std::declval()); +struct fold_right_plus_impl_ { + using next_t = fold_right_plus_impl_; + using rv = decltype(std::declval() + std::declval()); 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 MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_right_plus_impl_::__rv -__fold_right_plus_impl(Args&&... args) { - return __fold_right_plus_impl_::__impl((Args&&)args...); +constexpr typename fold_right_plus_impl_::rv +fold_right_plus_impl(Args&&... args) { + return fold_right_plus_impl_::impl((Args&&)args...); } // end right plus }}}2 @@ -536,32 +545,32 @@ __fold_right_plus_impl(Args&&... args) { // {{{2 template -struct __fold_right_times_impl_; +struct fold_right_times_impl_; template -struct __fold_right_times_impl_ { - using __rv = Arg&&; +struct fold_right_times_impl_ { + 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 -struct __fold_right_times_impl_ { - using __next_t = __fold_right_times_impl_; - using __rv = decltype(std::declval() * std::declval()); +struct fold_right_times_impl_ { + using next_t = fold_right_times_impl_; + using rv = decltype(std::declval() * std::declval()); 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 MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_right_times_impl_::__rv -__fold_right_times_impl(Args&&... args) { - return __fold_right_times_impl_::__impl((Args&&)args...); +constexpr typename fold_right_times_impl_::rv +fold_right_times_impl(Args&&... args) { + return fold_right_times_impl_::impl((Args&&)args...); } // end right times }}}2 @@ -571,32 +580,32 @@ __fold_right_times_impl(Args&&... args) { // {{{2 template -struct __fold_right_assign_impl_; +struct fold_right_assign_impl_; template -struct __fold_right_assign_impl_ { - using __rv = Arg&&; +struct fold_right_assign_impl_ { + 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 -struct __fold_right_assign_impl_ { - using __next_t = __fold_right_assign_impl_; - using __rv = decltype(std::declval() = std::declval()); +struct fold_right_assign_impl_ { + using next_t = fold_right_assign_impl_; + using rv = decltype(std::declval() = std::declval()); 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 MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_right_assign_impl_::__rv -__fold_right_assign_impl(Args&&... args) { - return __fold_right_assign_impl_::__impl((Args&&)args...); +constexpr typename fold_right_assign_impl_::rv +fold_right_assign_impl(Args&&... args) { + return fold_right_assign_impl_::impl((Args&&)args...); } // end right assign }}}2 @@ -606,33 +615,33 @@ __fold_right_assign_impl(Args&&... args) { // {{{2 template -struct __fold_left_assign_impl_; +struct fold_left_assign_impl_; template -struct __fold_left_assign_impl_ { - using __rv = Arg&&; +struct fold_left_assign_impl_ { + 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 -struct __fold_left_assign_impl_ { - using __assign_result_t = decltype(std::declval() = std::declval()); - using __next_t = __fold_left_assign_impl_<__assign_result_t, Args...>; - using __rv = typename __next_t::__rv; +struct fold_left_assign_impl_ { + using assign_result_t = decltype(std::declval() = std::declval()); + using next_t = fold_left_assign_impl_; + 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 MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_left_assign_impl_::__rv -__fold_left_assign_impl(Args&&... args) { - return __fold_left_assign_impl_::__impl((Args&&)args...); +constexpr typename fold_left_assign_impl_::rv +fold_left_assign_impl(Args&&... args) { + return fold_left_assign_impl_::impl((Args&&)args...); } // end left assign }}}2 @@ -642,25 +651,25 @@ __fold_left_assign_impl(Args&&... args) { template -constexpr __mdspan_enable_fold_comma __fold_comma_impl(Args&&...) noexcept { return { }; } +constexpr enable_fold_comma fold_comma_impl(Args&&...) noexcept { return { }; } template -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) +# 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) #endif @@ -670,10 +679,10 @@ struct __bools; //============================================================================== // {{{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 // end Variable template compatibility }}}1 @@ -682,18 +691,24 @@ struct __bools; //============================================================================== // {{{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 // 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 +#include +#include + namespace MDSPAN_IMPL_STANDARD_NAMESPACE { template < class ElementType, @@ -32,36 +37,36 @@ template < class mdspan { private: - static_assert(detail::__is_extents_v, + static_assert(detail::impl_is_extents_v, 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::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 - struct __deduction_workaround; + struct deduction_workaround; template - struct __deduction_workaround> + struct deduction_workaround> { 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 MDSPAN_FORCE_INLINE_FUNCTION static constexpr - ReferenceType __callop(mdspan const& __self, const std::array& indices) noexcept { - return __self.__accessor_ref().access(__self.__ptr_ref(), __self.__mapping_ref()(indices[Idxs]...)); + ReferenceType callop(mdspan const& self, const std::array& indices) noexcept { + return self.accessor_ref().access(self.ptr_ref(), self.mapping_ref()(indices[Idxs]...)); } #ifdef __cpp_lib_span template MDSPAN_FORCE_INLINE_FUNCTION static constexpr - ReferenceType __callop(mdspan const& __self, const std::span& indices) noexcept { - return __self.__accessor_ref().access(__self.__ptr_ref(), __self.__mapping_ref()(indices[Idxs]...)); + ReferenceType callop(mdspan const& self, const std::span& 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>; + // Can't use defaulted parameter in the deduction_workaround template because of a bug in MSVC warning C4348. + using deduction_workaround_impl = deduction_workaround>; - using __map_acc_pair_t = detail::__compressed_pair; + using map_acc_pair_t = detail::impl_compressed_pair; 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()) && - _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(std::move(dynamic_extents))...)), accessor_type())) + : m_members(std::move(p), map_acc_pair_t(mapping_type(extents_type(static_cast(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& 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 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&) && - _MDSPAN_TRAIT(std::is_constructible, accessor_type, const OtherAccessor&) + MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, const typename OtherLayoutPolicy::template mapping&) && + MDSPAN_IMPL_TRAIT(std::is_constructible, accessor_type, const OtherAccessor&) ) ) MDSPAN_CONDITIONAL_EXPLICIT( - !_MDSPAN_TRAIT(std::is_convertible, const typename OtherLayoutPolicy::template mapping&, mapping_type) || - !_MDSPAN_TRAIT(std::is_convertible, const OtherAccessor&, accessor_type) + !MDSPAN_IMPL_TRAIT(std::is_convertible, const typename OtherLayoutPolicy::template mapping&, mapping_type) || + !MDSPAN_IMPL_TRAIT(std::is_convertible, const OtherAccessor&, accessor_type) ) MDSPAN_INLINE_FUNCTION constexpr mdspan(const mdspan& 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()) + ) + ) + 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(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& 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(*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 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(*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()) ) ) MDSPAN_FORCE_INLINE_FUNCTION constexpr reference operator[](SizeTypes... indices) const { - return __accessor_ref().access(__ptr_ref(), __mapping_ref()(static_cast(std::move(indices))...)); + return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast(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& indices) const { - return __impl::template __callop(*this, indices); + return deduction_workaround_impl::template callop(*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 indices) const { - return __impl::template __callop(*this, indices); + return deduction_workaround_impl::template callop(*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(std::move(idx)))); + return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast(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(std::move(indices))...)); + return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast(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& indices) const { - return __impl::template __callop(*this, indices); + return deduction_workaround_impl::template callop(*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 indices) const { - return __impl::template __callop(*this, indices); + return deduction_workaround_impl::template callop(*this, indices); } #endif // __cpp_lib_span #endif // MDSPAN_USE_PAREN_OPERATOR MDSPAN_INLINE_FUNCTION constexpr size_type size() const noexcept { - return static_cast(__impl::__size(*this)); - }; + return static_cast(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 __members{}; + detail::impl_compressed_pair 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) >= extent; + } template 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)) + (MDSPAN_IMPL_TRAIT(std::is_pointer, std::remove_reference_t)) ) MDSPAN_DEDUCTION_GUIDE mdspan(Pointer&&) -> mdspan>, extents>; MDSPAN_TEMPLATE_REQUIRES( class CArray, - (_MDSPAN_TRAIT(std::is_array, CArray) && (std::rank_v == 1)) + (MDSPAN_IMPL_TRAIT(std::is_array, CArray) && (std::rank_v == 1)) ) MDSPAN_DEDUCTION_GUIDE mdspan(CArray&) -> mdspan, extents>>; 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 -struct __no_unique_address_emulation { - using __stored_type = _T; - _T __v; - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T const &__ref() const noexcept { - return __v; +template +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 -struct __no_unique_address_emulation< - _T, _Disambiguator, - std::enable_if_t<_MDSPAN_TRAIT(std::is_empty, _T) && +template +struct no_unique_address_emulation< + T, Disambiguator, + std::enable_if_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(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(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 @@ //============================================================================== // {{{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 _MDSPAN_INLINE_VARIABLE constexpr auto TRAIT##_v = TRAIT::value; +#define MDSPAN_IMPL_BACKPORT_TRAIT(TRAIT) \ + template MDSPAN_IMPL_INLINE_VARIABLE constexpr auto TRAIT##_v = TRAIT::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 // end Variable template trait backports (e.g., is_void_v) }}}1 //============================================================================== @@ -56,7 +56,7 @@ _MDSPAN_BACKPORT_TRAIT(is_void) //============================================================================== // {{{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; //============================================================================== // {{{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 using TRAIT##_t = typename TRAIT::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 -using enable_if_t = typename enable_if<_B, _T>::type; +template +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 struct __type_list { static constexpr auto __size = sizeof...(_Ts); }; +template struct type_list { static constexpr auto size = sizeof...(Ts); }; // Implementation of type_list at() that's heavily optimized for small typelists -template struct __type_at; -template > struct __type_at_large_impl; +template struct type_at; +template > struct type_at_large_impl; -template -struct __type_at_entry { }; +template +struct type_at_entry { }; -template -struct __type_at_assign_op_ignore_rest { - template - __type_at_assign_op_ignore_rest<_Result> operator=(_T&&); - using type = _Result; +template +struct type_at_assign_op_ignore_rest { + template + type_at_assign_op_ignore_rest operator=(T&&); + using type = Result; }; -struct __type_at_assign_op_impl { - template - __type_at_assign_op_impl operator=(__type_at_entry<_I, _Idx, _T>&&); - template - __type_at_assign_op_ignore_rest<_T> operator=(__type_at_entry<_I, _I, _T>&&); +struct type_at_assign_op_impl { + template + type_at_assign_op_impl operator=(type_at_entry&&); + template + type_at_assign_op_ignore_rest operator=(type_at_entry&&); }; -template -struct __type_at_large_impl<_I, __type_list<_Ts...>, std::integer_sequence> +template +struct type_at_large_impl, std::integer_sequence> : 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{}) ) { }; -template -struct __type_at<_I, __type_list<_Ts...>> - : __type_at_large_impl<_I, __type_list<_Ts...>> +template +struct type_at> + : type_at_large_impl> { }; -template -struct __type_at<0, __type_list<_T0, _Ts...>> { - using type = _T0; +template +struct type_at<0, type_list> { + using type = T0; }; -template -struct __type_at<1, __type_list<_T0, _T1, _Ts...>> { - using type = _T1; +template +struct type_at<1, type_list> { + using type = T1; }; -template -struct __type_at<2, __type_list<_T0, _T1, _T2, _Ts...>> { - using type = _T2; +template +struct type_at<2, type_list> { + using type = T2; }; -template -struct __type_at<3, __type_list<_T0, _T1, _T2, _T3, _Ts...>> { - using type = _T3; +template +struct type_at<3, type_list> { + 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 #include #include +#if defined(MDSPAN_IMPL_HAS_CUDA) && defined(__NVCC__) && (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 >= 1260) +#include +#else +#include +#endif +#include "macros.hpp" namespace MDSPAN_IMPL_STANDARD_NAMESPACE { namespace detail { @@ -46,7 +52,10 @@ constexpr bool rankwise_equal(with_rank, const T1& x, const T2& y, F func) return match; } -constexpr struct +#if MDSPAN_HAS_CXX_17 +inline +#endif +constexpr struct extent_functor { template MDSPAN_INLINE_FUNCTION @@ -56,7 +65,10 @@ constexpr struct } } extent; -constexpr struct +#if MDSPAN_HAS_CXX_17 +inline +#endif +constexpr struct stride_functor { template 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) {}; + constexpr integral_constant(std::integral_constant) {} MDSPAN_FUNCTION constexpr operator std::integral_constant() const noexcept { return std::integral_constant{}; @@ -164,8 +176,70 @@ constexpr const auto& get(const tuple& vals) { return vals.template get template tuple(Elements ...) -> tuple; #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 +MDSPAN_INLINE_FUNCTION constexpr bool cmp_less(T t, U u) noexcept { + if constexpr (std::is_signed_v == std::is_signed_v) + return t < u; + else if constexpr (std::is_signed_v) + return t < 0 || std::make_unsigned_t(t) < u; + else + return u >= 0 && t < std::make_unsigned_t(u); +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool cmp_less_equal(T t, U u) noexcept { + return !cmp_less(u, t); +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool cmp_greater_equal(T t, U u) noexcept { + return !cmp_less(t, u); +} + +template +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::min()) && + cmp_less_equal(t, numeric_limits::max()); +} + +template +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) { + 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::max() / b; +#endif +} +#endif } // namespace detail +#if MDSPAN_HAS_CXX_17 +inline +#endif constexpr struct mdspan_non_standard_tag { } mdspan_non_standard; -- cgit v1.2.3