11 #ifndef NONSTD_SPAN_HPP_INCLUDED 12 #define NONSTD_SPAN_HPP_INCLUDED 14 #define span_lite_MAJOR 0 15 #define span_lite_MINOR 5 16 #define span_lite_PATCH 0 18 #define span_lite_VERSION span_STRINGIFY(span_lite_MAJOR) "." span_STRINGIFY(span_lite_MINOR) "." span_STRINGIFY(span_lite_PATCH) 20 #define span_STRINGIFY( x ) span_STRINGIFY_( x ) 21 #define span_STRINGIFY_( x ) #x 25 #define span_SPAN_DEFAULT 0 26 #define span_SPAN_NONSTD 1 27 #define span_SPAN_STD 2 29 #ifndef span_CONFIG_SELECT_SPAN 30 # define span_CONFIG_SELECT_SPAN ( span_HAVE_STD_SPAN ? span_SPAN_STD : span_SPAN_NONSTD ) 33 #ifndef span_CONFIG_INDEX_TYPE 34 # define span_CONFIG_INDEX_TYPE std::ptrdiff_t 39 #ifndef span_FEATURE_WITH_CONTAINER 40 #ifdef span_FEATURE_WITH_CONTAINER_TO_STD 41 # define span_FEATURE_WITH_CONTAINER span_IN_STD( span_FEATURE_WITH_CONTAINER_TO_STD ) 43 # define span_FEATURE_WITH_CONTAINER 0 47 #ifndef span_FEATURE_CONSTRUCTION_FROM_STDARRAY_ELEMENT_TYPE 48 # define span_FEATURE_CONSTRUCTION_FROM_STDARRAY_ELEMENT_TYPE 0 51 #ifndef span_FEATURE_MEMBER_AT 52 # define span_FEATURE_MEMBER_AT 0 55 #ifndef span_FEATURE_MEMBER_BACK_FRONT 56 # define span_FEATURE_MEMBER_BACK_FRONT 1 59 #ifndef span_FEATURE_MEMBER_CALL_OPERATOR 60 # define span_FEATURE_MEMBER_CALL_OPERATOR 0 63 #ifndef span_FEATURE_MEMBER_SWAP 64 # define span_FEATURE_MEMBER_SWAP 0 67 #ifndef span_FEATURE_NON_MEMBER_FIRST_LAST_SUB 68 # define span_FEATURE_NON_MEMBER_FIRST_LAST_SUB 0 71 #ifndef span_FEATURE_COMPARISON 72 # define span_FEATURE_COMPARISON 1 // Note: C++20 does not provide comparison 75 #ifndef span_FEATURE_SAME 76 # define span_FEATURE_SAME 0 79 #ifndef span_FEATURE_MAKE_SPAN 80 #ifdef span_FEATURE_MAKE_SPAN_TO_STD 81 # define span_FEATURE_MAKE_SPAN span_IN_STD( span_FEATURE_MAKE_SPAN_TO_STD ) 83 # define span_FEATURE_MAKE_SPAN 0 87 #ifndef span_FEATURE_BYTE_SPAN 88 # define span_FEATURE_BYTE_SPAN 0 93 #ifndef span_CONFIG_NO_EXCEPTIONS 94 # if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND) 95 # define span_CONFIG_NO_EXCEPTIONS 0 97 # define span_CONFIG_NO_EXCEPTIONS 1 98 # undef span_CONFIG_CONTRACT_VIOLATION_THROWS 99 # undef span_CONFIG_CONTRACT_VIOLATION_TERMINATES 100 # define span_CONFIG_CONTRACT_VIOLATION_THROWS 0 101 # define span_CONFIG_CONTRACT_VIOLATION_TERMINATES 1 107 #if defined( span_CONFIG_CONTRACT_LEVEL_ON ) 108 # define span_CONFIG_CONTRACT_LEVEL_MASK 0x11 109 #elif defined( span_CONFIG_CONTRACT_LEVEL_OFF ) 110 # define span_CONFIG_CONTRACT_LEVEL_MASK 0x00 111 #elif defined( span_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY ) 112 # define span_CONFIG_CONTRACT_LEVEL_MASK 0x01 113 #elif defined( span_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY ) 114 # define span_CONFIG_CONTRACT_LEVEL_MASK 0x10 116 # define span_CONFIG_CONTRACT_LEVEL_MASK 0x11 119 #if defined( span_CONFIG_CONTRACT_VIOLATION_THROWS ) 120 # define span_CONFIG_CONTRACT_VIOLATION_THROWS_V span_CONFIG_CONTRACT_VIOLATION_THROWS 122 # define span_CONFIG_CONTRACT_VIOLATION_THROWS_V 0 125 #if defined( span_CONFIG_CONTRACT_VIOLATION_THROWS ) && span_CONFIG_CONTRACT_VIOLATION_THROWS && \ 126 defined( span_CONFIG_CONTRACT_VIOLATION_TERMINATES ) && span_CONFIG_CONTRACT_VIOLATION_TERMINATES 127 # error Please define none or one of span_CONFIG_CONTRACT_VIOLATION_THROWS and span_CONFIG_CONTRACT_VIOLATION_TERMINATES to 1, but not both. 133 #ifndef span_CPLUSPLUS 134 # if defined(_MSVC_LANG ) && !defined(__clang__) 135 # define span_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG ) 137 # define span_CPLUSPLUS __cplusplus 141 #define span_CPP98_OR_GREATER ( span_CPLUSPLUS >= 199711L ) 142 #define span_CPP11_OR_GREATER ( span_CPLUSPLUS >= 201103L ) 143 #define span_CPP14_OR_GREATER ( span_CPLUSPLUS >= 201402L ) 144 #define span_CPP17_OR_GREATER ( span_CPLUSPLUS >= 201703L ) 145 #define span_CPP20_OR_GREATER ( span_CPLUSPLUS >= 202000L ) 149 #define span_CPLUSPLUS_V ( span_CPLUSPLUS / 100 - (span_CPLUSPLUS > 200000 ? 2000 : 1994) ) 151 #define span_IN_STD( v ) ( ((v) == 98 ? 3 : (v)) >= span_CPLUSPLUS_V ) 153 #define span_CONFIG( feature ) ( span_CONFIG_##feature ) 154 #define span_FEATURE( feature ) ( span_FEATURE_##feature ) 155 #define span_FEATURE_TO_STD( feature ) ( span_IN_STD( span_FEATURE( feature##_TO_STD ) ) ) 159 #if span_CPP20_OR_GREATER && defined(__has_include ) 160 # if __has_include( <span> ) 161 # define span_HAVE_STD_SPAN 1 163 # define span_HAVE_STD_SPAN 0 166 # define span_HAVE_STD_SPAN 0 169 #define span_USES_STD_SPAN ( (span_CONFIG_SELECT_SPAN == span_SPAN_STD) || ((span_CONFIG_SELECT_SPAN == span_SPAN_DEFAULT) && span_HAVE_STD_SPAN) ) 175 #if span_USES_STD_SPAN 192 #else // span_USES_STD_SPAN 209 #if defined(_MSC_VER ) && !defined(__clang__) 210 # define span_COMPILER_MSVC_VER (_MSC_VER ) 211 # define span_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) ) 213 # define span_COMPILER_MSVC_VER 0 214 # define span_COMPILER_MSVC_VERSION 0 217 #define span_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) ) 219 #if defined(__clang__) 220 # define span_COMPILER_CLANG_VERSION span_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__) 222 # define span_COMPILER_CLANG_VERSION 0 225 #if defined(__GNUC__) && !defined(__clang__) 226 # define span_COMPILER_GNUC_VERSION span_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) 228 # define span_COMPILER_GNUC_VERSION 0 232 #define span_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) ) 236 #if defined(__clang__) 237 # pragma clang diagnostic push 238 # pragma clang diagnostic ignored "-Wundef" 239 # define span_RESTORE_WARNINGS() _Pragma( "clang diagnostic pop" ) 241 #elif defined __GNUC__ 242 # pragma GCC diagnostic push 243 # pragma GCC diagnostic ignored "-Wundef" 244 # define span_RESTORE_WARNINGS() _Pragma( "GCC diagnostic pop" ) 246 #elif span_COMPILER_MSVC_VERSION >= 140 247 # define span_DISABLE_MSVC_WARNINGS(codes) __pragma(warning(push)) __pragma(warning(disable: codes)) 248 # define span_RESTORE_WARNINGS() __pragma(warning(pop )) 259 span_DISABLE_MSVC_WARNINGS( 26439 26440 26472 26473 26481 26490 )
262 # define span_RESTORE_WARNINGS() 267 #define span_HAVE( feature ) ( span_HAVE_##feature ) 270 # define span_HAS_CPP0X _HAS_CPP0X 272 # define span_HAS_CPP0X 0 275 #define span_CPP11_80 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1400) 276 #define span_CPP11_90 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1500) 277 #define span_CPP11_100 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1600) 278 #define span_CPP11_110 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1700) 279 #define span_CPP11_120 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1800) 280 #define span_CPP11_140 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1900) 282 #define span_CPP14_000 (span_CPP14_OR_GREATER) 283 #define span_CPP14_120 (span_CPP14_OR_GREATER || span_COMPILER_MSVC_VER >= 1800) 284 #define span_CPP14_140 (span_CPP14_OR_GREATER || span_COMPILER_MSVC_VER >= 1900) 286 #define span_CPP17_000 (span_CPP17_OR_GREATER) 290 #define span_HAVE_ALIAS_TEMPLATE span_CPP11_140 291 #define span_HAVE_AUTO span_CPP11_100 292 #define span_HAVE_CONSTEXPR_11 span_CPP11_140 293 #define span_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG span_CPP11_120 294 #define span_HAVE_EXPLICIT_CONVERSION span_CPP11_140 295 #define span_HAVE_INITIALIZER_LIST span_CPP11_120 296 #define span_HAVE_IS_DEFAULT span_CPP11_140 297 #define span_HAVE_IS_DELETE span_CPP11_140 298 #define span_HAVE_NOEXCEPT span_CPP11_140 299 #define span_HAVE_NULLPTR span_CPP11_100 300 #define span_HAVE_STATIC_ASSERT span_CPP11_100 304 #define span_HAVE_CONSTEXPR_14 span_CPP14_000 308 #define span_HAVE_DEPRECATED span_CPP17_000 309 #define span_HAVE_NODISCARD span_CPP17_000 310 #define span_HAVE_NORETURN span_CPP17_000 314 #define span_HAVE_DEDUCTION_GUIDES (span_CPP17_OR_GREATER && ! span_BETWEEN( span_COMPILER_MSVC_VERSION, 1, 999 )) 318 #define span_HAVE_ADDRESSOF span_CPP17_000 319 #define span_HAVE_ARRAY span_CPP11_110 320 #define span_HAVE_BYTE span_CPP17_000 321 #define span_HAVE_CONDITIONAL span_CPP11_120 322 #define span_HAVE_CONTAINER_DATA_METHOD (span_CPP11_140 || ( span_COMPILER_MSVC_VERSION >= 90 && span_HAS_CPP0X )) 323 #define span_HAVE_DATA span_CPP17_000 324 #define span_HAVE_LONGLONG span_CPP11_80 325 #define span_HAVE_REMOVE_CONST span_CPP11_110 326 #define span_HAVE_SNPRINTF span_CPP11_140 327 #define span_HAVE_TYPE_TRAITS span_CPP11_90 331 #ifdef NONSTD_BYTE_LITE_HPP 332 # define span_HAVE_NONSTD_BYTE 1 334 # define span_HAVE_NONSTD_BYTE 0 339 #if span_HAVE_ADDRESSOF 340 # define span_ADDRESSOF(x) std::addressof(x) 342 # define span_ADDRESSOF(x) (&x) 345 #if span_HAVE_CONSTEXPR_11 346 # define span_constexpr constexpr 348 # define span_constexpr 351 #if span_HAVE_CONSTEXPR_14 352 # define span_constexpr14 constexpr 354 # define span_constexpr14 357 #if span_HAVE_EXPLICIT_CONVERSION 358 # define span_explicit explicit 360 # define span_explicit 363 #if span_HAVE_IS_DELETE 364 # define span_is_delete = delete 366 # define span_is_delete 369 #if span_HAVE_IS_DELETE 370 # define span_is_delete_access public 372 # define span_is_delete_access private 375 #if span_HAVE_NOEXCEPT && ! span_CONFIG_CONTRACT_VIOLATION_THROWS_V 376 # define span_noexcept noexcept 378 # define span_noexcept 381 #if span_HAVE_NULLPTR 382 # define span_nullptr nullptr 384 # define span_nullptr NULL 387 #if span_HAVE_DEPRECATED 388 # define span_deprecated(msg) [[deprecated(msg)]] 390 # define span_deprecated(msg) 393 #if span_HAVE_NODISCARD 394 # define span_nodiscard [[nodiscard]] 396 # define span_nodiscard 399 #if span_HAVE_NORETURN 400 # define span_noreturn [[noreturn]] 402 # define span_noreturn 407 #define span_HAVE_CONSTRAINED_SPAN_CONTAINER_CTOR span_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG 411 #if span_HAVE( ADDRESSOF ) 415 #if span_HAVE( ARRAY ) 419 #if span_HAVE( BYTE ) 423 #if span_HAVE( DATA ) 427 #if span_HAVE( TYPE_TRAITS ) 428 # include <type_traits> 431 #if ! span_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR ) 435 #if span_FEATURE( MEMBER_AT ) > 1 439 #if span_CONFIG( CONTRACT_VIOLATION_THROWS_V ) 440 # include <stdexcept> 445 #define span_ELIDE_CONTRACT_EXPECTS ( 0 == ( span_CONFIG_CONTRACT_LEVEL_MASK & 0x01 ) ) 446 #define span_ELIDE_CONTRACT_ENSURES ( 0 == ( span_CONFIG_CONTRACT_LEVEL_MASK & 0x10 ) ) 448 #if span_ELIDE_CONTRACT_EXPECTS 449 # define span_constexpr_exp span_constexpr 450 # define span_EXPECTS( cond ) 452 # define span_constexpr_exp span_constexpr14 453 # define span_EXPECTS( cond ) span_CONTRACT_CHECK( "Precondition", cond ) 456 #if span_ELIDE_CONTRACT_ENSURES 457 # define span_constexpr_ens span_constexpr 458 # define span_ENSURES( cond ) 460 # define span_constexpr_ens span_constexpr14 461 # define span_ENSURES( cond ) span_CONTRACT_CHECK( "Postcondition", cond ) 464 #define span_CONTRACT_CHECK( type, cond ) \ 465 cond ? static_cast< void >( 0 ) \ 466 : nonstd::span_lite::detail::report_contract_violation( span_LOCATION( __FILE__, __LINE__ ) ": " type " violation." ) 469 # define span_LOCATION( file, line ) file ":" span_STRINGIFY( line ) 471 # define span_LOCATION( file, line ) file "(" span_STRINGIFY( line ) ")" 476 #define span_REQUIRES_0(VA) \ 477 template< bool B = (VA), typename std::enable_if<B, int>::type = 0 > 479 #define span_REQUIRES_T(VA) \ 480 , typename = typename std::enable_if< (VA), nonstd::span_lite::detail::enabler >::type 482 #define span_REQUIRES_R(R, VA) \ 483 typename std::enable_if< (VA), R>::type 485 #define span_REQUIRES_A(VA) \ 486 , typename std::enable_if< (VA), void*>::type = nullptr 489 namespace span_lite {
499 template<
class T, extent_t Extent = dynamic_extent >
511 #if span_HAVE( REMOVE_CONST ) 513 using std::remove_cv;
514 using std::remove_const;
515 using std::remove_volatile;
531 #endif // span_HAVE( REMOVE_CONST ) 533 #if span_HAVE( TYPE_TRAITS ) 536 using std::integral_constant;
546 template<
class T,
class U >
struct is_same : false_type{};
547 template<
class T >
struct is_same<T, T> : true_type{};
566 #if span_HAVE( DATA ) 571 #elif span_HAVE_CONSTRAINED_SPAN_CONTAINER_CTOR 573 template<
typename T,
size_t N >
579 template<
typename C >
585 template<
typename T,
size_t N >
591 template<
typename C >
592 inline span_constexpr auto data( C & cont ) -> decltype( cont.data() )
597 template<
typename C >
598 inline span_constexpr auto data( C
const & cont ) -> decltype( cont.data() )
603 template<
typename E >
609 #endif // span_HAVE( DATA ) 611 #if span_HAVE( BYTE ) 613 #elif span_HAVE( NONSTD_BYTE ) 625 #if span_HAVE( TYPE_TRAITS ) 630 template<
class T, std::ptrdiff_t Extent >
634 struct is_span : is_span_oracle< typename std::remove_cv<Q>::type >{};
639 #if span_HAVE( ARRAY ) 641 template<
class T, std::
size_t Extent >
642 struct is_std_array_oracle< std::array<T, Extent> > :
std::true_type{};
647 struct is_std_array : is_std_array_oracle< typename std::remove_cv<Q>::type >{};
655 template<
class T, std::
size_t N >
658 #if span_CPP11_140 && ! span_BETWEEN( span_COMPILER_GNUC_VERSION, 1, 500 ) 660 template<
class,
class =
void >
664 struct has_size_and_data
667 decltype( std17::size(std::declval<C>()) ),
668 decltype( std17::data(std::declval<C>()) ) >
671 template<
class,
class,
class =
void >
674 template<
class C,
class E >
675 struct is_compatible_element
678 decltype( std17::data(std::declval<C>()) ) >
679 > : std::is_convertible< typename std::remove_pointer<decltype( std17::data( std::declval<C&>() ) )>::type(*)[], E(*)[] >{};
684 ! is_span< C >::value
685 && ! is_array< C >::value
686 && ! is_std_array< C >::value
687 && has_size_and_data< C >::value
690 template<
class C,
class E >
693 is_container<C>::value
694 && is_compatible_element<C,E>::value
697 #else // span_CPP11_140 702 ! is_span< C >::value
703 && ! is_array< C >::value
704 && ! is_std_array< C >::value
705 && ( std::is_convertible<
typename std::remove_pointer<decltype( std17::data( std::declval<C&>() ) )>::type(*)[], E(*)[] >::value)
708 ,
class = decltype(
std17::size(std::declval<C>()) )
709 ,
class = decltype( std17::data(std::declval<C>()) )
713 #endif // span_CPP11_140 715 #endif // span_HAVE( TYPE_TRAITS ) 717 #if ! span_CONFIG( NO_EXCEPTIONS ) 718 #if span_FEATURE( MEMBER_AT ) > 1 722 #if defined(__clang__) 723 # pragma clang diagnostic ignored "-Wlong-long" 724 #elif defined __GNUC__ 725 # pragma GCC diagnostic ignored "-Wformat=ll" 726 # pragma GCC diagnostic ignored "-Wlong-long" 729 inline void throw_out_of_range( index_t idx, index_t
size )
731 const char fmt[] =
"span::at(): index '%lli' is out of range [0..%lli)";
732 char buffer[ 2 * 20 +
sizeof fmt ];
733 sprintf( buffer, fmt, static_cast<long long>(idx), static_cast<long long>(size) );
735 throw std::out_of_range( buffer );
740 inline void throw_out_of_range( index_t , index_t )
742 throw std::out_of_range(
"span::at(): index outside span" );
745 #endif // NO_EXCEPTIONS 747 #if span_CONFIG( CONTRACT_VIOLATION_THROWS_V ) 749 struct contract_violation : std::logic_error
751 explicit contract_violation(
char const *
const message )
752 : std::logic_error( message )
758 throw contract_violation( msg );
761 #else // span_CONFIG( CONTRACT_VIOLATION_THROWS_V ) 768 #endif // span_CONFIG( CONTRACT_VIOLATION_THROWS_V ) 774 #define span_sizeof(T) static_cast<extent_t>( sizeof(T) ) 779 return static_cast<index_t
>(
size );
785 template<
class T, extent_t Extent >
811 enum { extent = Extent };
815 #if span_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) 838 , size_(
to_size(
std::distance( firstElem, lastElem ) ) )
841 std::distance( firstElem, lastElem ) >= 0
846 #if span_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) 848 (Extent == dynamic_extent || Extent == static_cast<extent_t>(N))
849 && std::is_convertible< value_type(*)[], element_type(*)[] >::value
858 #if span_HAVE( ARRAY ) 861 # if span_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) 863 (Extent == dynamic_extent || Extent == static_cast<extent_t>(N))
864 && std::is_convertible< value_type(*)[], element_type(*)[] >::value
868 # if span_FEATURE( CONSTRUCTION_FROM_STDARRAY_ELEMENT_TYPE ) 874 , size_(
to_size( arr.size() ) )
878 # if span_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) 880 (Extent == dynamic_extent || Extent == static_cast<extent_t>(N))
881 && std::is_convertible< value_type(*)[], element_type(*)[] >::value
887 , size_(
to_size( arr.size() ) )
890 #endif // span_HAVE( ARRAY ) 892 #if span_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR ) 893 template<
class Container
895 detail::is_compatible_container< Container, element_type >::value
899 : data_( std17::data( cont ) )
903 template<
class Container
905 std::is_const< element_type >::value
906 && detail::is_compatible_container< Container, element_type >::value
910 : data_( std17::data( cont ) )
914 #endif // span_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR ) 916 #if span_FEATURE( WITH_CONTAINER ) 918 template<
class Container >
921 , size_(
to_size( cont.size() ) )
924 template<
class Container >
927 , size_(
to_size( cont.size() ) )
931 #if span_HAVE( IS_DEFAULT ) 934 ~span() span_noexcept =
default;
936 span_constexpr14 span & operator=( span
const & other ) span_noexcept =
default;
939 : data_( other.
data_ )
940 , size_( other.
size_ )
955 template<
class OtherElementType, extent_type OtherExtent
956 #if span_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) 958 (Extent == dynamic_extent || Extent == OtherExtent)
959 && std::is_convertible<OtherElementType(*)[], element_type(*)[]>::value
964 : data_( reinterpret_cast<pointer>( other.
data() ) )
965 , size_( other.
size() )
972 template< extent_type Count >
981 template< extent_type Count >
990 #if span_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) 991 template< index_type Offset, extent_type Count = dynamic_extent >
993 template< index_type Offset, extent_type
Count >
999 ( 0 <= Offset && Offset <=
size() ) &&
1004 data() + Offset,
Count != dynamic_extent ?
Count : (Extent != dynamic_extent ? Extent - Offset :
size() - Offset) );
1024 subspan( index_type offset, index_type count = static_cast<index_type>(dynamic_extent) )
const 1027 ( ( 0 <= offset && offset <=
size() ) ) &&
1028 ( count == static_cast<index_type>(dynamic_extent) || ( 0 <= count && offset + count <=
size() ) )
1032 data() + offset, count ==
static_cast<index_type
>(
dynamic_extent) ?
size() - offset : count );
1044 return static_cast<std::ptrdiff_t
>( size_ );
1049 return size() *
to_size(
sizeof( element_type ) );
1063 return *( data() + idx );
1066 #if span_FEATURE( MEMBER_CALL_OPERATOR ) 1073 return *( data() + idx );
1077 #if span_FEATURE( MEMBER_AT ) 1080 #if span_CONFIG( NO_EXCEPTIONS ) 1081 return this->operator[]( idx );
1083 if ( idx < 0 ||
size() <= idx )
1085 detail::throw_out_of_range( idx,
size() );
1087 return *( data() + idx );
1097 #if span_FEATURE( MEMBER_BACK_FRONT ) 1110 return *( data() +
size() - 1 );
1117 #if span_FEATURE( MEMBER_SWAP ) 1122 swap( data_, other.
data_ );
1123 swap( size_, other.
size_ );
1131 #if span_CPP11_OR_GREATER 1134 return iterator( data() );
1140 #if span_CPP11_OR_GREATER 1141 return { data() +
size() };
1143 return iterator( data() +
size() );
1149 #if span_CPP11_OR_GREATER 1152 return const_iterator( data() );
1158 #if span_CPP11_OR_GREATER 1159 return { data() +
size() };
1161 return const_iterator( data() +
size() );
1167 return reverse_iterator( end() );
1172 return reverse_iterator( begin() );
1177 return const_reverse_iterator ( cend() );
1182 return const_reverse_iterator( cbegin() );
1192 #if span_HAVE( DEDUCTION_GUIDES ) // span_CPP17_OR_GREATER 1194 template<
class T,
size_t N >
1197 template<
class T,
size_t N >
1200 template<
class T,
size_t N >
1203 template<
class Container >
1206 template<
class Container >
1209 #endif // span_HAVE( DEDUCTION_GUIDES ) 1213 #if span_FEATURE( COMPARISON ) 1214 #if span_FEATURE( SAME ) 1216 template<
class T1, extent_t E1,
class T2, extent_t E2 >
1220 && l.size() == r.size()
1221 &&
static_cast<void const*
>( l.data() ) == r.data();
1226 template<
class T1, extent_t E1,
class T2, extent_t E2 >
1230 #if span_FEATURE( SAME ) 1236 template<
class T1, extent_t E1,
class T2, extent_t E2 >
1239 return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
1242 template<
class T1, extent_t E1,
class T2, extent_t E2 >
1248 template<
class T1, extent_t E1,
class T2, extent_t E2 >
1254 template<
class T1, extent_t E1,
class T2, extent_t E2 >
1260 template<
class T1, extent_t E1,
class T2, extent_t E2 >
1266 #endif // span_FEATURE( COMPARISON ) 1270 #if span_HAVE( BYTE ) || span_HAVE( NONSTD_BYTE ) 1272 template<
class T, extent_t Extent >
1277 return {
reinterpret_cast< std17::byte
const *
>( spn.
data() ), spn.
size_bytes() };
1280 reinterpret_cast< std17::byte
const *
>( spn.
data() ), spn.
size_bytes() );
1284 template<
class T, extent_t Extent >
1289 return {
reinterpret_cast< std17::byte *
>( spn.
data() ), spn.
size_bytes() };
1292 reinterpret_cast< std17::byte *
>( spn.
data() ), spn.
size_bytes() );
1296 #endif // span_HAVE( BYTE ) || span_HAVE( NONSTD_BYTE ) 1301 #if span_FEATURE( NON_MEMBER_FIRST_LAST_SUB ) && span_CPP11_120 1303 template< extent_t Count,
class T >
1305 first( T & t ) -> decltype( make_span(t).
template first<Count>() )
1307 return make_span( t ).template first<Count>();
1312 first( T & t, index_t count ) -> decltype( make_span(t).first(count) )
1314 return make_span( t ).first( count );
1317 template< extent_t Count,
class T >
1319 last( T & t ) -> decltype( make_span(t).
template last<Count>() )
1321 return make_span(t).template last<Count>();
1326 last( T & t, extent_t count ) -> decltype( make_span(t).last(count) )
1328 return make_span( t ).last( count );
1331 template< index_t Offset, extent_t Count = dynamic_extent,
class T >
1333 subspan( T & t ) -> decltype( make_span(t).
template subspan<Offset, Count>() )
1335 return make_span( t ).template subspan<Offset, Count>();
1340 subspan( T & t, index_t offset, extent_t count = dynamic_extent ) -> decltype( make_span(t).subspan(offset, count) )
1342 return make_span( t ).subspan( offset, count );
1345 #endif // span_FEATURE( NON_MEMBER_FIRST_LAST_SUB ) 1349 template<
class T, extent_t Extent >
1352 return static_cast<std::size_t
>( spn.
size() );
1355 template<
class T, extent_t Extent >
1358 return static_cast<std::ptrdiff_t
>( spn.
size() );
1374 #if span_FEATURE( COMPARISON ) 1375 #if span_FEATURE( SAME ) 1376 using span_lite::same;
1379 using span_lite::operator==;
1380 using span_lite::operator!=;
1381 using span_lite::operator<;
1382 using span_lite::operator<=;
1383 using span_lite::operator>;
1384 using span_lite::operator>=;
1387 #if span_HAVE( BYTE ) 1388 using span_lite::as_bytes;
1389 using span_lite::as_writeable_bytes;
1397 #endif // span_USES_STD_SPAN 1401 #if span_FEATURE( MAKE_SPAN ) || span_FEATURE( NON_MEMBER_FIRST_LAST_SUB ) 1404 namespace span_lite {
1408 make_span( T * ptr, index_t count ) span_noexcept
1415 make_span( T * first, T * last ) span_noexcept
1417 return span<T>( first, last );
1420 template<
class T,
size_t N >
1422 make_span( T ( &arr )[ N ] ) span_noexcept
1427 #if span_USES_STD_SPAN || span_HAVE( ARRAY ) 1429 template<
class T,
size_t N >
1431 make_span( std::array< T, N > & arr ) span_noexcept
1436 template<
class T,
size_t N >
1438 make_span( std::array< T, N >
const & arr ) span_noexcept
1443 #endif // span_HAVE( ARRAY ) 1445 #if span_USES_STD_SPAN || ( span_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR ) && span_HAVE( AUTO ) ) 1447 template<
class Container,
class EP = decltype( std17::data(std::declval<Container&>())) >
1454 template<
class Container,
class EP = decltype( std17::data(std::declval<Container&>())) >
1463 template<
class T,
class Allocator >
1465 make_span( std::vector<T, Allocator> & cont ) span_noexcept
1470 template<
class T,
class Allocator >
1472 make_span( std::vector<T, Allocator>
const & cont ) span_noexcept
1477 #endif // span_USES_STD_SPAN || ( ... ) 1479 #if ! span_USES_STD_SPAN && span_FEATURE( WITH_CONTAINER ) 1481 template<
class Container >
1488 template<
class Container >
1495 #endif // ! span_USES_STD_SPAN && span_FEATURE( WITH_CONTAINER ) 1504 using span_lite::make_span;
1507 #endif // #if span_FEATURE_TO_STD( MAKE_SPAN ) 1509 #if span_CPP11_OR_GREATER && span_FEATURE( BYTE_SPAN ) && ( span_HAVE( BYTE ) || span_HAVE( NONSTD_BYTE ) ) 1512 namespace span_lite {
1534 using span_lite::byte_span;
1537 #endif // span_FEATURE( BYTE_SPAN ) 1539 #if ! span_USES_STD_SPAN 1541 #endif // span_USES_STD_SPAN 1543 #endif // NONSTD_SPAN_HPP_INCLUDED
std11::remove_volatile< typename std11::remove_const< T >::type >::type type
#define span_CONFIG_INDEX_TYPE
const_pointer const_iterator
span_constexpr span(span const &other) span_noexcept
span_constexpr_exp span< element_type, dynamic_extent > subspan(index_type offset, index_type count=static_cast< index_type >(dynamic_extent)) const
span_constexpr_exp span(pointer ptr, index_type count)
span_constexpr iterator begin() const span_noexcept
span_constexpr_exp reference operator[](index_type idx) const
span_CONFIG_INDEX_TYPE index_t
span_constexpr_exp span(span< OtherElementType, OtherExtent > const &other) span_noexcept
#define span_REQUIRES_0(VA)
span_constexpr bool operator>=(span< T1, E1 > const &l, span< T2, E2 > const &r)
span_constexpr bool operator!=(span< T1, E1 > const &l, span< T2, E2 > const &r)
#define span_constexpr_exp
span_constexpr std::ptrdiff_t ssize(span< T, Extent > const &spn)
#define span_REQUIRES_T(VA)
std::ptrdiff_t difference_type
T const & const_reference
span_constexpr reverse_iterator rbegin() const span_noexcept
span_constexpr_exp span< element_type, Count > last() const
#define span_EXPECTS(cond)
span_constexpr index_t to_size(T size)
span_constexpr_exp span< element_type, dynamic_extent > last(index_type count) const
#define span_ADDRESSOF(x)
span_constexpr const_iterator cbegin() const span_noexcept
const span_constexpr with_container_t with_container
span_constexpr span(element_type(&arr)[N]) span_noexcept
#define span_RESTORE_WARNINGS()
span_constexpr const_reverse_iterator crbegin() const span_noexcept
span_constexpr bool operator==(span< T1, E1 > const &l, span< T2, E2 > const &r)
integral_constant< bool, false > false_type
span_constexpr pointer data() const span_noexcept
span_noreturn void report_contract_violation(char const *) span_noexcept
integral_constant< bool, true > true_type
span_constexpr_exp reference back() const span_noexcept
std11::remove_cv< T >::type value_type
span_constexpr_exp span(pointer firstElem, pointer lastElem)
std::reverse_iterator< iterator > reverse_iterator
span_constexpr_exp span< element_type, Count > first() const
span_constexpr span() span_noexcept
#define span_deprecated(msg)
span_constexpr with_container_t() span_noexcept
span_constexpr_exp reference front() const span_noexcept
span_constexpr const extent_t dynamic_extent
std::reverse_iterator< const_iterator > const_reverse_iterator
span_constexpr_exp span< element_type, Count > subspan() const
span_constexpr const_iterator cend() const span_noexcept
span_constexpr std::ptrdiff_t ssize() const span_noexcept
span_constexpr iterator end() const span_noexcept
span_constexpr std::size_t size(span< T, Extent > const &spn)
span_nodiscard span_constexpr bool empty() const span_noexcept
span_constexpr_exp span< element_type, dynamic_extent > first(index_type count) const
span_constexpr reverse_iterator rend() const span_noexcept
span_constexpr const_reverse_iterator crend() const span_noexcept
span_constexpr index_type size() const span_noexcept
span_constexpr index_type size_bytes() const span_noexcept
span_constexpr bool operator>(span< T1, E1 > const &l, span< T2, E2 > const &r)
span_constexpr14 span & operator=(span const &other) span_noexcept