--- /dev/null
+//
+// span for C++98 and later.
+// Based on http://wg21.link/p0122r7
+// For more information see https://github.com/martinmoene/span-lite
+//
+// Copyright 2018-2021 Martin Moene
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef NONSTD_SPAN_HPP_INCLUDED
+#define NONSTD_SPAN_HPP_INCLUDED
+
+#define span_lite_MAJOR 0
+#define span_lite_MINOR 11
+#define span_lite_PATCH 0
+
+#define span_lite_VERSION span_STRINGIFY(span_lite_MAJOR) "." span_STRINGIFY(span_lite_MINOR) "." span_STRINGIFY(span_lite_PATCH)
+
+#define span_STRINGIFY( x ) span_STRINGIFY_( x )
+#define span_STRINGIFY_( x ) #x
+
+// span configuration:
+
+#define span_SPAN_DEFAULT 0
+#define span_SPAN_NONSTD 1
+#define span_SPAN_STD 2
+
+// tweak header support:
+
+#ifdef __has_include
+# if __has_include(<nonstd/span.tweak.hpp>)
+# include <nonstd/span.tweak.hpp>
+# endif
+#define span_HAVE_TWEAK_HEADER 1
+#else
+#define span_HAVE_TWEAK_HEADER 0
+//# pragma message("span.hpp: Note: Tweak header not supported.")
+#endif
+
+// span selection and configuration:
+
+#define span_HAVE( feature ) ( span_HAVE_##feature )
+
+#ifndef span_CONFIG_SELECT_SPAN
+# define span_CONFIG_SELECT_SPAN ( span_HAVE_STD_SPAN ? span_SPAN_STD : span_SPAN_NONSTD )
+#endif
+
+#ifndef span_CONFIG_EXTENT_TYPE
+# define span_CONFIG_EXTENT_TYPE std::size_t
+#endif
+
+#ifndef span_CONFIG_SIZE_TYPE
+# define span_CONFIG_SIZE_TYPE std::size_t
+#endif
+
+#ifdef span_CONFIG_INDEX_TYPE
+# error `span_CONFIG_INDEX_TYPE` is deprecated since v0.7.0; it is replaced by `span_CONFIG_SIZE_TYPE`.
+#endif
+
+// span configuration (features):
+
+#ifndef span_FEATURE_WITH_INITIALIZER_LIST_P2447
+# define span_FEATURE_WITH_INITIALIZER_LIST_P2447 0
+#endif
+
+#ifndef span_FEATURE_WITH_CONTAINER
+#ifdef span_FEATURE_WITH_CONTAINER_TO_STD
+# define span_FEATURE_WITH_CONTAINER span_IN_STD( span_FEATURE_WITH_CONTAINER_TO_STD )
+#else
+# define span_FEATURE_WITH_CONTAINER 0
+# define span_FEATURE_WITH_CONTAINER_TO_STD 0
+#endif
+#endif
+
+#ifndef span_FEATURE_CONSTRUCTION_FROM_STDARRAY_ELEMENT_TYPE
+# define span_FEATURE_CONSTRUCTION_FROM_STDARRAY_ELEMENT_TYPE 0
+#endif
+
+#ifndef span_FEATURE_MEMBER_AT
+# define span_FEATURE_MEMBER_AT 0
+#endif
+
+#ifndef span_FEATURE_MEMBER_BACK_FRONT
+# define span_FEATURE_MEMBER_BACK_FRONT 1
+#endif
+
+#ifndef span_FEATURE_MEMBER_CALL_OPERATOR
+# define span_FEATURE_MEMBER_CALL_OPERATOR 0
+#endif
+
+#ifndef span_FEATURE_MEMBER_SWAP
+# define span_FEATURE_MEMBER_SWAP 0
+#endif
+
+#ifndef span_FEATURE_NON_MEMBER_FIRST_LAST_SUB
+# define span_FEATURE_NON_MEMBER_FIRST_LAST_SUB 0
+#elif span_FEATURE_NON_MEMBER_FIRST_LAST_SUB
+# define span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_SPAN 1
+# define span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_CONTAINER 1
+#endif
+
+#ifndef span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_SPAN
+# define span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_SPAN 0
+#endif
+
+#ifndef span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_CONTAINER
+# define span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_CONTAINER 0
+#endif
+
+#ifndef span_FEATURE_COMPARISON
+# define span_FEATURE_COMPARISON 0 // Note: C++20 does not provide comparison
+#endif
+
+#ifndef span_FEATURE_SAME
+# define span_FEATURE_SAME 0
+#endif
+
+#if span_FEATURE_SAME && !span_FEATURE_COMPARISON
+# error `span_FEATURE_SAME` requires `span_FEATURE_COMPARISON`
+#endif
+
+#ifndef span_FEATURE_MAKE_SPAN
+#ifdef span_FEATURE_MAKE_SPAN_TO_STD
+# define span_FEATURE_MAKE_SPAN span_IN_STD( span_FEATURE_MAKE_SPAN_TO_STD )
+#else
+# define span_FEATURE_MAKE_SPAN 0
+# define span_FEATURE_MAKE_SPAN_TO_STD 0
+#endif
+#endif
+
+#ifndef span_FEATURE_BYTE_SPAN
+# define span_FEATURE_BYTE_SPAN 0
+#endif
+
+// Control presence of exception handling (try and auto discover):
+
+#ifndef span_CONFIG_NO_EXCEPTIONS
+# if defined(_MSC_VER)
+# include <cstddef> // for _HAS_EXCEPTIONS
+# endif
+# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
+# define span_CONFIG_NO_EXCEPTIONS 0
+# else
+# define span_CONFIG_NO_EXCEPTIONS 1
+# undef span_CONFIG_CONTRACT_VIOLATION_THROWS
+# undef span_CONFIG_CONTRACT_VIOLATION_TERMINATES
+# define span_CONFIG_CONTRACT_VIOLATION_THROWS 0
+# define span_CONFIG_CONTRACT_VIOLATION_TERMINATES 1
+# endif
+#endif
+
+// Control pre- and postcondition violation behaviour:
+
+#if defined( span_CONFIG_CONTRACT_LEVEL_ON )
+# define span_CONFIG_CONTRACT_LEVEL_MASK 0x11
+#elif defined( span_CONFIG_CONTRACT_LEVEL_OFF )
+# define span_CONFIG_CONTRACT_LEVEL_MASK 0x00
+#elif defined( span_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY )
+# define span_CONFIG_CONTRACT_LEVEL_MASK 0x01
+#elif defined( span_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY )
+# define span_CONFIG_CONTRACT_LEVEL_MASK 0x10
+#else
+# define span_CONFIG_CONTRACT_LEVEL_MASK 0x11
+#endif
+
+#if defined( span_CONFIG_CONTRACT_VIOLATION_THROWS )
+# define span_CONFIG_CONTRACT_VIOLATION_THROWS_V span_CONFIG_CONTRACT_VIOLATION_THROWS
+#else
+# define span_CONFIG_CONTRACT_VIOLATION_THROWS_V 0
+#endif
+
+#if defined( span_CONFIG_CONTRACT_VIOLATION_THROWS ) && span_CONFIG_CONTRACT_VIOLATION_THROWS && \
+ defined( span_CONFIG_CONTRACT_VIOLATION_TERMINATES ) && span_CONFIG_CONTRACT_VIOLATION_TERMINATES
+# error Please define none or one of span_CONFIG_CONTRACT_VIOLATION_THROWS and span_CONFIG_CONTRACT_VIOLATION_TERMINATES to 1, but not both.
+#endif
+
+// C++ language version detection (C++23 is speculative):
+// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
+
+#ifndef span_CPLUSPLUS
+# if defined(_MSVC_LANG ) && !defined(__clang__)
+# define span_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
+# else
+# define span_CPLUSPLUS __cplusplus
+# endif
+#endif
+
+#define span_CPP98_OR_GREATER ( span_CPLUSPLUS >= 199711L )
+#define span_CPP11_OR_GREATER ( span_CPLUSPLUS >= 201103L )
+#define span_CPP14_OR_GREATER ( span_CPLUSPLUS >= 201402L )
+#define span_CPP17_OR_GREATER ( span_CPLUSPLUS >= 201703L )
+#define span_CPP20_OR_GREATER ( span_CPLUSPLUS >= 202002L )
+#define span_CPP23_OR_GREATER ( span_CPLUSPLUS >= 202300L )
+
+// C++ language version (represent 98 as 3):
+
+#define span_CPLUSPLUS_V ( span_CPLUSPLUS / 100 - (span_CPLUSPLUS > 200000 ? 2000 : 1994) )
+
+#define span_IN_STD( v ) ( ((v) == 98 ? 3 : (v)) >= span_CPLUSPLUS_V )
+
+#define span_CONFIG( feature ) ( span_CONFIG_##feature )
+#define span_FEATURE( feature ) ( span_FEATURE_##feature )
+#define span_FEATURE_TO_STD( feature ) ( span_IN_STD( span_FEATURE( feature##_TO_STD ) ) )
+
+// Use C++20 std::span if available and requested:
+
+#if span_CPP20_OR_GREATER && defined(__has_include )
+# if __has_include( <span> )
+# define span_HAVE_STD_SPAN 1
+# else
+# define span_HAVE_STD_SPAN 0
+# endif
+#else
+# define span_HAVE_STD_SPAN 0
+#endif
+
+#define span_USES_STD_SPAN ( (span_CONFIG_SELECT_SPAN == span_SPAN_STD) || ((span_CONFIG_SELECT_SPAN == span_SPAN_DEFAULT) && span_HAVE_STD_SPAN) )
+
+//
+// Use C++20 std::span:
+//
+
+#if span_USES_STD_SPAN
+
+#include <span>
+
+namespace nonstd {
+
+using std::span;
+using std::dynamic_extent;
+
+// Note: C++20 does not provide comparison
+// using std::operator==;
+// using std::operator!=;
+// using std::operator<;
+// using std::operator<=;
+// using std::operator>;
+// using std::operator>=;
+} // namespace nonstd
+
+#else // span_USES_STD_SPAN
+
+#include <algorithm>
+
+// Compiler versions:
+//
+// MSVC++ 6.0 _MSC_VER == 1200 span_COMPILER_MSVC_VERSION == 60 (Visual Studio 6.0)
+// MSVC++ 7.0 _MSC_VER == 1300 span_COMPILER_MSVC_VERSION == 70 (Visual Studio .NET 2002)
+// MSVC++ 7.1 _MSC_VER == 1310 span_COMPILER_MSVC_VERSION == 71 (Visual Studio .NET 2003)
+// MSVC++ 8.0 _MSC_VER == 1400 span_COMPILER_MSVC_VERSION == 80 (Visual Studio 2005)
+// MSVC++ 9.0 _MSC_VER == 1500 span_COMPILER_MSVC_VERSION == 90 (Visual Studio 2008)
+// MSVC++ 10.0 _MSC_VER == 1600 span_COMPILER_MSVC_VERSION == 100 (Visual Studio 2010)
+// MSVC++ 11.0 _MSC_VER == 1700 span_COMPILER_MSVC_VERSION == 110 (Visual Studio 2012)
+// MSVC++ 12.0 _MSC_VER == 1800 span_COMPILER_MSVC_VERSION == 120 (Visual Studio 2013)
+// MSVC++ 14.0 _MSC_VER == 1900 span_COMPILER_MSVC_VERSION == 140 (Visual Studio 2015)
+// MSVC++ 14.1 _MSC_VER >= 1910 span_COMPILER_MSVC_VERSION == 141 (Visual Studio 2017)
+// MSVC++ 14.2 _MSC_VER >= 1920 span_COMPILER_MSVC_VERSION == 142 (Visual Studio 2019)
+
+#if defined(_MSC_VER ) && !defined(__clang__)
+# define span_COMPILER_MSVC_VER (_MSC_VER )
+# define span_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
+#else
+# define span_COMPILER_MSVC_VER 0
+# define span_COMPILER_MSVC_VERSION 0
+#endif
+
+#define span_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) )
+
+#if defined(__clang__)
+# define span_COMPILER_CLANG_VERSION span_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#else
+# define span_COMPILER_CLANG_VERSION 0
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+# define span_COMPILER_GNUC_VERSION span_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#else
+# define span_COMPILER_GNUC_VERSION 0
+#endif
+
+// half-open range [lo..hi):
+#define span_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
+
+// Compiler warning suppression:
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wundef"
+# pragma clang diagnostic ignored "-Wmismatched-tags"
+# define span_RESTORE_WARNINGS() _Pragma( "clang diagnostic pop" )
+
+#elif defined __GNUC__
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wundef"
+# define span_RESTORE_WARNINGS() _Pragma( "GCC diagnostic pop" )
+
+#elif span_COMPILER_MSVC_VER >= 1900
+# define span_DISABLE_MSVC_WARNINGS(codes) __pragma(warning(push)) __pragma(warning(disable: codes))
+# define span_RESTORE_WARNINGS() __pragma(warning(pop ))
+
+// Suppress the following MSVC GSL warnings:
+// - C26439, gsl::f.6 : special function 'function' can be declared 'noexcept'
+// - C26440, gsl::f.6 : function 'function' can be declared 'noexcept'
+// - C26472, gsl::t.1 : don't use a static_cast for arithmetic conversions;
+// use brace initialization, gsl::narrow_cast or gsl::narrow
+// - C26473: gsl::t.1 : don't cast between pointer types where the source type and the target type are the same
+// - C26481: gsl::b.1 : don't use pointer arithmetic. Use span instead
+// - C26490: gsl::t.1 : don't use reinterpret_cast
+
+span_DISABLE_MSVC_WARNINGS( 26439 26440 26472 26473 26481 26490 )
+
+#else
+# define span_RESTORE_WARNINGS() /*empty*/
+#endif
+
+// Presence of language and library features:
+
+#ifdef _HAS_CPP0X
+# define span_HAS_CPP0X _HAS_CPP0X
+#else
+# define span_HAS_CPP0X 0
+#endif
+
+#define span_CPP11_80 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1400)
+#define span_CPP11_90 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1500)
+#define span_CPP11_100 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1600)
+#define span_CPP11_110 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1700)
+#define span_CPP11_120 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1800)
+#define span_CPP11_140 (span_CPP11_OR_GREATER || span_COMPILER_MSVC_VER >= 1900)
+
+#define span_CPP14_000 (span_CPP14_OR_GREATER)
+#define span_CPP14_120 (span_CPP14_OR_GREATER || span_COMPILER_MSVC_VER >= 1800)
+#define span_CPP14_140 (span_CPP14_OR_GREATER || span_COMPILER_MSVC_VER >= 1900)
+
+#define span_CPP17_000 (span_CPP17_OR_GREATER)
+
+// Presence of C++11 language features:
+
+#define span_HAVE_ALIAS_TEMPLATE span_CPP11_140
+#define span_HAVE_AUTO span_CPP11_100
+#define span_HAVE_CONSTEXPR_11 span_CPP11_140
+#define span_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG span_CPP11_120
+#define span_HAVE_EXPLICIT_CONVERSION span_CPP11_140
+#define span_HAVE_INITIALIZER_LIST span_CPP11_120
+#define span_HAVE_IS_DEFAULT span_CPP11_140
+#define span_HAVE_IS_DELETE span_CPP11_140
+#define span_HAVE_NOEXCEPT span_CPP11_140
+#define span_HAVE_NORETURN ( span_CPP11_140 && ! span_BETWEEN( span_COMPILER_GNUC_VERSION, 1, 480 ) )
+#define span_HAVE_NULLPTR span_CPP11_100
+#define span_HAVE_STATIC_ASSERT span_CPP11_100
+
+// Presence of C++14 language features:
+
+#define span_HAVE_CONSTEXPR_14 span_CPP14_000
+
+// Presence of C++17 language features:
+
+#define span_HAVE_DEPRECATED span_CPP17_000
+#define span_HAVE_NODISCARD span_CPP17_000
+
+// MSVC: template parameter deduction guides since Visual Studio 2017 v15.7
+
+#if defined(__cpp_deduction_guides)
+# define span_HAVE_DEDUCTION_GUIDES 1
+#else
+# define span_HAVE_DEDUCTION_GUIDES (span_CPP17_OR_GREATER && ! span_BETWEEN( span_COMPILER_MSVC_VER, 1, 1913 ))
+#endif
+
+// Presence of C++ library features:
+
+#define span_HAVE_ADDRESSOF span_CPP17_000
+#define span_HAVE_ARRAY span_CPP11_110
+#define span_HAVE_BYTE span_CPP17_000
+#define span_HAVE_CONDITIONAL span_CPP11_120
+#define span_HAVE_CONTAINER_DATA_METHOD (span_CPP11_140 || ( span_COMPILER_MSVC_VER >= 1500 && span_HAS_CPP0X ))
+#define span_HAVE_DATA span_CPP17_000
+#define span_HAVE_LONGLONG span_CPP11_80
+#define span_HAVE_REMOVE_CONST span_CPP11_110
+#define span_HAVE_SNPRINTF span_CPP11_140
+#define span_HAVE_STRUCT_BINDING span_CPP11_120
+#define span_HAVE_TYPE_TRAITS span_CPP11_90
+
+// Presence of byte-lite:
+
+#ifdef NONSTD_BYTE_LITE_HPP
+# define span_HAVE_NONSTD_BYTE 1
+#else
+# define span_HAVE_NONSTD_BYTE 0
+#endif
+
+// C++ feature usage:
+
+#if span_HAVE_ADDRESSOF
+# define span_ADDRESSOF(x) std::addressof(x)
+#else
+# define span_ADDRESSOF(x) (&x)
+#endif
+
+#if span_HAVE_CONSTEXPR_11
+# define span_constexpr constexpr
+#else
+# define span_constexpr /*span_constexpr*/
+#endif
+
+#if span_HAVE_CONSTEXPR_14
+# define span_constexpr14 constexpr
+#else
+# define span_constexpr14 /*span_constexpr*/
+#endif
+
+#if span_HAVE_EXPLICIT_CONVERSION
+# define span_explicit explicit
+#else
+# define span_explicit /*explicit*/
+#endif
+
+#if span_HAVE_IS_DELETE
+# define span_is_delete = delete
+#else
+# define span_is_delete
+#endif
+
+#if span_HAVE_IS_DELETE
+# define span_is_delete_access public
+#else
+# define span_is_delete_access private
+#endif
+
+#if span_HAVE_NOEXCEPT && ! span_CONFIG_CONTRACT_VIOLATION_THROWS_V
+# define span_noexcept noexcept
+#else
+# define span_noexcept /*noexcept*/
+#endif
+
+#if span_HAVE_NULLPTR
+# define span_nullptr nullptr
+#else
+# define span_nullptr NULL
+#endif
+
+#if span_HAVE_DEPRECATED
+# define span_deprecated(msg) [[deprecated(msg)]]
+#else
+# define span_deprecated(msg) /*[[deprecated]]*/
+#endif
+
+#if span_HAVE_NODISCARD
+# define span_nodiscard [[nodiscard]]
+#else
+# define span_nodiscard /*[[nodiscard]]*/
+#endif
+
+#if span_HAVE_NORETURN
+# define span_noreturn [[noreturn]]
+#else
+# define span_noreturn /*[[noreturn]]*/
+#endif
+
+// Other features:
+
+#define span_HAVE_CONSTRAINED_SPAN_CONTAINER_CTOR span_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG
+#define span_HAVE_ITERATOR_CTOR span_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG
+
+// Additional includes:
+
+#if span_HAVE( ADDRESSOF )
+# include <memory>
+#endif
+
+#if span_HAVE( ARRAY )
+# include <array>
+#endif
+
+#if span_HAVE( BYTE )
+# include <cstddef>
+#endif
+
+#if span_HAVE( DATA )
+# include <iterator> // for std::data(), std::size()
+#endif
+
+#if span_HAVE( TYPE_TRAITS )
+# include <type_traits>
+#endif
+
+#if ! span_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+# include <vector>
+#endif
+
+#if span_FEATURE( MEMBER_AT ) > 1
+# include <cstdio>
+#endif
+
+#if ! span_CONFIG( NO_EXCEPTIONS )
+# include <stdexcept>
+#endif
+
+// Contract violation
+
+#define span_ELIDE_CONTRACT_EXPECTS ( 0 == ( span_CONFIG_CONTRACT_LEVEL_MASK & 0x01 ) )
+#define span_ELIDE_CONTRACT_ENSURES ( 0 == ( span_CONFIG_CONTRACT_LEVEL_MASK & 0x10 ) )
+
+#if span_ELIDE_CONTRACT_EXPECTS
+# define span_constexpr_exp span_constexpr
+# define span_EXPECTS( cond ) /* Expect elided */
+#else
+# define span_constexpr_exp span_constexpr14
+# define span_EXPECTS( cond ) span_CONTRACT_CHECK( "Precondition", cond )
+#endif
+
+#if span_ELIDE_CONTRACT_ENSURES
+# define span_constexpr_ens span_constexpr
+# define span_ENSURES( cond ) /* Ensures elided */
+#else
+# define span_constexpr_ens span_constexpr14
+# define span_ENSURES( cond ) span_CONTRACT_CHECK( "Postcondition", cond )
+#endif
+
+#define span_CONTRACT_CHECK( type, cond ) \
+ cond ? static_cast< void >( 0 ) \
+ : nonstd::span_lite::detail::report_contract_violation( span_LOCATION( __FILE__, __LINE__ ) ": " type " violation." )
+
+#ifdef __GNUG__
+# define span_LOCATION( file, line ) file ":" span_STRINGIFY( line )
+#else
+# define span_LOCATION( file, line ) file "(" span_STRINGIFY( line ) ")"
+#endif
+
+// Method enabling
+
+#if span_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+
+#define span_REQUIRES_0(VA) \
+ template< bool B = (VA), typename std::enable_if<B, int>::type = 0 >
+
+# if span_BETWEEN( span_COMPILER_MSVC_VERSION, 1, 140 )
+// VS 2013 and earlier seem to have trouble with SFINAE for default non-type arguments
+# define span_REQUIRES_T(VA) \
+ , typename = typename std::enable_if< ( VA ), nonstd::span_lite::detail::enabler >::type
+# else
+# define span_REQUIRES_T(VA) \
+ , typename std::enable_if< (VA), int >::type = 0
+# endif
+
+#define span_REQUIRES_R(R, VA) \
+ typename std::enable_if< (VA), R>::type
+
+#define span_REQUIRES_A(VA) \
+ , typename std::enable_if< (VA), void*>::type = nullptr
+
+#else
+
+# define span_REQUIRES_0(VA) /*empty*/
+# define span_REQUIRES_T(VA) /*empty*/
+# define span_REQUIRES_R(R, VA) R
+# define span_REQUIRES_A(VA) /*empty*/
+
+#endif
+
+namespace nonstd {
+namespace span_lite {
+
+// [views.constants], constants
+
+typedef span_CONFIG_EXTENT_TYPE extent_t;
+typedef span_CONFIG_SIZE_TYPE size_t;
+
+span_constexpr const extent_t dynamic_extent = static_cast<extent_t>( -1 );
+
+template< class T, extent_t Extent = dynamic_extent >
+class span;
+
+// Tag to select span constructor taking a container (prevent ms-gsl warning C26426):
+
+struct with_container_t { span_constexpr with_container_t() span_noexcept {} };
+const span_constexpr with_container_t with_container;
+
+// C++11 emulation:
+
+namespace std11 {
+
+#if span_HAVE( REMOVE_CONST )
+
+using std::remove_cv;
+using std::remove_const;
+using std::remove_volatile;
+
+#else
+
+template< class T > struct remove_const { typedef T type; };
+template< class T > struct remove_const< T const > { typedef T type; };
+
+template< class T > struct remove_volatile { typedef T type; };
+template< class T > struct remove_volatile< T volatile > { typedef T type; };
+
+template< class T >
+struct remove_cv
+{
+ typedef typename std11::remove_volatile< typename std11::remove_const< T >::type >::type type;
+};
+
+#endif // span_HAVE( REMOVE_CONST )
+
+#if span_HAVE( TYPE_TRAITS )
+
+using std::is_same;
+using std::is_signed;
+using std::integral_constant;
+using std::true_type;
+using std::false_type;
+using std::remove_reference;
+
+#else
+
+template< class T, T v > struct integral_constant { enum { value = v }; };
+typedef integral_constant< bool, true > true_type;
+typedef integral_constant< bool, false > false_type;
+
+template< class T, class U > struct is_same : false_type{};
+template< class T > struct is_same<T, T> : true_type{};
+
+template< typename T > struct is_signed : false_type {};
+template<> struct is_signed<signed char> : true_type {};
+template<> struct is_signed<signed int > : true_type {};
+template<> struct is_signed<signed long> : true_type {};
+
+#endif
+
+} // namespace std11
+
+// C++17 emulation:
+
+namespace std17 {
+
+template< bool v > struct bool_constant : std11::integral_constant<bool, v>{};
+
+#if span_CPP11_120
+
+template< class...>
+using void_t = void;
+
+#endif
+
+#if span_HAVE( DATA )
+
+using std::data;
+using std::size;
+
+#elif span_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+
+template< typename T, std::size_t N >
+inline span_constexpr auto size( const T(&)[N] ) span_noexcept -> size_t
+{
+ return N;
+}
+
+template< typename C >
+inline span_constexpr auto size( C const & cont ) -> decltype( cont.size() )
+{
+ return cont.size();
+}
+
+template< typename T, std::size_t N >
+inline span_constexpr auto data( T(&arr)[N] ) span_noexcept -> T*
+{
+ return &arr[0];
+}
+
+template< typename C >
+inline span_constexpr auto data( C & cont ) -> decltype( cont.data() )
+{
+ return cont.data();
+}
+
+template< typename C >
+inline span_constexpr auto data( C const & cont ) -> decltype( cont.data() )
+{
+ return cont.data();
+}
+
+template< typename E >
+inline span_constexpr auto data( std::initializer_list<E> il ) span_noexcept -> E const *
+{
+ return il.begin();
+}
+
+#endif // span_HAVE( DATA )
+
+#if span_HAVE( BYTE )
+using std::byte;
+#elif span_HAVE( NONSTD_BYTE )
+using nonstd::byte;
+#endif
+
+} // namespace std17
+
+// C++20 emulation:
+
+namespace std20 {
+
+#if span_HAVE( DEDUCTION_GUIDES )
+template< class T >
+using iter_reference_t = decltype( *std::declval<T&>() );
+#endif
+
+} // namespace std20
+
+// Implementation details:
+
+namespace detail {
+
+/*enum*/ struct enabler{};
+
+template< typename T >
+span_constexpr bool is_positive( T x )
+{
+ return std11::is_signed<T>::value ? x >= 0 : true;
+}
+
+#if span_HAVE( TYPE_TRAITS )
+
+template< class Q >
+struct is_span_oracle : std::false_type{};
+
+template< class T, span_CONFIG_EXTENT_TYPE Extent >
+struct is_span_oracle< span<T, Extent> > : std::true_type{};
+
+template< class Q >
+struct is_span : is_span_oracle< typename std::remove_cv<Q>::type >{};
+
+template< class Q >
+struct is_std_array_oracle : std::false_type{};
+
+#if span_HAVE( ARRAY )
+
+template< class T, std::size_t Extent >
+struct is_std_array_oracle< std::array<T, Extent> > : std::true_type{};
+
+#endif
+
+template< class Q >
+struct is_std_array : is_std_array_oracle< typename std::remove_cv<Q>::type >{};
+
+template< class Q >
+struct is_array : std::false_type {};
+
+template< class T >
+struct is_array<T[]> : std::true_type {};
+
+template< class T, std::size_t N >
+struct is_array<T[N]> : std::true_type {};
+
+#if span_CPP11_140 && ! span_BETWEEN( span_COMPILER_GNUC_VERSION, 1, 500 )
+
+template< class, class = void >
+struct has_size_and_data : std::false_type{};
+
+template< class C >
+struct has_size_and_data
+<
+ C, std17::void_t<
+ decltype( std17::size(std::declval<C>()) ),
+ decltype( std17::data(std::declval<C>()) ) >
+> : std::true_type{};
+
+template< class, class, class = void >
+struct is_compatible_element : std::false_type {};
+
+template< class C, class E >
+struct is_compatible_element
+<
+ C, E, std17::void_t<
+ decltype( std17::data(std::declval<C>()) ) >
+> : std::is_convertible< typename std::remove_pointer<decltype( std17::data( std::declval<C&>() ) )>::type(*)[], E(*)[] >{};
+
+template< class C >
+struct is_container : std17::bool_constant
+<
+ ! is_span< C >::value
+ && ! is_array< C >::value
+ && ! is_std_array< C >::value
+ && has_size_and_data< C >::value
+>{};
+
+template< class C, class E >
+struct is_compatible_container : std17::bool_constant
+<
+ is_container<C>::value
+ && is_compatible_element<C,E>::value
+>{};
+
+#else // span_CPP11_140
+
+template<
+ class C, class E
+ span_REQUIRES_T((
+ ! is_span< C >::value
+ && ! is_array< C >::value
+ && ! is_std_array< C >::value
+ && ( std::is_convertible< typename std::remove_pointer<decltype( std17::data( std::declval<C&>() ) )>::type(*)[], E(*)[] >::value)
+ // && has_size_and_data< C >::value
+ ))
+ , class = decltype( std17::size(std::declval<C>()) )
+ , class = decltype( std17::data(std::declval<C>()) )
+>
+struct is_compatible_container : std::true_type{};
+
+#endif // span_CPP11_140
+
+#endif // span_HAVE( TYPE_TRAITS )
+
+#if ! span_CONFIG( NO_EXCEPTIONS )
+#if span_FEATURE( MEMBER_AT ) > 1
+
+// format index and size:
+
+#if defined(__clang__)
+# pragma clang diagnostic ignored "-Wlong-long"
+#elif defined __GNUC__
+# pragma GCC diagnostic ignored "-Wformat=ll"
+# pragma GCC diagnostic ignored "-Wlong-long"
+#endif
+
+span_noreturn inline void throw_out_of_range( size_t idx, size_t size )
+{
+ const char fmt[] = "span::at(): index '%lli' is out of range [0..%lli)";
+ char buffer[ 2 * 20 + sizeof fmt ];
+ sprintf( buffer, fmt, static_cast<long long>(idx), static_cast<long long>(size) );
+
+ throw std::out_of_range( buffer );
+}
+
+#else // MEMBER_AT
+
+span_noreturn inline void throw_out_of_range( size_t /*idx*/, size_t /*size*/ )
+{
+ throw std::out_of_range( "span::at(): index outside span" );
+}
+#endif // MEMBER_AT
+#endif // NO_EXCEPTIONS
+
+#if span_CONFIG( CONTRACT_VIOLATION_THROWS_V )
+
+struct contract_violation : std::logic_error
+{
+ explicit contract_violation( char const * const message )
+ : std::logic_error( message )
+ {}
+};
+
+inline void report_contract_violation( char const * msg )
+{
+ throw contract_violation( msg );
+}
+
+#else // span_CONFIG( CONTRACT_VIOLATION_THROWS_V )
+
+span_noreturn inline void report_contract_violation( char const * /*msg*/ ) span_noexcept
+{
+ std::terminate();
+}
+
+#endif // span_CONFIG( CONTRACT_VIOLATION_THROWS_V )
+
+} // namespace detail
+
+// Prevent signed-unsigned mismatch:
+
+#define span_sizeof(T) static_cast<extent_t>( sizeof(T) )
+
+template< class T >
+inline span_constexpr size_t to_size( T size )
+{
+ return static_cast<size_t>( size );
+}
+
+//
+// [views.span] - A view over a contiguous, single-dimension sequence of objects
+//
+template< class T, extent_t Extent /*= dynamic_extent*/ >
+class span
+{
+public:
+ // constants and types
+
+ typedef T element_type;
+ typedef typename std11::remove_cv< T >::type value_type;
+
+ typedef T & reference;
+ typedef T * pointer;
+ typedef T const * const_pointer;
+ typedef T const & const_reference;
+
+ typedef size_t size_type;
+ typedef extent_t extent_type;
+
+ typedef pointer iterator;
+ typedef const_pointer const_iterator;
+
+ typedef std::ptrdiff_t difference_type;
+
+ typedef std::reverse_iterator< iterator > reverse_iterator;
+ typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
+
+// static constexpr extent_type extent = Extent;
+ enum { extent = Extent };
+
+ // 26.7.3.2 Constructors, copy, and assignment [span.cons]
+
+ span_REQUIRES_0(
+ ( Extent == 0 ) ||
+ ( Extent == dynamic_extent )
+ )
+ span_constexpr span() span_noexcept
+ : data_( span_nullptr )
+ , size_( 0 )
+ {
+ // span_EXPECTS( data() == span_nullptr );
+ // span_EXPECTS( size() == 0 );
+ }
+
+#if span_HAVE( ITERATOR_CTOR )
+ // Didn't yet succeed in combining the next two constructors:
+
+ span_constexpr_exp span( std::nullptr_t, size_type count )
+ : data_( span_nullptr )
+ , size_( count )
+ {
+ span_EXPECTS( data_ == span_nullptr && count == 0 );
+ }
+
+ template< typename It
+ span_REQUIRES_T((
+ std::is_convertible<decltype(*std::declval<It&>()), element_type &>::value
+ ))
+ >
+ span_constexpr_exp span( It first, size_type count )
+ : data_( to_address( first ) )
+ , size_( count )
+ {
+ span_EXPECTS(
+ ( data_ == span_nullptr && count == 0 ) ||
+ ( data_ != span_nullptr && detail::is_positive( count ) )
+ );
+ }
+#else
+ span_constexpr_exp span( pointer ptr, size_type count )
+ : data_( ptr )
+ , size_( count )
+ {
+ span_EXPECTS(
+ ( ptr == span_nullptr && count == 0 ) ||
+ ( ptr != span_nullptr && detail::is_positive( count ) )
+ );
+ }
+#endif
+
+#if span_HAVE( ITERATOR_CTOR )
+ template< typename It, typename End
+ span_REQUIRES_T((
+ std::is_convertible<decltype(&*std::declval<It&>()), element_type *>::value
+ && ! std::is_convertible<End, std::size_t>::value
+ ))
+ >
+ span_constexpr_exp span( It first, End last )
+ : data_( to_address( first ) )
+ , size_( to_size( last - first ) )
+ {
+ span_EXPECTS(
+ last - first >= 0
+ );
+ }
+#else
+ span_constexpr_exp span( pointer first, pointer last )
+ : data_( first )
+ , size_( to_size( last - first ) )
+ {
+ span_EXPECTS(
+ last - first >= 0
+ );
+ }
+#endif
+
+ template< std::size_t N
+ span_REQUIRES_T((
+ (Extent == dynamic_extent || Extent == static_cast<extent_t>(N))
+ && std::is_convertible< value_type(*)[], element_type(*)[] >::value
+ ))
+ >
+ span_constexpr span( element_type ( &arr )[ N ] ) span_noexcept
+ : data_( span_ADDRESSOF( arr[0] ) )
+ , size_( N )
+ {}
+
+#if span_HAVE( ARRAY )
+
+ template< std::size_t N
+ span_REQUIRES_T((
+ (Extent == dynamic_extent || Extent == static_cast<extent_t>(N))
+ && std::is_convertible< value_type(*)[], element_type(*)[] >::value
+ ))
+ >
+# if span_FEATURE( CONSTRUCTION_FROM_STDARRAY_ELEMENT_TYPE )
+ span_constexpr span( std::array< element_type, N > & arr ) span_noexcept
+# else
+ span_constexpr span( std::array< value_type, N > & arr ) span_noexcept
+# endif
+ : data_( arr.data() )
+ , size_( to_size( arr.size() ) )
+ {}
+
+ template< std::size_t N
+# if span_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+ span_REQUIRES_T((
+ (Extent == dynamic_extent || Extent == static_cast<extent_t>(N))
+ && std::is_convertible< value_type(*)[], element_type(*)[] >::value
+ ))
+# endif
+ >
+ span_constexpr span( std::array< value_type, N> const & arr ) span_noexcept
+ : data_( arr.data() )
+ , size_( to_size( arr.size() ) )
+ {}
+
+#endif // span_HAVE( ARRAY )
+
+#if span_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+ template< class Container
+ span_REQUIRES_T((
+ detail::is_compatible_container< Container, element_type >::value
+ ))
+ >
+ span_constexpr span( Container & cont )
+ : data_( std17::data( cont ) )
+ , size_( to_size( std17::size( cont ) ) )
+ {}
+
+ template< class Container
+ span_REQUIRES_T((
+ std::is_const< element_type >::value
+ && detail::is_compatible_container< Container, element_type >::value
+ ))
+ >
+ span_constexpr span( Container const & cont )
+ : data_( std17::data( cont ) )
+ , size_( to_size( std17::size( cont ) ) )
+ {}
+
+#endif // span_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+
+#if span_FEATURE( WITH_CONTAINER )
+
+ template< class Container >
+ span_constexpr span( with_container_t, Container & cont )
+ : data_( cont.size() == 0 ? span_nullptr : span_ADDRESSOF( cont[0] ) )
+ , size_( to_size( cont.size() ) )
+ {}
+
+ template< class Container >
+ span_constexpr span( with_container_t, Container const & cont )
+ : data_( cont.size() == 0 ? span_nullptr : const_cast<pointer>( span_ADDRESSOF( cont[0] ) ) )
+ , size_( to_size( cont.size() ) )
+ {}
+#endif
+
+#if span_FEATURE( WITH_INITIALIZER_LIST_P2447 ) && span_HAVE( INITIALIZER_LIST )
+
+ // constexpr explicit(extent != dynamic_extent) span(std::initializer_list<value_type> il) noexcept;
+
+#if !span_BETWEEN( span_COMPILER_MSVC_VERSION, 120, 130 )
+
+ template< extent_t U = Extent
+ span_REQUIRES_T((
+ U != dynamic_extent
+ ))
+ >
+#if span_COMPILER_GNUC_VERSION >= 900 // prevent GCC's "-Winit-list-lifetime"
+ span_constexpr14 explicit span( std::initializer_list<value_type> il ) span_noexcept
+ {
+ data_ = il.begin();
+ size_ = il.size();
+ }
+#else
+ span_constexpr explicit span( std::initializer_list<value_type> il ) span_noexcept
+ : data_( il.begin() )
+ , size_( il.size() )
+ {}
+#endif
+
+#endif // MSVC 120 (VS2013)
+
+ template< extent_t U = Extent
+ span_REQUIRES_T((
+ U == dynamic_extent
+ ))
+ >
+#if span_COMPILER_GNUC_VERSION >= 900 // prevent GCC's "-Winit-list-lifetime"
+ span_constexpr14 /*explicit*/ span( std::initializer_list<value_type> il ) span_noexcept
+ {
+ data_ = il.begin();
+ size_ = il.size();
+ }
+#else
+ span_constexpr /*explicit*/ span( std::initializer_list<value_type> il ) span_noexcept
+ : data_( il.begin() )
+ , size_( il.size() )
+ {}
+#endif
+
+#endif // P2447
+
+#if span_HAVE( IS_DEFAULT )
+ span_constexpr span( span const & other ) span_noexcept = default;
+
+ ~span() span_noexcept = default;
+
+ span_constexpr14 span & operator=( span const & other ) span_noexcept = default;
+#else
+ span_constexpr span( span const & other ) span_noexcept
+ : data_( other.data_ )
+ , size_( other.size_ )
+ {}
+
+ ~span() span_noexcept
+ {}
+
+ span_constexpr14 span & operator=( span const & other ) span_noexcept
+ {
+ data_ = other.data_;
+ size_ = other.size_;
+
+ return *this;
+ }
+#endif
+
+ template< class OtherElementType, extent_type OtherExtent
+ span_REQUIRES_T((
+ (Extent == dynamic_extent || OtherExtent == dynamic_extent || Extent == OtherExtent)
+ && std::is_convertible<OtherElementType(*)[], element_type(*)[]>::value
+ ))
+ >
+ span_constexpr_exp span( span<OtherElementType, OtherExtent> const & other ) span_noexcept
+ : data_( other.data() )
+ , size_( other.size() )
+ {
+ span_EXPECTS( OtherExtent == dynamic_extent || other.size() == to_size(OtherExtent) );
+ }
+
+ // 26.7.3.3 Subviews [span.sub]
+
+ template< extent_type Count >
+ span_constexpr_exp span< element_type, Count >
+ first() const
+ {
+ span_EXPECTS( detail::is_positive( Count ) && Count <= size() );
+
+ return span< element_type, Count >( data(), Count );
+ }
+
+ template< extent_type Count >
+ span_constexpr_exp span< element_type, Count >
+ last() const
+ {
+ span_EXPECTS( detail::is_positive( Count ) && Count <= size() );
+
+ return span< element_type, Count >( data() + (size() - Count), Count );
+ }
+
+#if span_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+ template< size_type Offset, extent_type Count = dynamic_extent >
+#else
+ template< size_type Offset, extent_type Count /*= dynamic_extent*/ >
+#endif
+ span_constexpr_exp span< element_type, Count >
+ subspan() const
+ {
+ span_EXPECTS(
+ ( detail::is_positive( Offset ) && Offset <= size() ) &&
+ ( Count == dynamic_extent || (detail::is_positive( Count ) && Count + Offset <= size()) )
+ );
+
+ return span< element_type, Count >(
+ data() + Offset, Count != dynamic_extent ? Count : (Extent != dynamic_extent ? Extent - Offset : size() - Offset) );
+ }
+
+ span_constexpr_exp span< element_type, dynamic_extent >
+ first( size_type count ) const
+ {
+ span_EXPECTS( detail::is_positive( count ) && count <= size() );
+
+ return span< element_type, dynamic_extent >( data(), count );
+ }
+
+ span_constexpr_exp span< element_type, dynamic_extent >
+ last( size_type count ) const
+ {
+ span_EXPECTS( detail::is_positive( count ) && count <= size() );
+
+ return span< element_type, dynamic_extent >( data() + ( size() - count ), count );
+ }
+
+ span_constexpr_exp span< element_type, dynamic_extent >
+ subspan( size_type offset, size_type count = static_cast<size_type>(dynamic_extent) ) const
+ {
+ span_EXPECTS(
+ ( ( detail::is_positive( offset ) && offset <= size() ) ) &&
+ ( count == static_cast<size_type>(dynamic_extent) || ( detail::is_positive( count ) && offset + count <= size() ) )
+ );
+
+ return span< element_type, dynamic_extent >(
+ data() + offset, count == static_cast<size_type>(dynamic_extent) ? size() - offset : count );
+ }
+
+ // 26.7.3.4 Observers [span.obs]
+
+ span_constexpr size_type size() const span_noexcept
+ {
+ return size_;
+ }
+
+ span_constexpr std::ptrdiff_t ssize() const span_noexcept
+ {
+ return static_cast<std::ptrdiff_t>( size_ );
+ }
+
+ span_constexpr size_type size_bytes() const span_noexcept
+ {
+ return size() * to_size( sizeof( element_type ) );
+ }
+
+ span_nodiscard span_constexpr bool empty() const span_noexcept
+ {
+ return size() == 0;
+ }
+
+ // 26.7.3.5 Element access [span.elem]
+
+ span_constexpr_exp reference operator[]( size_type idx ) const
+ {
+ span_EXPECTS( detail::is_positive( idx ) && idx < size() );
+
+ return *( data() + idx );
+ }
+
+#if span_FEATURE( MEMBER_CALL_OPERATOR )
+ span_deprecated("replace operator() with operator[]")
+
+ span_constexpr_exp reference operator()( size_type idx ) const
+ {
+ span_EXPECTS( detail::is_positive( idx ) && idx < size() );
+
+ return *( data() + idx );
+ }
+#endif
+
+#if span_FEATURE( MEMBER_AT )
+ span_constexpr14 reference at( size_type idx ) const
+ {
+#if span_CONFIG( NO_EXCEPTIONS )
+ return this->operator[]( idx );
+#else
+ if ( !detail::is_positive( idx ) || size() <= idx )
+ {
+ detail::throw_out_of_range( idx, size() );
+ }
+ return *( data() + idx );
+#endif
+ }
+#endif
+
+ span_constexpr pointer data() const span_noexcept
+ {
+ return data_;
+ }
+
+#if span_FEATURE( MEMBER_BACK_FRONT )
+
+ span_constexpr_exp reference front() const span_noexcept
+ {
+ span_EXPECTS( ! empty() );
+
+ return *data();
+ }
+
+ span_constexpr_exp reference back() const span_noexcept
+ {
+ span_EXPECTS( ! empty() );
+
+ return *( data() + size() - 1 );
+ }
+
+#endif
+
+ // xx.x.x.x Modifiers [span.modifiers]
+
+#if span_FEATURE( MEMBER_SWAP )
+
+ span_constexpr14 void swap( span & other ) span_noexcept
+ {
+ using std::swap;
+ swap( data_, other.data_ );
+ swap( size_, other.size_ );
+ }
+#endif
+
+ // 26.7.3.6 Iterator support [span.iterators]
+
+ span_constexpr iterator begin() const span_noexcept
+ {
+#if span_CPP11_OR_GREATER
+ return { data() };
+#else
+ return iterator( data() );
+#endif
+ }
+
+ span_constexpr iterator end() const span_noexcept
+ {
+#if span_CPP11_OR_GREATER
+ return { data() + size() };
+#else
+ return iterator( data() + size() );
+#endif
+ }
+
+ span_constexpr const_iterator cbegin() const span_noexcept
+ {
+#if span_CPP11_OR_GREATER
+ return { data() };
+#else
+ return const_iterator( data() );
+#endif
+ }
+
+ span_constexpr const_iterator cend() const span_noexcept
+ {
+#if span_CPP11_OR_GREATER
+ return { data() + size() };
+#else
+ return const_iterator( data() + size() );
+#endif
+ }
+
+ span_constexpr reverse_iterator rbegin() const span_noexcept
+ {
+ return reverse_iterator( end() );
+ }
+
+ span_constexpr reverse_iterator rend() const span_noexcept
+ {
+ return reverse_iterator( begin() );
+ }
+
+ span_constexpr const_reverse_iterator crbegin() const span_noexcept
+ {
+ return const_reverse_iterator ( cend() );
+ }
+
+ span_constexpr const_reverse_iterator crend() const span_noexcept
+ {
+ return const_reverse_iterator( cbegin() );
+ }
+
+private:
+
+ // Note: C++20 has std::pointer_traits<Ptr>::to_address( it );
+
+#if span_HAVE( ITERATOR_CTOR )
+ static inline span_constexpr pointer to_address( std::nullptr_t ) span_noexcept
+ {
+ return nullptr;
+ }
+
+ template< typename U >
+ static inline span_constexpr U * to_address( U * p ) span_noexcept
+ {
+ return p;
+ }
+
+ template< typename Ptr
+ span_REQUIRES_T(( ! std::is_pointer<Ptr>::value ))
+ >
+ static inline span_constexpr pointer to_address( Ptr const & it ) span_noexcept
+ {
+ return to_address( it.operator->() );
+ }
+#endif // span_HAVE( ITERATOR_CTOR )
+
+private:
+ pointer data_;
+ size_type size_;
+};
+
+// class template argument deduction guides:
+
+#if span_HAVE( DEDUCTION_GUIDES )
+
+template< class T, size_t N >
+span( T (&)[N] ) -> span<T, static_cast<extent_t>(N)>;
+
+template< class T, size_t N >
+span( std::array<T, N> & ) -> span<T, static_cast<extent_t>(N)>;
+
+template< class T, size_t N >
+span( std::array<T, N> const & ) -> span<const T, static_cast<extent_t>(N)>;
+
+#if span_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+
+template< class Container >
+span( Container& ) -> span<typename Container::value_type>;
+
+template< class Container >
+span( Container const & ) -> span<const typename Container::value_type>;
+
+#endif
+
+// iterator: constraints: It satisfies contiguous_iterator.
+
+template< class It, class EndOrSize >
+span( It, EndOrSize ) -> span< typename std11::remove_reference< typename std20::iter_reference_t<It> >::type >;
+
+#endif // span_HAVE( DEDUCTION_GUIDES )
+
+// 26.7.3.7 Comparison operators [span.comparison]
+
+#if span_FEATURE( COMPARISON )
+#if span_FEATURE( SAME )
+
+template< class T1, extent_t E1, class T2, extent_t E2 >
+inline span_constexpr bool same( span<T1,E1> const & l, span<T2,E2> const & r ) span_noexcept
+{
+ return std11::is_same<T1, T2>::value
+ && l.size() == r.size()
+ && static_cast<void const*>( l.data() ) == r.data();
+}
+
+#endif
+
+template< class T1, extent_t E1, class T2, extent_t E2 >
+inline span_constexpr bool operator==( span<T1,E1> const & l, span<T2,E2> const & r )
+{
+ return
+#if span_FEATURE( SAME )
+ same( l, r ) ||
+#endif
+ ( l.size() == r.size() && std::equal( l.begin(), l.end(), r.begin() ) );
+}
+
+template< class T1, extent_t E1, class T2, extent_t E2 >
+inline span_constexpr bool operator<( span<T1,E1> const & l, span<T2,E2> const & r )
+{
+ return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+
+template< class T1, extent_t E1, class T2, extent_t E2 >
+inline span_constexpr bool operator!=( span<T1,E1> const & l, span<T2,E2> const & r )
+{
+ return !( l == r );
+}
+
+template< class T1, extent_t E1, class T2, extent_t E2 >
+inline span_constexpr bool operator<=( span<T1,E1> const & l, span<T2,E2> const & r )
+{
+ return !( r < l );
+}
+
+template< class T1, extent_t E1, class T2, extent_t E2 >
+inline span_constexpr bool operator>( span<T1,E1> const & l, span<T2,E2> const & r )
+{
+ return ( r < l );
+}
+
+template< class T1, extent_t E1, class T2, extent_t E2 >
+inline span_constexpr bool operator>=( span<T1,E1> const & l, span<T2,E2> const & r )
+{
+ return !( l < r );
+}
+
+#endif // span_FEATURE( COMPARISON )
+
+// 26.7.2.6 views of object representation [span.objectrep]
+
+#if span_HAVE( BYTE ) || span_HAVE( NONSTD_BYTE )
+
+// Avoid MSVC 14.1 (1910), VS 2017: warning C4307: '*': integral constant overflow:
+
+template< typename T, extent_t Extent >
+struct BytesExtent
+{
+#if span_CPP11_OR_GREATER
+ enum ET : extent_t { value = span_sizeof(T) * Extent };
+#else
+ enum ET { value = span_sizeof(T) * Extent };
+#endif
+};
+
+template< typename T >
+struct BytesExtent< T, dynamic_extent >
+{
+#if span_CPP11_OR_GREATER
+ enum ET : extent_t { value = dynamic_extent };
+#else
+ enum ET { value = dynamic_extent };
+#endif
+};
+
+template< class T, extent_t Extent >
+inline span_constexpr span< const std17::byte, BytesExtent<T, Extent>::value >
+as_bytes( span<T,Extent> spn ) span_noexcept
+{
+#if 0
+ return { reinterpret_cast< std17::byte const * >( spn.data() ), spn.size_bytes() };
+#else
+ return span< const std17::byte, BytesExtent<T, Extent>::value >(
+ reinterpret_cast< std17::byte const * >( spn.data() ), spn.size_bytes() ); // NOLINT
+#endif
+}
+
+template< class T, extent_t Extent >
+inline span_constexpr span< std17::byte, BytesExtent<T, Extent>::value >
+as_writable_bytes( span<T,Extent> spn ) span_noexcept
+{
+#if 0
+ return { reinterpret_cast< std17::byte * >( spn.data() ), spn.size_bytes() };
+#else
+ return span< std17::byte, BytesExtent<T, Extent>::value >(
+ reinterpret_cast< std17::byte * >( spn.data() ), spn.size_bytes() ); // NOLINT
+#endif
+}
+
+#endif // span_HAVE( BYTE ) || span_HAVE( NONSTD_BYTE )
+
+// 27.8 Container and view access [iterator.container]
+
+template< class T, extent_t Extent /*= dynamic_extent*/ >
+span_constexpr std::size_t size( span<T,Extent> const & spn )
+{
+ return static_cast<std::size_t>( spn.size() );
+}
+
+template< class T, extent_t Extent /*= dynamic_extent*/ >
+span_constexpr std::ptrdiff_t ssize( span<T,Extent> const & spn )
+{
+ return static_cast<std::ptrdiff_t>( spn.size() );
+}
+
+} // namespace span_lite
+} // namespace nonstd
+
+// make available in nonstd:
+
+namespace nonstd {
+
+using span_lite::dynamic_extent;
+
+using span_lite::span;
+
+using span_lite::with_container;
+
+#if span_FEATURE( COMPARISON )
+#if span_FEATURE( SAME )
+using span_lite::same;
+#endif
+
+using span_lite::operator==;
+using span_lite::operator!=;
+using span_lite::operator<;
+using span_lite::operator<=;
+using span_lite::operator>;
+using span_lite::operator>=;
+#endif
+
+#if span_HAVE( BYTE )
+using span_lite::as_bytes;
+using span_lite::as_writable_bytes;
+#endif
+
+using span_lite::size;
+using span_lite::ssize;
+
+} // namespace nonstd
+
+#endif // span_USES_STD_SPAN
+
+// make_span() [span-lite extension]:
+
+#if span_FEATURE( MAKE_SPAN ) || span_FEATURE( NON_MEMBER_FIRST_LAST_SUB_SPAN ) || span_FEATURE( NON_MEMBER_FIRST_LAST_SUB_CONTAINER )
+
+#if span_USES_STD_SPAN
+# define span_constexpr constexpr
+# define span_noexcept noexcept
+# define span_nullptr nullptr
+# ifndef span_CONFIG_EXTENT_TYPE
+# define span_CONFIG_EXTENT_TYPE std::size_t
+# endif
+using extent_t = span_CONFIG_EXTENT_TYPE;
+#endif // span_USES_STD_SPAN
+
+namespace nonstd {
+namespace span_lite {
+
+template< class T >
+inline span_constexpr span<T>
+make_span( T * ptr, size_t count ) span_noexcept
+{
+ return span<T>( ptr, count );
+}
+
+template< class T >
+inline span_constexpr span<T>
+make_span( T * first, T * last ) span_noexcept
+{
+ return span<T>( first, last );
+}
+
+template< class T, std::size_t N >
+inline span_constexpr span<T, static_cast<extent_t>(N)>
+make_span( T ( &arr )[ N ] ) span_noexcept
+{
+ return span<T, static_cast<extent_t>(N)>( &arr[ 0 ], N );
+}
+
+#if span_USES_STD_SPAN || span_HAVE( ARRAY )
+
+template< class T, std::size_t N >
+inline span_constexpr span<T, static_cast<extent_t>(N)>
+make_span( std::array< T, N > & arr ) span_noexcept
+{
+ return span<T, static_cast<extent_t>(N)>( arr );
+}
+
+template< class T, std::size_t N >
+inline span_constexpr span< const T, static_cast<extent_t>(N) >
+make_span( std::array< T, N > const & arr ) span_noexcept
+{
+ return span<const T, static_cast<extent_t>(N)>( arr );
+}
+
+#endif // span_HAVE( ARRAY )
+
+#if span_USES_STD_SPAN || span_HAVE( INITIALIZER_LIST )
+
+template< class T >
+inline span_constexpr span< const T >
+make_span( std::initializer_list<T> il ) span_noexcept
+{
+ return span<const T>( il.begin(), il.size() );
+}
+
+#endif // span_HAVE( INITIALIZER_LIST )
+
+#if span_USES_STD_SPAN
+
+template< class Container, class EP = decltype( std::data(std::declval<Container&>())) >
+inline span_constexpr auto
+make_span( Container & cont ) span_noexcept -> span< typename std::remove_pointer<EP>::type >
+{
+ return span< typename std::remove_pointer<EP>::type >( cont );
+}
+
+template< class Container, class EP = decltype( std::data(std::declval<Container&>())) >
+inline span_constexpr auto
+make_span( Container const & cont ) span_noexcept -> span< const typename std::remove_pointer<EP>::type >
+{
+ return span< const typename std::remove_pointer<EP>::type >( cont );
+}
+
+#elif span_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR ) && span_HAVE( AUTO )
+
+template< class Container, class EP = decltype( std17::data(std::declval<Container&>())) >
+inline span_constexpr auto
+make_span( Container & cont ) span_noexcept -> span< typename std::remove_pointer<EP>::type >
+{
+ return span< typename std::remove_pointer<EP>::type >( cont );
+}
+
+template< class Container, class EP = decltype( std17::data(std::declval<Container&>())) >
+inline span_constexpr auto
+make_span( Container const & cont ) span_noexcept -> span< const typename std::remove_pointer<EP>::type >
+{
+ return span< const typename std::remove_pointer<EP>::type >( cont );
+}
+
+#else
+
+template< class T >
+inline span_constexpr span<T>
+make_span( span<T> spn ) span_noexcept
+{
+ return spn;
+}
+
+template< class T, class Allocator >
+inline span_constexpr span<T>
+make_span( std::vector<T, Allocator> & cont ) span_noexcept
+{
+ return span<T>( with_container, cont );
+}
+
+template< class T, class Allocator >
+inline span_constexpr span<const T>
+make_span( std::vector<T, Allocator> const & cont ) span_noexcept
+{
+ return span<const T>( with_container, cont );
+}
+
+#endif // span_USES_STD_SPAN || ( ... )
+
+#if ! span_USES_STD_SPAN && span_FEATURE( WITH_CONTAINER )
+
+template< class Container >
+inline span_constexpr span<typename Container::value_type>
+make_span( with_container_t, Container & cont ) span_noexcept
+{
+ return span< typename Container::value_type >( with_container, cont );
+}
+
+template< class Container >
+inline span_constexpr span<const typename Container::value_type>
+make_span( with_container_t, Container const & cont ) span_noexcept
+{
+ return span< const typename Container::value_type >( with_container, cont );
+}
+
+#endif // ! span_USES_STD_SPAN && span_FEATURE( WITH_CONTAINER )
+
+// extensions: non-member views:
+// this feature implies the presence of make_span()
+
+#if span_FEATURE( NON_MEMBER_FIRST_LAST_SUB_SPAN )
+
+template< extent_t Count, class T, extent_t Extent >
+span_constexpr span<T, Count>
+first( span<T, Extent> spn )
+{
+ return spn.template first<Count>();
+}
+
+template< class T, extent_t Extent >
+span_constexpr span<T>
+first( span<T, Extent> spn, size_t count )
+{
+ return spn.first( count );
+}
+
+template< extent_t Count, class T, extent_t Extent >
+span_constexpr span<T, Count>
+last( span<T, Extent> spn )
+{
+ return spn.template last<Count>();
+}
+
+template< class T, extent_t Extent >
+span_constexpr span<T>
+last( span<T, Extent> spn, size_t count )
+{
+ return spn.last( count );
+}
+
+template< size_t Offset, extent_t Count, class T, extent_t Extent >
+span_constexpr span<T, Count>
+subspan( span<T, Extent> spn )
+{
+ return spn.template subspan<Offset, Count>();
+}
+
+template< class T, extent_t Extent >
+span_constexpr span<T>
+subspan( span<T, Extent> spn, size_t offset, extent_t count = dynamic_extent )
+{
+ return spn.subspan( offset, count );
+}
+
+#endif // span_FEATURE( NON_MEMBER_FIRST_LAST_SUB_SPAN )
+
+#if span_FEATURE( NON_MEMBER_FIRST_LAST_SUB_CONTAINER ) && span_CPP11_120
+
+template< extent_t Count, class T >
+span_constexpr auto
+first( T & t ) -> decltype( make_span(t).template first<Count>() )
+{
+ return make_span( t ).template first<Count>();
+}
+
+template< class T >
+span_constexpr auto
+first( T & t, size_t count ) -> decltype( make_span(t).first(count) )
+{
+ return make_span( t ).first( count );
+}
+
+template< extent_t Count, class T >
+span_constexpr auto
+last( T & t ) -> decltype( make_span(t).template last<Count>() )
+{
+ return make_span(t).template last<Count>();
+}
+
+template< class T >
+span_constexpr auto
+last( T & t, extent_t count ) -> decltype( make_span(t).last(count) )
+{
+ return make_span( t ).last( count );
+}
+
+template< size_t Offset, extent_t Count = dynamic_extent, class T >
+span_constexpr auto
+subspan( T & t ) -> decltype( make_span(t).template subspan<Offset, Count>() )
+{
+ return make_span( t ).template subspan<Offset, Count>();
+}
+
+template< class T >
+span_constexpr auto
+subspan( T & t, size_t offset, extent_t count = dynamic_extent ) -> decltype( make_span(t).subspan(offset, count) )
+{
+ return make_span( t ).subspan( offset, count );
+}
+
+#endif // span_FEATURE( NON_MEMBER_FIRST_LAST_SUB_CONTAINER )
+
+} // namespace span_lite
+} // namespace nonstd
+
+// make available in nonstd:
+
+namespace nonstd {
+using span_lite::make_span;
+
+#if span_FEATURE( NON_MEMBER_FIRST_LAST_SUB_SPAN ) || ( span_FEATURE( NON_MEMBER_FIRST_LAST_SUB_CONTAINER ) && span_CPP11_120 )
+
+using span_lite::first;
+using span_lite::last;
+using span_lite::subspan;
+
+#endif // span_FEATURE( NON_MEMBER_FIRST_LAST_SUB_[SPAN|CONTAINER] )
+
+} // namespace nonstd
+
+#endif // #if span_FEATURE_TO_STD( MAKE_SPAN )
+
+#if span_CPP11_OR_GREATER && span_FEATURE( BYTE_SPAN ) && ( span_HAVE( BYTE ) || span_HAVE( NONSTD_BYTE ) )
+
+namespace nonstd {
+namespace span_lite {
+
+template< class T >
+inline span_constexpr auto
+byte_span( T & t ) span_noexcept -> span< std17::byte, span_sizeof(T) >
+{
+ return span< std17::byte, span_sizeof(t) >( reinterpret_cast< std17::byte * >( &t ), span_sizeof(T) );
+}
+
+template< class T >
+inline span_constexpr auto
+byte_span( T const & t ) span_noexcept -> span< const std17::byte, span_sizeof(T) >
+{
+ return span< const std17::byte, span_sizeof(t) >( reinterpret_cast< std17::byte const * >( &t ), span_sizeof(T) );
+}
+
+} // namespace span_lite
+} // namespace nonstd
+
+// make available in nonstd:
+
+namespace nonstd {
+using span_lite::byte_span;
+} // namespace nonstd
+
+#endif // span_FEATURE( BYTE_SPAN )
+
+#if span_HAVE( STRUCT_BINDING )
+
+#if span_CPP14_OR_GREATER
+# include <tuple>
+#elif span_CPP11_OR_GREATER
+# include <tuple>
+namespace std {
+ template< std::size_t I, typename T >
+ using tuple_element_t = typename tuple_element<I, T>::type;
+}
+#else
+namespace std {
+ template< typename T >
+ class tuple_size; /*undefined*/
+
+ template< std::size_t I, typename T >
+ class tuple_element; /* undefined */
+}
+#endif // span_CPP14_OR_GREATER
+
+namespace std {
+
+// 26.7.X Tuple interface
+
+// std::tuple_size<>:
+
+template< typename ElementType, nonstd::span_lite::extent_t Extent >
+class tuple_size< nonstd::span<ElementType, Extent> > : public integral_constant<size_t, static_cast<size_t>(Extent)> {};
+
+// std::tuple_size<>: Leave undefined for dynamic extent:
+
+template< typename ElementType >
+class tuple_size< nonstd::span<ElementType, nonstd::dynamic_extent> >;
+
+// std::tuple_element<>:
+
+template< size_t I, typename ElementType, nonstd::span_lite::extent_t Extent >
+class tuple_element< I, nonstd::span<ElementType, Extent> >
+{
+public:
+#if span_HAVE( STATIC_ASSERT )
+ static_assert( Extent != nonstd::dynamic_extent && I < Extent, "tuple_element<I,span>: dynamic extent or index out of range" );
+#endif
+ using type = ElementType;
+};
+
+// std::get<>(), 2 variants:
+
+template< size_t I, typename ElementType, nonstd::span_lite::extent_t Extent >
+span_constexpr ElementType & get( nonstd::span<ElementType, Extent> & spn ) span_noexcept
+{
+#if span_HAVE( STATIC_ASSERT )
+ static_assert( Extent != nonstd::dynamic_extent && I < Extent, "get<>(span): dynamic extent or index out of range" );
+#endif
+ return spn[I];
+}
+
+template< size_t I, typename ElementType, nonstd::span_lite::extent_t Extent >
+span_constexpr ElementType const & get( nonstd::span<ElementType, Extent> const & spn ) span_noexcept
+{
+#if span_HAVE( STATIC_ASSERT )
+ static_assert( Extent != nonstd::dynamic_extent && I < Extent, "get<>(span): dynamic extent or index out of range" );
+#endif
+ return spn[I];
+}
+
+} // end namespace std
+
+#endif // span_HAVE( STRUCT_BINDING )
+
+#if ! span_USES_STD_SPAN
+span_RESTORE_WARNINGS()
+#endif // span_USES_STD_SPAN
+
+#endif // NONSTD_SPAN_HPP_INCLUDED
projects / babeltrace.git / commitdiff
