diff options
author | Neil MacIntosh <neilmac@microsoft.com> | 2016-08-02 15:14:11 -0700 |
---|---|---|
committer | GitHub <noreply@github.com> | 2016-08-02 15:14:11 -0700 |
commit | 7272552bf97cb5350226424f4024d4bd1a67928c (patch) | |
tree | b3aff4ec6e56a45cf76b94e11b9bddd66278dc42 | |
parent | 0535138459d0f78e39a2e558bc239f5727eaa13c (diff) | |
parent | 3836e124d8a80dfdaa009591bf34ee783de418e8 (diff) | |
download | platform_external_Microsoft-GSL-7272552bf97cb5350226424f4024d4bd1a67928c.tar.gz platform_external_Microsoft-GSL-7272552bf97cb5350226424f4024d4bd1a67928c.tar.bz2 platform_external_Microsoft-GSL-7272552bf97cb5350226424f4024d4bd1a67928c.zip |
Updating span<T> to reflect standardization. (PR #309)
Updating span<T> to reflect standardization.
-rw-r--r-- | .clang-format | 2 | ||||
-rw-r--r-- | README.md | 3 | ||||
-rw-r--r-- | include/gsl.h | 102 | ||||
-rw-r--r-- | include/gsl_assert.h | 68 | ||||
-rw-r--r-- | include/gsl_byte.h | 125 | ||||
-rw-r--r-- | include/gsl_util.h | 85 | ||||
-rw-r--r-- | include/multi_span.h | 2229 | ||||
-rw-r--r-- | include/span.h | 2325 | ||||
-rw-r--r-- | include/string_span.h | 657 | ||||
-rw-r--r-- | tests/CMakeLists.txt | 4 | ||||
-rw-r--r-- | tests/bounds_tests.cpp | 4 | ||||
-rw-r--r-- | tests/byte_tests.cpp | 93 | ||||
-rw-r--r-- | tests/multi_span_tests.cpp | 1679 | ||||
-rw-r--r-- | tests/span_tests.cpp | 1255 | ||||
-rw-r--r-- | tests/strided_span_tests.cpp | 96 | ||||
-rw-r--r-- | tests/string_span_tests.cpp | 10 | ||||
-rw-r--r-- | tests/utils_tests.cpp | 2 |
17 files changed, 5456 insertions, 3283 deletions
diff --git a/.clang-format b/.clang-format index b80d2c6..78696f5 100644 --- a/.clang-format +++ b/.clang-format @@ -16,6 +16,6 @@ AllowShortLoopsOnASingleLine: true PointerAlignment: Left AlignConsecutiveAssignments: false -AlignTrailingComments: false +AlignTrailingComments: true SpaceAfterCStyleCast: true @@ -14,6 +14,9 @@ it is simplest to just include [gsl.h](./include/gsl.h) and gain access to the e > NOTE: We encourage contributions that improve or refine any of the types in this library as well as ports to other platforms. Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more information about contributing. +# Project Code of Conduct +This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments. + # Quick Start ## Supported Platforms The test suite that exercises GSL has been built and passes successfully on the following platforms: diff --git a/include/gsl.h b/include/gsl.h index ad064ba..8e00a44 100644 --- a/include/gsl.h +++ b/include/gsl.h @@ -1,17 +1,17 @@ -/////////////////////////////////////////////////////////////////////////////// -// -// Copyright (c) 2015 Microsoft Corporation. All rights reserved. -// -// This code is licensed under the MIT License (MIT). -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. -// +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// /////////////////////////////////////////////////////////////////////////////// #pragma once @@ -21,36 +21,36 @@ #include "gsl_assert.h" // Ensures/Expects #include "gsl_util.h" // finally()/narrow()/narrow_cast()... -#include "span.h" // span, strided_span... -#include "string_span.h" // zstring, string_span, zstring_builder... +#include "multi_span.h" // multi_span, strided_span... +#include "span.h" // span +#include "string_span.h" // zstring, string_span, zstring_builder... #include <memory> #ifdef _MSC_VER // No MSVC does constexpr fully yet #pragma push_macro("constexpr") -#define constexpr +#define constexpr // MSVC 2013 workarounds #if _MSC_VER <= 1800 -// noexcept is not understood +// noexcept is not understood #pragma push_macro("noexcept") -#define noexcept +#define noexcept // turn off some misguided warnings #pragma warning(push) -#pragma warning(disable: 4351) // warns about newly introduced aggregate initializer behavior +#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior #endif // _MSC_VER <= 1800 #endif // _MSC_VER - namespace gsl { // -// GSL.owner: ownership pointers +// GSL.owner: ownership pointers // using std::unique_ptr; using std::shared_ptr; @@ -58,67 +58,74 @@ using std::shared_ptr; template <class T> using owner = T; - // // not_null // // Restricts a pointer or smart pointer to only hold non-null values. -// +// // Has zero size overhead over T. // -// If T is a pointer (i.e. T == U*) then -// - allow construction from U* or U& +// If T is a pointer (i.e. T == U*) then +// - allow construction from U* or U& // - disallow construction from nullptr_t // - disallow default construction // - ensure construction from U* fails with nullptr // - allow implicit conversion to U* // -template<class T> +template <class T> class not_null { static_assert(std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr."); + public: not_null(T t) : ptr_(t) { ensure_invariant(); } - not_null& operator=(const T& t) { ptr_ = t; ensure_invariant(); return *this; } + not_null& operator=(const T& t) + { + ptr_ = t; + ensure_invariant(); + return *this; + } - not_null(const not_null &other) = default; - not_null& operator=(const not_null &other) = default; + not_null(const not_null& other) = default; + not_null& operator=(const not_null& other) = default; template <typename U, typename Dummy = std::enable_if_t<std::is_convertible<U, T>::value>> - not_null(const not_null<U> &other) + not_null(const not_null<U>& other) { *this = other; } template <typename U, typename Dummy = std::enable_if_t<std::is_convertible<U, T>::value>> - not_null& operator=(const not_null<U> &other) + not_null& operator=(const not_null<U>& other) { ptr_ = other.get(); return *this; } - // prevents compilation when someone attempts to assign a nullptr + // prevents compilation when someone attempts to assign a nullptr not_null(std::nullptr_t) = delete; not_null(int) = delete; not_null<T>& operator=(std::nullptr_t) = delete; - not_null<T>& operator=(int) = delete; - - T get() const { + not_null<T>& operator=(int) = delete; + + T get() const + { #ifdef _MSC_VER __assume(ptr_ != nullptr); #endif return ptr_; } // the assume() should help the optimizer - operator T() const { return get(); } + operator T() const { return get(); } T operator->() const { return get(); } - bool operator==(const T& rhs) const { return ptr_ == rhs; } - bool operator!=(const T& rhs) const { return !(*this == rhs); } + bool operator==(const T& rhs) const { return ptr_ == rhs; } + bool operator!=(const T& rhs) const { return !(*this == rhs); } private: T ptr_; - // we assume that the compiler can hoist/prove away most of the checks inlined from this function + // we assume that the compiler can hoist/prove away most of the checks inlined from this + // function // if not, we could make them optional via conditional compilation void ensure_invariant() const { Expects(ptr_ != nullptr); } @@ -138,14 +145,11 @@ private: namespace std { - template<class T> - struct hash<gsl::not_null<T>> - { - size_t operator()(const gsl::not_null<T> & value) const - { - return hash<T>{}(value); - } - }; +template <class T> +struct hash<gsl::not_null<T>> +{ + size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value); } +}; } // namespace std @@ -158,7 +162,7 @@ namespace std #undef noexcept #pragma pop_macro("noexcept") - + #pragma warning(pop) #endif // _MSC_VER <= 1800 diff --git a/include/gsl_assert.h b/include/gsl_assert.h index 51e8ab6..10de31a 100644 --- a/include/gsl_assert.h +++ b/include/gsl_assert.h @@ -1,17 +1,17 @@ -/////////////////////////////////////////////////////////////////////////////// -// -// Copyright (c) 2015 Microsoft Corporation. All rights reserved. -// -// This code is licensed under the MIT License (MIT). -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. -// +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// /////////////////////////////////////////////////////////////////////////////// #pragma once @@ -28,50 +28,50 @@ // // 1. GSL_TERMINATE_ON_CONTRACT_VIOLATION: std::terminate will be called (default) // 2. GSL_THROW_ON_CONTRACT_VIOLATION: a gsl::fail_fast exception will be thrown -// 3. GSL_UNENFORCED_ON_CONTRACT_VIOLATION: nothing happens +// 3. GSL_UNENFORCED_ON_CONTRACT_VIOLATION: nothing happens // -#if !(defined(GSL_THROW_ON_CONTRACT_VIOLATION) ^ defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION) ^ defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION)) -#define GSL_TERMINATE_ON_CONTRACT_VIOLATION +#if !(defined(GSL_THROW_ON_CONTRACT_VIOLATION) ^ defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION) ^ \ + defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION)) +#define GSL_TERMINATE_ON_CONTRACT_VIOLATION #endif - #define GSL_STRINGIFY_DETAIL(x) #x #define GSL_STRINGIFY(x) GSL_STRINGIFY_DETAIL(x) - // // GSL.assert: assertions // namespace gsl { -struct fail_fast : public std::runtime_error +struct fail_fast : public std::runtime_error { - explicit fail_fast(char const* const message) : std::runtime_error(message) {} + explicit fail_fast(char const* const message) : std::runtime_error(message) {} }; } #if defined(GSL_THROW_ON_CONTRACT_VIOLATION) -#define Expects(cond) if (!(cond)) \ - throw gsl::fail_fast("GSL: Precondition failure at " __FILE__ ": " GSL_STRINGIFY(__LINE__)); -#define Ensures(cond) if (!(cond)) \ - throw gsl::fail_fast("GSL: Postcondition failure at " __FILE__ ": " GSL_STRINGIFY(__LINE__)); - +#define Expects(cond) \ + if (!(cond)) \ + throw gsl::fail_fast("GSL: Precondition failure at " __FILE__ ": " GSL_STRINGIFY(__LINE__)); +#define Ensures(cond) \ + if (!(cond)) \ + throw gsl::fail_fast("GSL: Postcondition failure at " __FILE__ \ + ": " GSL_STRINGIFY(__LINE__)); #elif defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION) - -#define Expects(cond) if (!(cond)) std::terminate(); -#define Ensures(cond) if (!(cond)) std::terminate(); - +#define Expects(cond) \ + if (!(cond)) std::terminate(); +#define Ensures(cond) \ + if (!(cond)) std::terminate(); #elif defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION) -#define Expects(cond) -#define Ensures(cond) - -#endif +#define Expects(cond) +#define Ensures(cond) +#endif #endif // GSL_CONTRACTS_H diff --git a/include/gsl_byte.h b/include/gsl_byte.h new file mode 100644 index 0000000..5a9c327 --- /dev/null +++ b/include/gsl_byte.h @@ -0,0 +1,125 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_BYTE_H +#define GSL_BYTE_H + +#ifdef _MSC_VER + +// MSVC 2013 workarounds +#if _MSC_VER <= 1800 + +// constexpr is not understood +#pragma push_macro("constexpr") +#define constexpr + +// noexcept is not understood +#pragma push_macro("noexcept") +#define noexcept + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +namespace gsl +{ +// This is a simple definition for now that allows +// use of byte within span<> to be standards-compliant +enum class byte : unsigned char +{ +}; + +template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> +constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept +{ + return b = byte(static_cast<unsigned char>(b) << shift); +} + +template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> +constexpr byte operator<<(byte b, IntegerType shift) noexcept +{ + return byte(static_cast<unsigned char>(b) << shift); +} + +template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> +constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept +{ + return b = byte(static_cast<unsigned char>(b) >> shift); +} + +template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> +constexpr byte operator>>(byte b, IntegerType shift) noexcept +{ + return byte(static_cast<unsigned char>(b) >> shift); +} + +constexpr byte& operator|=(byte& l, byte r) noexcept +{ + return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r)); +} + +constexpr byte operator|(byte l, byte r) noexcept +{ + return byte(static_cast<unsigned char>(l) + static_cast<unsigned char>(r)); +} + +constexpr byte& operator&=(byte& l, byte r) noexcept +{ + return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r)); +} + +constexpr byte operator&(byte l, byte r) noexcept +{ + return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r)); +} + +constexpr byte& operator^=(byte& l, byte r) noexcept +{ + return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r)); +} + +constexpr byte operator^(byte l, byte r) noexcept +{ + return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r)); +} + +constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); } + +template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> +constexpr IntegerType to_integer(byte b) noexcept +{ + return {b}; +} + +} // namespace gsl + +#ifdef _MSC_VER + +#if _MSC_VER <= 1800 + +#undef constexpr +#pragma pop_macro("constexpr") + +#undef noexcept +#pragma pop_macro("noexcept") + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#endif // GSL_BYTE_H
\ No newline at end of file diff --git a/include/gsl_util.h b/include/gsl_util.h index b42b66a..92a795b 100644 --- a/include/gsl_util.h +++ b/include/gsl_util.h @@ -19,11 +19,11 @@ #ifndef GSL_UTIL_H #define GSL_UTIL_H -#include "gsl_assert.h" // Ensures/Expects +#include "gsl_assert.h" // Ensures/Expects #include <array> -#include <utility> -#include <type_traits> #include <exception> +#include <type_traits> +#include <utility> #ifdef _MSC_VER @@ -32,7 +32,7 @@ #define constexpr #pragma warning(push) -#pragma warning(disable: 4127) // conditional expression is constant +#pragma warning(disable : 4127) // conditional expression is constant // MSVC 2013 workarounds #if _MSC_VER <= 1800 @@ -42,13 +42,12 @@ // turn off some misguided warnings #pragma warning(push) -#pragma warning(disable: 4351) // warns about newly introduced aggregate initializer behavior +#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior #endif // _MSC_VER <= 1800 #endif // _MSC_VER - namespace gsl { // @@ -60,18 +59,20 @@ template <class F> class final_act { public: - explicit final_act(F f) noexcept - : f_(std::move(f)), invoke_(true) - {} + explicit final_act(F f) noexcept : f_(std::move(f)), invoke_(true) {} - final_act(final_act&& other) noexcept - : f_(std::move(other.f_)), invoke_(other.invoke_) - { other.invoke_ = false; } + final_act(final_act&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_) + { + other.invoke_ = false; + } final_act(const final_act&) = delete; final_act& operator=(const final_act&) = delete; - ~final_act() noexcept { if (invoke_) f_(); } + ~final_act() noexcept + { + if (invoke_) f_(); + } private: F f_; @@ -80,34 +81,43 @@ private: // finally() - convenience function to generate a final_act template <class F> -inline final_act<F> finally(const F &f) -noexcept { return final_act<F>(f); } +inline final_act<F> finally(const F& f) noexcept +{ + return final_act<F>(f); +} template <class F> -inline final_act<F> finally(F &&f) noexcept -{ return final_act<F>(std::forward<F>(f)); } +inline final_act<F> finally(F&& f) noexcept +{ + return final_act<F>(std::forward<F>(f)); +} // narrow_cast(): a searchable way to do narrowing casts of values -template<class T, class U> +template <class T, class U> inline constexpr T narrow_cast(U u) noexcept -{ return static_cast<T>(u); } +{ + return static_cast<T>(u); +} -struct narrowing_error : public std::exception {}; +struct narrowing_error : public std::exception +{ +}; namespace details { - template<class T, class U> - struct is_same_signedness : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value> - {}; + template <class T, class U> + struct is_same_signedness + : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value> + { + }; } // narrow() : a checked version of narrow_cast() that throws if the cast changed the value -template<class T, class U> +template <class T, class U> inline T narrow(U u) { T t = narrow_cast<T>(u); - if (static_cast<U>(t) != u) - throw narrowing_error(); + if (static_cast<U>(t) != u) throw narrowing_error(); if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{}))) throw narrowing_error(); return t; @@ -117,24 +127,35 @@ inline T narrow(U u) // at() - Bounds-checked way of accessing static arrays, std::array, std::vector // template <class T, size_t N> -constexpr T& at(T(&arr)[N], size_t index) -{ Expects(index < N); return arr[index]; } +constexpr T& at(T (&arr)[N], size_t index) +{ + Expects(index < N); + return arr[index]; +} template <class T, size_t N> constexpr T& at(std::array<T, N>& arr, size_t index) -{ Expects(index < N); return arr[index]; } +{ + Expects(index < N); + return arr[index]; +} template <class Cont> constexpr typename Cont::value_type& at(Cont& cont, size_t index) -{ Expects(index < cont.size()); return cont[index]; } +{ + Expects(index < cont.size()); + return cont[index]; +} template <class T> constexpr const T& at(std::initializer_list<T> cont, size_t index) -{ Expects(index < cont.size()); return *(cont.begin() + index); } +{ + Expects(index < cont.size()); + return *(cont.begin() + index); +} } // namespace gsl - #ifdef _MSC_VER #pragma warning(pop) diff --git a/include/multi_span.h b/include/multi_span.h new file mode 100644 index 0000000..a8a1af2 --- /dev/null +++ b/include/multi_span.h @@ -0,0 +1,2229 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_MULTI_SPAN_H +#define GSL_MULTI_SPAN_H + +#include "gsl_assert.h" +#include "gsl_byte.h" +#include "gsl_util.h" +#include <algorithm> +#include <array> +#include <cassert> +#include <cstddef> +#include <cstdint> +#include <functional> +#include <iterator> +#include <limits> +#include <new> +#include <numeric> +#include <stdexcept> +#include <type_traits> +#include <utility> + +#ifdef _MSC_VER + +// turn off some warnings that are noisy about our Expects statements +#pragma warning(push) +#pragma warning(disable : 4127) // conditional expression is constant + +// No MSVC does constexpr fully yet +#pragma push_macro("constexpr") +#define constexpr + +// VS 2013 workarounds +#if _MSC_VER <= 1800 + +#define GSL_MSVC_HAS_VARIADIC_CTOR_BUG +#define GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT + +// noexcept is not understood +#ifndef GSL_THROW_ON_CONTRACT_VIOLATION +#pragma push_macro("noexcept") +#define noexcept /* nothing */ +#endif + +// turn off some misguided warnings +#pragma warning(push) +#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior +#pragma warning(disable : 4512) // warns that assignment op could not be generated + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#ifdef GSL_THROW_ON_CONTRACT_VIOLATION + +#ifdef _MSC_VER +#pragma push_macro("noexcept") +#endif + +#define noexcept /* nothing */ + +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +namespace gsl +{ + +/* +** begin definitions of index and bounds +*/ +namespace details +{ + template <typename SizeType> + struct SizeTypeTraits + { + static const SizeType max_value = std::numeric_limits<SizeType>::max(); + }; + + template <typename... Ts> + class are_integral : public std::integral_constant<bool, true> + { + }; + + template <typename T, typename... Ts> + class are_integral<T, Ts...> + : public std::integral_constant<bool, + std::is_integral<T>::value && are_integral<Ts...>::value> + { + }; +} + +template <size_t Rank> +class index final +{ + static_assert(Rank > 0, "Rank must be greater than 0!"); + + template <size_t OtherRank> + friend class index; + +public: + static const size_t rank = Rank; + using value_type = std::ptrdiff_t; + using size_type = value_type; + using reference = std::add_lvalue_reference_t<value_type>; + using const_reference = std::add_lvalue_reference_t<std::add_const_t<value_type>>; + + constexpr index() noexcept {} + + constexpr index(const value_type (&values)[Rank]) noexcept + { + std::copy(values, values + Rank, elems); + } + +#ifdef GSL_MSVC_HAS_VARIADIC_CTOR_BUG + template < + typename T, typename... Ts, + typename = std::enable_if_t<((sizeof...(Ts) + 1) == Rank) && std::is_integral<T>::value && + details::are_integral<Ts...>::value>> + constexpr index(T t, Ts... ds) + : index({narrow_cast<value_type>(t), narrow_cast<value_type>(ds)...}) + { + } +#else + template <typename... Ts, typename = std::enable_if_t<(sizeof...(Ts) == Rank) && + details::are_integral<Ts...>::value>> + constexpr index(Ts... ds) noexcept : elems{narrow_cast<value_type>(ds)...} + { + } +#endif + + constexpr index(const index& other) noexcept = default; + + constexpr index& operator=(const index& rhs) noexcept = default; + + // Preconditions: component_idx < rank + constexpr reference operator[](size_t component_idx) + { + Expects(component_idx < Rank); // Component index must be less than rank + return elems[component_idx]; + } + + // Preconditions: component_idx < rank + constexpr const_reference operator[](size_t component_idx) const noexcept + { + Expects(component_idx < Rank); // Component index must be less than rank + return elems[component_idx]; + } + + constexpr bool operator==(const index& rhs) const noexcept + { + return std::equal(elems, elems + rank, rhs.elems); + } + + constexpr bool operator!=(const index& rhs) const noexcept { return !(this == rhs); } + + constexpr index operator+() const noexcept { return *this; } + + constexpr index operator-() const noexcept + { + index ret = *this; + std::transform(ret, ret + rank, ret, std::negate<value_type>{}); + return ret; + } + + constexpr index operator+(const index& rhs) const noexcept + { + index ret = *this; + ret += rhs; + return ret; + } + + constexpr index operator-(const index& rhs) const noexcept + { + index ret = *this; + ret -= rhs; + return ret; + } + + constexpr index& operator+=(const index& rhs) noexcept + { + std::transform(elems, elems + rank, rhs.elems, elems, std::plus<value_type>{}); + return *this; + } + + constexpr index& operator-=(const index& rhs) noexcept + { + std::transform(elems, elems + rank, rhs.elems, elems, std::minus<value_type>{}); + return *this; + } + + constexpr index operator*(value_type v) const noexcept + { + index ret = *this; + ret *= v; + return ret; + } + + constexpr index operator/(value_type v) const noexcept + { + index ret = *this; + ret /= v; + return ret; + } + + friend constexpr index operator*(value_type v, const index& rhs) noexcept { return rhs * v; } + + constexpr index& operator*=(value_type v) noexcept + { + std::transform(elems, elems + rank, elems, + [v](value_type x) { return std::multiplies<value_type>{}(x, v); }); + return *this; + } + + constexpr index& operator/=(value_type v) noexcept + { + std::transform(elems, elems + rank, elems, + [v](value_type x) { return std::divides<value_type>{}(x, v); }); + return *this; + } + +private: + value_type elems[Rank] = {}; +}; + +#ifndef _MSC_VER + +struct static_bounds_dynamic_range_t +{ + template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> + constexpr operator T() const noexcept + { + return narrow_cast<T>(-1); + } + + template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> + constexpr bool operator==(T other) const noexcept + { + return narrow_cast<T>(-1) == other; + } + + template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> + constexpr bool operator!=(T other) const noexcept + { + return narrow_cast<T>(-1) != other; + } +}; + +template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> +constexpr bool operator==(T left, static_bounds_dynamic_range_t right) noexcept +{ + return right == left; +} + +template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> +constexpr bool operator!=(T left, static_bounds_dynamic_range_t right) noexcept +{ + return right != left; +} + +constexpr static_bounds_dynamic_range_t dynamic_range{}; +#else +const std::ptrdiff_t dynamic_range = -1; +#endif + +struct generalized_mapping_tag +{ +}; +struct contiguous_mapping_tag : generalized_mapping_tag +{ +}; + +namespace details +{ + + template <std::ptrdiff_t Left, std::ptrdiff_t Right> + struct LessThan + { + static const bool value = Left < Right; + }; + + template <std::ptrdiff_t... Ranges> + struct BoundsRanges + { + using size_type = std::ptrdiff_t; + static const size_type Depth = 0; + static const size_type DynamicNum = 0; + static const size_type CurrentRange = 1; + static const size_type TotalSize = 1; + + // TODO : following signature is for work around VS bug + template <typename OtherRange> + BoundsRanges(const OtherRange&, bool /* firstLevel */) + { + } + + BoundsRanges(const BoundsRanges&) = default; + BoundsRanges& operator=(const BoundsRanges&) = default; + BoundsRanges(const std::ptrdiff_t* const) {} + BoundsRanges() = default; + + template <typename T, size_t Dim> + void serialize(T&) const + { + } + + template <typename T, size_t Dim> + size_type linearize(const T&) const + { + return 0; + } + + template <typename T, size_t Dim> + size_type contains(const T&) const + { + return -1; + } + + size_type elementNum(size_t) const noexcept { return 0; } + + size_type totalSize() const noexcept { return TotalSize; } + + bool operator==(const BoundsRanges&) const noexcept { return true; } + }; + + template <std::ptrdiff_t... RestRanges> + struct BoundsRanges<dynamic_range, RestRanges...> : BoundsRanges<RestRanges...> + { + using Base = BoundsRanges<RestRanges...>; + using size_type = std::ptrdiff_t; + static const size_t Depth = Base::Depth + 1; + static const size_t DynamicNum = Base::DynamicNum + 1; + static const size_type CurrentRange = dynamic_range; + static const size_type TotalSize = dynamic_range; + const size_type m_bound; + + BoundsRanges(const BoundsRanges&) = default; + + BoundsRanges(const std::ptrdiff_t* const arr) + : Base(arr + 1), m_bound(*arr * this->Base::totalSize()) + { + Expects(0 <= *arr); + } + + BoundsRanges() : m_bound(0) {} + + template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges> + BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other, + bool /* firstLevel */ = true) + : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false) + , m_bound(other.totalSize()) + { + } + + template <typename T, size_t Dim = 0> + void serialize(T& arr) const + { + arr[Dim] = elementNum(); + this->Base::template serialize<T, Dim + 1>(arr); + } + + template <typename T, size_t Dim = 0> + size_type linearize(const T& arr) const + { + const size_type index = this->Base::totalSize() * arr[Dim]; + Expects(index < m_bound); + return index + this->Base::template linearize<T, Dim + 1>(arr); + } + + template <typename T, size_t Dim = 0> + size_type contains(const T& arr) const + { + const ptrdiff_t last = this->Base::template contains<T, Dim + 1>(arr); + if (last == -1) return -1; + const ptrdiff_t cur = this->Base::totalSize() * arr[Dim]; + return cur < m_bound ? cur + last : -1; + } + + size_type totalSize() const noexcept { return m_bound; } + + size_type elementNum() const noexcept { return totalSize() / this->Base::totalSize(); } + + size_type elementNum(size_t dim) const noexcept + { + if (dim > 0) + return this->Base::elementNum(dim - 1); + else + return elementNum(); + } + + bool operator==(const BoundsRanges& rhs) const noexcept + { + return m_bound == rhs.m_bound && + static_cast<const Base&>(*this) == static_cast<const Base&>(rhs); + } + }; + + template <std::ptrdiff_t CurRange, std::ptrdiff_t... RestRanges> + struct BoundsRanges<CurRange, RestRanges...> : BoundsRanges<RestRanges...> + { + using Base = BoundsRanges<RestRanges...>; + using size_type = std::ptrdiff_t; + static const size_t Depth = Base::Depth + 1; + static const size_t DynamicNum = Base::DynamicNum; + static const size_type CurrentRange = CurRange; + static const size_type TotalSize = + Base::TotalSize == dynamic_range ? dynamic_range : CurrentRange * Base::TotalSize; + + BoundsRanges(const BoundsRanges&) = default; + + BoundsRanges(const std::ptrdiff_t* const arr) : Base(arr) {} + BoundsRanges() = default; + + template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges> + BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other, + bool firstLevel = true) + : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false) + { + (void) firstLevel; + } + + template <typename T, size_t Dim = 0> + void serialize(T& arr) const + { + arr[Dim] = elementNum(); + this->Base::template serialize<T, Dim + 1>(arr); + } + + template <typename T, size_t Dim = 0> + size_type linearize(const T& arr) const + { + Expects(arr[Dim] < CurrentRange); // Index is out of range + return this->Base::totalSize() * arr[Dim] + + this->Base::template linearize<T, Dim + 1>(arr); + } + + template <typename T, size_t Dim = 0> + size_type contains(const T& arr) const + { + if (arr[Dim] >= CurrentRange) return -1; + const size_type last = this->Base::template contains<T, Dim + 1>(arr); + if (last == -1) return -1; + return this->Base::totalSize() * arr[Dim] + last; + } + + size_type totalSize() const noexcept { return CurrentRange * this->Base::totalSize(); } + + size_type elementNum() const noexcept { return CurrentRange; } + + size_type elementNum(size_t dim) const noexcept + { + if (dim > 0) + return this->Base::elementNum(dim - 1); + else + return elementNum(); + } + + bool operator==(const BoundsRanges& rhs) const noexcept + { + return static_cast<const Base&>(*this) == static_cast<const Base&>(rhs); + } + }; + + template <typename SourceType, typename TargetType> + struct BoundsRangeConvertible + : public std::integral_constant<bool, (SourceType::TotalSize >= TargetType::TotalSize || + TargetType::TotalSize == dynamic_range || + SourceType::TotalSize == dynamic_range || + TargetType::TotalSize == 0)> + { + }; + + template <typename TypeChain> + struct TypeListIndexer + { + const TypeChain& obj_; + TypeListIndexer(const TypeChain& obj) : obj_(obj) {} + + template <size_t N> + const TypeChain& getObj(std::true_type) + { + return obj_; + } + + template <size_t N, typename MyChain = TypeChain, typename MyBase = typename MyChain::Base> + auto getObj(std::false_type) + -> decltype(TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>()) + { + return TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>(); + } + + template <size_t N> + auto get() -> decltype(getObj<N - 1>(std::integral_constant<bool, N == 0>())) + { + return getObj<N - 1>(std::integral_constant<bool, N == 0>()); + } + }; + + template <typename TypeChain> + TypeListIndexer<TypeChain> createTypeListIndexer(const TypeChain& obj) + { + return TypeListIndexer<TypeChain>(obj); + } + + template <size_t Rank, bool Enabled = (Rank > 1), + typename Ret = std::enable_if_t<Enabled, index<Rank - 1>>> + constexpr Ret shift_left(const index<Rank>& other) noexcept + { + Ret ret{}; + for (size_t i = 0; i < Rank - 1; ++i) { + ret[i] = other[i + 1]; + } + return ret; + } +} + +template <typename IndexType> +class bounds_iterator; + +template <std::ptrdiff_t... Ranges> +class static_bounds +{ +public: + static_bounds(const details::BoundsRanges<Ranges...>&) {} +}; + +template <std::ptrdiff_t FirstRange, std::ptrdiff_t... RestRanges> +class static_bounds<FirstRange, RestRanges...> +{ + using MyRanges = details::BoundsRanges<FirstRange, RestRanges...>; + + MyRanges m_ranges; + constexpr static_bounds(const MyRanges& range) : m_ranges(range) {} + + template <std::ptrdiff_t... OtherRanges> + friend class static_bounds; + +public: + static const size_t rank = MyRanges::Depth; + static const size_t dynamic_rank = MyRanges::DynamicNum; + static const std::ptrdiff_t static_size = MyRanges::TotalSize; + + using size_type = std::ptrdiff_t; + using index_type = index<rank>; + using const_index_type = std::add_const_t<index_type>; + using iterator = bounds_iterator<const_index_type>; + using const_iterator = bounds_iterator<const_index_type>; + using difference_type = std::ptrdiff_t; + using sliced_type = static_bounds<RestRanges...>; + using mapping_type = contiguous_mapping_tag; + + constexpr static_bounds(const static_bounds&) = default; + + template <typename SourceType, typename TargetType, size_t Rank> + struct BoundsRangeConvertible2; + + template <size_t Rank, typename SourceType, typename TargetType, + typename Ret = BoundsRangeConvertible2<typename SourceType::Base, + typename TargetType::Base, Rank>> + static auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type) -> Ret; + + template <size_t Rank, typename SourceType, typename TargetType> + static auto helpBoundsRangeConvertible(SourceType, TargetType, ...) -> std::false_type; + + template <typename SourceType, typename TargetType, size_t Rank> + struct BoundsRangeConvertible2 + : decltype(helpBoundsRangeConvertible<Rank - 1>( + SourceType(), TargetType(), + std::integral_constant<bool, + SourceType::Depth == TargetType::Depth && + (SourceType::CurrentRange == TargetType::CurrentRange || + TargetType::CurrentRange == dynamic_range || + SourceType::CurrentRange == dynamic_range)>())) + { + }; + + template <typename SourceType, typename TargetType> + struct BoundsRangeConvertible2<SourceType, TargetType, 0> : std::true_type + { + }; + + template <typename SourceType, typename TargetType, std::ptrdiff_t Rank = TargetType::Depth> + struct BoundsRangeConvertible + : decltype(helpBoundsRangeConvertible<Rank - 1>( + SourceType(), TargetType(), + std::integral_constant<bool, + SourceType::Depth == TargetType::Depth && + (!details::LessThan<SourceType::CurrentRange, + TargetType::CurrentRange>::value || + TargetType::CurrentRange == dynamic_range || + SourceType::CurrentRange == dynamic_range)>())) + { + }; + + template <typename SourceType, typename TargetType> + struct BoundsRangeConvertible<SourceType, TargetType, 0> : std::true_type + { + }; + + template <std::ptrdiff_t... Ranges, + typename = std::enable_if_t<details::BoundsRangeConvertible< + details::BoundsRanges<Ranges...>, + details::BoundsRanges<FirstRange, RestRanges...>>::value>> + constexpr static_bounds(const static_bounds<Ranges...>& other) : m_ranges(other.m_ranges) + { + Expects((MyRanges::DynamicNum == 0 && details::BoundsRanges<Ranges...>::DynamicNum == 0) || + MyRanges::DynamicNum > 0 || other.m_ranges.totalSize() >= m_ranges.totalSize()); + } + + constexpr static_bounds(std::initializer_list<size_type> il) + : m_ranges(static_cast<const std::ptrdiff_t*>(il.begin())) + { + // Size of the initializer list must match the rank of the array + Expects((MyRanges::DynamicNum == 0 && il.size() == 1 && *il.begin() == static_size) || + MyRanges::DynamicNum == il.size()); + // Size of the range must be less than the max element of the size type + Expects(m_ranges.totalSize() <= PTRDIFF_MAX); + } + + constexpr static_bounds() = default; + + constexpr static_bounds& operator=(const static_bounds& otherBounds) + { + new (&m_ranges) MyRanges(otherBounds.m_ranges); + return *this; + } + + constexpr sliced_type slice() const noexcept + { + return sliced_type{static_cast<const details::BoundsRanges<RestRanges...>&>(m_ranges)}; + } + + constexpr size_type stride() const noexcept { return rank > 1 ? slice().size() : 1; } + + constexpr size_type size() const noexcept { return m_ranges.totalSize(); } + + constexpr size_type total_size() const noexcept { return m_ranges.totalSize(); } + + constexpr size_type linearize(const index_type& idx) const { return m_ranges.linearize(idx); } + + constexpr bool contains(const index_type& idx) const noexcept + { + return m_ranges.contains(idx) != -1; + } + + constexpr size_type operator[](size_t index) const noexcept + { + return m_ranges.elementNum(index); + } + + template <size_t Dim = 0> + constexpr size_type extent() const noexcept + { + static_assert(Dim < rank, + "dimension should be less than rank (dimension count starts from 0)"); + return details::createTypeListIndexer(m_ranges).template get<Dim>().elementNum(); + } + + template <typename IntType> + constexpr size_type extent(IntType dim) const noexcept + { + static_assert(std::is_integral<IntType>::value, + "Dimension parameter must be supplied as an integral type."); + auto real_dim = narrow_cast<size_t>(dim); + Expects(real_dim < rank); + + return m_ranges.elementNum(real_dim); + } + + constexpr index_type index_bounds() const noexcept + { + size_type extents[rank] = {}; + m_ranges.serialize(extents); + return {extents}; + } + + template <std::ptrdiff_t... Ranges> + constexpr bool operator==(const static_bounds<Ranges...>& rhs) const noexcept + { + return this->size() == rhs.size(); + } + + template <std::ptrdiff_t... Ranges> + constexpr bool operator!=(const static_bounds<Ranges...>& rhs) const noexcept + { + return !(*this == rhs); + } + + constexpr const_iterator begin() const noexcept { return const_iterator(*this, index_type{}); } + + constexpr const_iterator end() const noexcept + { + return const_iterator(*this, this->index_bounds()); + } +}; + +template <size_t Rank> +class strided_bounds +{ + template <size_t OtherRank> + friend class strided_bounds; + +public: + static const size_t rank = Rank; + using value_type = std::ptrdiff_t; + using reference = std::add_lvalue_reference_t<value_type>; + using const_reference = std::add_const_t<reference>; + using size_type = value_type; + using difference_type = value_type; + using index_type = index<rank>; + using const_index_type = std::add_const_t<index_type>; + using iterator = bounds_iterator<const_index_type>; + using const_iterator = bounds_iterator<const_index_type>; + static const value_type dynamic_rank = rank; + static const value_type static_size = dynamic_range; + using sliced_type = std::conditional_t<rank != 0, strided_bounds<rank - 1>, void>; + using mapping_type = generalized_mapping_tag; + + constexpr strided_bounds(const strided_bounds&) noexcept = default; + + constexpr strided_bounds& operator=(const strided_bounds&) noexcept = default; + + constexpr strided_bounds(const value_type (&values)[rank], index_type strides) + : m_extents(values), m_strides(std::move(strides)) + { + } + + constexpr strided_bounds(const index_type& extents, const index_type& strides) noexcept + : m_extents(extents), + m_strides(strides) + { + } + + constexpr index_type strides() const noexcept { return m_strides; } + + constexpr size_type total_size() const noexcept + { + size_type ret = 0; + for (size_t i = 0; i < rank; ++i) { + ret += (m_extents[i] - 1) * m_strides[i]; + } + return ret + 1; + } + + constexpr size_type size() const noexcept + { + size_type ret = 1; + for (size_t i = 0; i < rank; ++i) { + ret *= m_extents[i]; + } + return ret; + } + + constexpr bool contains(const index_type& idx) const noexcept + { + for (size_t i = 0; i < rank; ++i) { + if (idx[i] < 0 || idx[i] >= m_extents[i]) return false; + } + return true; + } + + constexpr size_type linearize(const index_type& idx) const noexcept + { + size_type ret = 0; + for (size_t i = 0; i < rank; i++) { + Expects(idx[i] < m_extents[i]); // index is out of bounds of the array + ret += idx[i] * m_strides[i]; + } + return ret; + } + + constexpr size_type stride() const noexcept { return m_strides[0]; } + + template <bool Enabled = (rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>> + constexpr sliced_type slice() const + { + return {details::shift_left(m_extents), details::shift_left(m_strides)}; + } + + template <size_t Dim = 0> + constexpr size_type extent() const noexcept + { + static_assert(Dim < Rank, + "dimension should be less than rank (dimension count starts from 0)"); + return m_extents[Dim]; + } + + constexpr index_type index_bounds() const noexcept { return m_extents; } + constexpr const_iterator begin() const noexcept { return const_iterator{*this, index_type{}}; } + + constexpr const_iterator end() const noexcept { return const_iterator{*this, index_bounds()}; } + +private: + index_type m_extents; + index_type m_strides; +}; + +template <typename T> +struct is_bounds : std::integral_constant<bool, false> +{ +}; +template <std::ptrdiff_t... Ranges> +struct is_bounds<static_bounds<Ranges...>> : std::integral_constant<bool, true> +{ +}; +template <size_t Rank> +struct is_bounds<strided_bounds<Rank>> : std::integral_constant<bool, true> +{ +}; + +template <typename IndexType> +class bounds_iterator : public std::iterator<std::random_access_iterator_tag, IndexType> +{ +private: + using Base = std::iterator<std::random_access_iterator_tag, IndexType>; + +public: + static const size_t rank = IndexType::rank; + using typename Base::reference; + using typename Base::pointer; + using typename Base::difference_type; + using typename Base::value_type; + using index_type = value_type; + using index_size_type = typename IndexType::value_type; + template <typename Bounds> + explicit bounds_iterator(const Bounds& bnd, value_type curr) noexcept + : boundary_(bnd.index_bounds()), + curr_(std::move(curr)) + { + static_assert(is_bounds<Bounds>::value, "Bounds type must be provided"); + } + + constexpr reference operator*() const noexcept { return curr_; } + + constexpr pointer operator->() const noexcept { return &curr_; } + + constexpr bounds_iterator& operator++() noexcept + { + for (size_t i = rank; i-- > 0;) { + if (curr_[i] < boundary_[i] - 1) { + curr_[i]++; + return *this; + } + curr_[i] = 0; + } + // If we're here we've wrapped over - set to past-the-end. + curr_ = boundary_; + return *this; + } + + constexpr bounds_iterator operator++(int) noexcept + { + auto ret = *this; + ++(*this); + return ret; + } + + constexpr bounds_iterator& operator--() noexcept + { + if (!less(curr_, boundary_)) { + // if at the past-the-end, set to last element + for (size_t i = 0; i < rank; ++i) { + curr_[i] = boundary_[i] - 1; + } + return *this; + } + for (size_t i = rank; i-- > 0;) { + if (curr_[i] >= 1) { + curr_[i]--; + return *this; + } + curr_[i] = boundary_[i] - 1; + } + // If we're here the preconditions were violated + // "pre: there exists s such that r == ++s" + Expects(false); + return *this; + } + + constexpr bounds_iterator operator--(int) noexcept + { + auto ret = *this; + --(*this); + return ret; + } + + constexpr bounds_iterator operator+(difference_type n) const noexcept + { + bounds_iterator ret{*this}; + return ret += n; + } + + constexpr bounds_iterator& operator+=(difference_type n) noexcept + { + auto linear_idx = linearize(curr_) + n; + std::remove_const_t<value_type> stride = 0; + stride[rank - 1] = 1; + for (size_t i = rank - 1; i-- > 0;) { + stride[i] = stride[i + 1] * boundary_[i + 1]; + } + for (size_t i = 0; i < rank; ++i) { + curr_[i] = linear_idx / stride[i]; + linear_idx = linear_idx % stride[i]; + } + // index is out of bounds of the array + Expects(!less(curr_, index_type{}) && !less(boundary_, curr_)); + return *this; + } + + constexpr bounds_iterator operator-(difference_type n) const noexcept + { + bounds_iterator ret{*this}; + return ret -= n; + } + + constexpr bounds_iterator& operator-=(difference_type n) noexcept { return *this += -n; } + + constexpr difference_type operator-(const bounds_iterator& rhs) const noexcept + { + return linearize(curr_) - linearize(rhs.curr_); + } + + constexpr value_type operator[](difference_type n) const noexcept { return *(*this + n); } + + constexpr bool operator==(const bounds_iterator& rhs) const noexcept + { + return curr_ == rhs.curr_; + } + + constexpr bool operator!=(const bounds_iterator& rhs) const noexcept { return !(*this == rhs); } + + constexpr bool operator<(const bounds_iterator& rhs) const noexcept + { + return less(curr_, rhs.curr_); + } + + constexpr bool operator<=(const bounds_iterator& rhs) const noexcept { return !(rhs < *this); } + + constexpr bool operator>(const bounds_iterator& rhs) const noexcept { return rhs < *this; } + + constexpr bool operator>=(const bounds_iterator& rhs) const noexcept { return !(rhs > *this); } + + void swap(bounds_iterator& rhs) noexcept + { + std::swap(boundary_, rhs.boundary_); + std::swap(curr_, rhs.curr_); + } + +private: + constexpr bool less(index_type& one, index_type& other) const noexcept + { + for (size_t i = 0; i < rank; ++i) { + if (one[i] < other[i]) return true; + } + return false; + } + + constexpr index_size_type linearize(const value_type& idx) const noexcept + { + // TODO: Smarter impl. + // Check if past-the-end + index_size_type multiplier = 1; + index_size_type res = 0; + if (!less(idx, boundary_)) { + res = 1; + for (size_t i = rank; i-- > 0;) { + res += (idx[i] - 1) * multiplier; + multiplier *= boundary_[i]; + } + } + else + { + for (size_t i = rank; i-- > 0;) { + res += idx[i] * multiplier; + multiplier *= boundary_[i]; + } + } + return res; + } + + value_type boundary_; + std::remove_const_t<value_type> curr_; +}; + +template <typename IndexType> +bounds_iterator<IndexType> operator+(typename bounds_iterator<IndexType>::difference_type n, + const bounds_iterator<IndexType>& rhs) noexcept +{ + return rhs + n; +} + +namespace details +{ + template <typename Bounds> + constexpr std::enable_if_t< + std::is_same<typename Bounds::mapping_type, generalized_mapping_tag>::value, + typename Bounds::index_type> + make_stride(const Bounds& bnd) noexcept + { + return bnd.strides(); + } + + // Make a stride vector from bounds, assuming contiguous memory. + template <typename Bounds> + constexpr std::enable_if_t< + std::is_same<typename Bounds::mapping_type, contiguous_mapping_tag>::value, + typename Bounds::index_type> + make_stride(const Bounds& bnd) noexcept + { + auto extents = bnd.index_bounds(); + typename Bounds::size_type stride[Bounds::rank] = {}; + + stride[Bounds::rank - 1] = 1; + for (size_t i = 1; i < Bounds::rank; ++i) { + stride[Bounds::rank - i - 1] = stride[Bounds::rank - i] * extents[Bounds::rank - i]; + } + return {stride}; + } + + template <typename BoundsSrc, typename BoundsDest> + void verifyBoundsReshape(const BoundsSrc& src, const BoundsDest& dest) + { + static_assert(is_bounds<BoundsSrc>::value && is_bounds<BoundsDest>::value, + "The src type and dest type must be bounds"); + static_assert(std::is_same<typename BoundsSrc::mapping_type, contiguous_mapping_tag>::value, + "The source type must be a contiguous bounds"); + static_assert(BoundsDest::static_size == dynamic_range || + BoundsSrc::static_size == dynamic_range || + BoundsDest::static_size == BoundsSrc::static_size, + "The source bounds must have same size as dest bounds"); + Expects(src.size() == dest.size()); + } + +} // namespace details + +template <typename Span> +class contiguous_span_iterator; +template <typename Span> +class general_span_iterator; + +template <std::ptrdiff_t DimSize = dynamic_range> +struct dim +{ + static const std::ptrdiff_t value = DimSize; +}; +template <> +struct dim<dynamic_range> +{ + static const std::ptrdiff_t value = dynamic_range; + const std::ptrdiff_t dvalue; + dim(std::ptrdiff_t size) : dvalue(size) {} +}; + +template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range, + std::ptrdiff_t... RestDimensions> +class multi_span; + +template <typename ValueType, size_t Rank> +class strided_span; + +namespace details +{ + template <typename T, typename = std::true_type> + struct SpanTypeTraits + { + using value_type = T; + using size_type = size_t; + }; + + template <typename Traits> + struct SpanTypeTraits<Traits, typename std::is_reference<typename Traits::span_traits&>::type> + { + using value_type = typename Traits::span_traits::value_type; + using size_type = typename Traits::span_traits::size_type; + }; + + template <typename T, std::ptrdiff_t... Ranks> + struct SpanArrayTraits + { + using type = multi_span<T, Ranks...>; + using value_type = T; + using bounds_type = static_bounds<Ranks...>; + using pointer = T*; + using reference = T&; + }; + template <typename T, std::ptrdiff_t N, std::ptrdiff_t... Ranks> + struct SpanArrayTraits<T[N], Ranks...> : SpanArrayTraits<T, Ranks..., N> + { + }; + + template <typename BoundsType> + BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::true_type) // dynamic size + { + Expects(totalSize >= 0 && totalSize <= PTRDIFF_MAX); + return BoundsType{totalSize}; + } + template <typename BoundsType> + BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::false_type) // static size + { + Expects(BoundsType::static_size <= totalSize); + return {}; + } + template <typename BoundsType> + BoundsType newBoundsHelper(std::ptrdiff_t totalSize) + { + static_assert(BoundsType::dynamic_rank <= 1, "dynamic rank must less or equal to 1"); + return newBoundsHelperImpl<BoundsType>( + totalSize, std::integral_constant<bool, BoundsType::dynamic_rank == 1>()); + } + + struct Sep + { + }; + + template <typename T, typename... Args> + T static_as_multi_span_helper(Sep, Args... args) + { + return T{narrow_cast<typename T::size_type>(args)...}; + } + template <typename T, typename Arg, typename... Args> + std::enable_if_t< + !std::is_same<Arg, dim<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T> + static_as_multi_span_helper(Arg, Args... args) + { + return static_as_multi_span_helper<T>(args...); + } + template <typename T, typename... Args> + T static_as_multi_span_helper(dim<dynamic_range> val, Args... args) + { + return static_as_multi_span_helper<T>(args..., val.dvalue); + } + + template <typename... Dimensions> + struct static_as_multi_span_static_bounds_helper + { + using type = static_bounds<(Dimensions::value)...>; + }; + + template <typename T> + struct is_multi_span_oracle : std::false_type + { + }; + + template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> + struct is_multi_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>> + : std::true_type + { + }; + + template <typename ValueType, std::ptrdiff_t Rank> + struct is_multi_span_oracle<strided_span<ValueType, Rank>> : std::true_type + { + }; + + template <typename T> + struct is_multi_span : is_multi_span_oracle<std::remove_cv_t<T>> + { + }; +} + +template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> +class multi_span +{ + // TODO do we still need this? + template <typename ValueType2, std::ptrdiff_t FirstDimension2, + std::ptrdiff_t... RestDimensions2> + friend class multi_span; + +public: + using bounds_type = static_bounds<FirstDimension, RestDimensions...>; + static const size_t Rank = bounds_type::rank; + using size_type = typename bounds_type::size_type; + using index_type = typename bounds_type::index_type; + using value_type = ValueType; + using const_value_type = std::add_const_t<value_type>; + using pointer = std::add_pointer_t<value_type>; + using reference = std::add_lvalue_reference_t<value_type>; + using iterator = contiguous_span_iterator<multi_span>; + using const_span = multi_span<const_value_type, FirstDimension, RestDimensions...>; + using const_iterator = contiguous_span_iterator<const_span>; + using reverse_iterator = std::reverse_iterator<iterator>; + using const_reverse_iterator = std::reverse_iterator<const_iterator>; + using sliced_type = + std::conditional_t<Rank == 1, value_type, multi_span<value_type, RestDimensions...>>; + +private: + pointer data_; + bounds_type bounds_; + + friend iterator; + friend const_iterator; + +public: + // default constructor - same as constructing from nullptr_t + constexpr multi_span() noexcept : multi_span(nullptr, bounds_type{}) + { + static_assert(bounds_type::dynamic_rank != 0 || + (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0), + "Default construction of multi_span<T> only possible " + "for dynamic or fixed, zero-length spans."); + } + + // construct from nullptr - get an empty multi_span + constexpr multi_span(std::nullptr_t) noexcept : multi_span(nullptr, bounds_type{}) + { + static_assert(bounds_type::dynamic_rank != 0 || + (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0), + "nullptr_t construction of multi_span<T> only possible " + "for dynamic or fixed, zero-length spans."); + } + + // construct from nullptr with size of 0 (helps with template function calls) + template <class IntType, typename = std::enable_if_t<std::is_integral<IntType>::value>> + constexpr multi_span(std::nullptr_t, IntType size) noexcept : multi_span(nullptr, bounds_type{}) + { + static_assert(bounds_type::dynamic_rank != 0 || + (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0), + "nullptr_t construction of multi_span<T> only possible " + "for dynamic or fixed, zero-length spans."); + Expects(size == 0); + } + + // construct from a single element + constexpr multi_span(reference data) noexcept : multi_span(&data, bounds_type{1}) + { + static_assert(bounds_type::dynamic_rank > 0 || bounds_type::static_size == 0 || + bounds_type::static_size == 1, + "Construction from a single element only possible " + "for dynamic or fixed spans of length 0 or 1."); + } + + // prevent constructing from temporaries for single-elements + constexpr multi_span(value_type&&) = delete; + + // construct from pointer + length + constexpr multi_span(pointer ptr, size_type size) noexcept : multi_span(ptr, bounds_type{size}) + { + } + + // construct from pointer + length - multidimensional + constexpr multi_span(pointer data, bounds_type bounds) noexcept : data_(data), + bounds_(std::move(bounds)) + { + Expects((bounds_.size() > 0 && data != nullptr) || bounds_.size() == 0); + } + + // construct from begin,end pointer pair + template <typename Ptr, + typename = std::enable_if_t<std::is_convertible<Ptr, pointer>::value && + details::LessThan<bounds_type::dynamic_rank, 2>::value>> + constexpr multi_span(pointer begin, Ptr end) + : multi_span(begin, + details::newBoundsHelper<bounds_type>(static_cast<pointer>(end) - begin)) + { + Expects(begin != nullptr && end != nullptr && begin <= static_cast<pointer>(end)); + } + + // construct from n-dimensions static array + template <typename T, size_t N, typename Helper = details::SpanArrayTraits<T, N>> + constexpr multi_span(T (&arr)[N]) + : multi_span(reinterpret_cast<pointer>(arr), bounds_type{typename Helper::bounds_type{}}) + { + static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value, + "Cannot convert from source type to target multi_span type."); + static_assert(std::is_convertible<typename Helper::bounds_type, bounds_type>::value, + "Cannot construct a multi_span from an array with fewer elements."); + } + + // construct from n-dimensions dynamic array (e.g. new int[m][4]) + // (precedence will be lower than the 1-dimension pointer) + template <typename T, typename Helper = details::SpanArrayTraits<T, dynamic_range>> + constexpr multi_span(T* const& data, size_type size) + : multi_span(reinterpret_cast<pointer>(data), typename Helper::bounds_type{size}) + { + static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value, + "Cannot convert from source type to target multi_span type."); + } + + // construct from std::array + template <typename T, size_t N> + constexpr multi_span(std::array<T, N>& arr) + : multi_span(arr.data(), bounds_type{static_bounds<N>{}}) + { + static_assert( + std::is_convertible<T(*)[], typename std::remove_const_t<value_type>(*)[]>::value, + "Cannot convert from source type to target multi_span type."); + static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value, + "You cannot construct a multi_span from a std::array of smaller size."); + } + + // construct from const std::array + template <typename T, size_t N> + constexpr multi_span(const std::array<std::remove_const_t<value_type>, N>& arr) + : multi_span(arr.data(), static_bounds<N>()) + { + static_assert(std::is_convertible<T(*)[], std::remove_const_t<value_type>>::value, + "Cannot convert from source type to target multi_span type."); + static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value, + "You cannot construct a multi_span from a std::array of smaller size."); + } + + // prevent constructing from temporary std::array + template <typename T, size_t N> + constexpr multi_span(std::array<T, N>&& arr) = delete; + + // construct from containers + // future: could use contiguous_iterator_traits to identify only contiguous containers + // type-requirements: container must have .size(), operator[] which are value_type compatible + template <typename Cont, typename DataType = typename Cont::value_type, + typename = std::enable_if_t< + !details::is_multi_span<Cont>::value && + std::is_convertible<DataType (*)[], value_type (*)[]>::value && + std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), + *std::declval<Cont>().data())>, + DataType>::value>> + constexpr multi_span(Cont& cont) + : multi_span(static_cast<pointer>(cont.data()), + details::newBoundsHelper<bounds_type>(narrow_cast<size_type>(cont.size()))) + { + } + + // prevent constructing from temporary containers + template <typename Cont, typename DataType = typename Cont::value_type, + typename = std::enable_if_t< + !details::is_multi_span<Cont>::value && + std::is_convertible<DataType (*)[], value_type (*)[]>::value && + std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), + *std::declval<Cont>().data())>, + DataType>::value>> + explicit constexpr multi_span(Cont&& cont) = delete; + + // construct from a convertible multi_span + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename OtherBounds = static_bounds<OtherDimensions...>, + typename = std::enable_if_t<std::is_convertible<OtherValueType, ValueType>::value && + std::is_convertible<OtherBounds, bounds_type>::value>> + constexpr multi_span(multi_span<OtherValueType, OtherDimensions...> other) noexcept + : data_(other.data_), + bounds_(other.bounds_) + { + } + +// trivial copy and move +#ifndef GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT + constexpr multi_span(multi_span&&) = default; +#endif + constexpr multi_span(const multi_span&) = default; + +// trivial assignment +#ifndef GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT + constexpr multi_span& operator=(multi_span&&) = default; +#endif + constexpr multi_span& operator=(const multi_span&) = default; + + // first() - extract the first Count elements into a new multi_span + template <std::ptrdiff_t Count> + constexpr multi_span<ValueType, Count> first() const noexcept + { + static_assert(Count >= 0, "Count must be >= 0."); + static_assert(bounds_type::static_size == dynamic_range || + Count <= bounds_type::static_size, + "Count is out of bounds."); + + Expects(bounds_type::static_size != dynamic_range || Count <= this->size()); + return {this->data(), Count}; + } + + // first() - extract the first count elements into a new multi_span + constexpr multi_span<ValueType, dynamic_range> first(size_type count) const noexcept + { + Expects(count >= 0 && count <= this->size()); + return {this->data(), count}; + } + + // last() - extract the last Count elements into a new multi_span + template <std::ptrdiff_t Count> + constexpr multi_span<ValueType, Count> last() const noexcept + { + static_assert(Count >= 0, "Count must be >= 0."); + static_assert(bounds_type::static_size == dynamic_range || + Count <= bounds_type::static_size, + "Count is out of bounds."); + + Expects(bounds_type::static_size != dynamic_range || Count <= this->size()); + return {this->data() + this->size() - Count, Count}; + } + + // last() - extract the last count elements into a new multi_span + constexpr multi_span<ValueType, dynamic_range> last(size_type count) const noexcept + { + Expects(count >= 0 && count <= this->size()); + return {this->data() + this->size() - count, count}; + } + + // subspan() - create a subview of Count elements starting at Offset + template <std::ptrdiff_t Offset, std::ptrdiff_t Count> + constexpr multi_span<ValueType, Count> subspan() const noexcept + { + static_assert(Count >= 0, "Count must be >= 0."); + static_assert(Offset >= 0, "Offset must be >= 0."); + static_assert(bounds_type::static_size == dynamic_range || + ((Offset <= bounds_type::static_size) && + Count <= bounds_type::static_size - Offset), + "You must describe a sub-range within bounds of the multi_span."); + + Expects(bounds_type::static_size != dynamic_range || + (Offset <= this->size() && Count <= this->size() - Offset)); + return {this->data() + Offset, Count}; + } + + // subspan() - create a subview of count elements starting at offset + // supplying dynamic_range for count will consume all available elements from offset + constexpr multi_span<ValueType, dynamic_range> subspan(size_type offset, + size_type count = dynamic_range) const + noexcept + { + Expects((offset >= 0 && offset <= this->size()) && + (count == dynamic_range || (count <= this->size() - offset))); + return {this->data() + offset, count == dynamic_range ? this->length() - offset : count}; + } + + // section - creates a non-contiguous, strided multi_span from a contiguous one + constexpr strided_span<ValueType, Rank> section(index_type origin, index_type extents) const + noexcept + { + size_type size = this->bounds().total_size() - this->bounds().linearize(origin); + return {&this->operator[](origin), size, + strided_bounds<Rank>{extents, details::make_stride(bounds())}}; + } + + // length of the multi_span in elements + constexpr size_type size() const noexcept { return bounds_.size(); } + + // length of the multi_span in elements + constexpr size_type length() const noexcept { return this->size(); } + + // length of the multi_span in bytes + constexpr size_type size_bytes() const noexcept { return sizeof(value_type) * this->size(); } + + // length of the multi_span in bytes + constexpr size_type length_bytes() const noexcept { return this->size_bytes(); } + + constexpr bool empty() const noexcept { return this->size() == 0; } + + static constexpr std::size_t rank() { return Rank; } + + template <size_t Dim = 0> + constexpr size_type extent() const noexcept + { + static_assert(Dim < Rank, + "Dimension should be less than rank (dimension count starts from 0)."); + return bounds_.template extent<Dim>(); + } + + template <typename IntType> + constexpr size_type extent(IntType dim) const noexcept + { + return bounds_.extent(dim); + } + + constexpr bounds_type bounds() const noexcept { return bounds_; } + + constexpr pointer data() const noexcept { return data_; } + + template <typename FirstIndex> + constexpr reference operator()(FirstIndex index) + { + return this->operator[](narrow_cast<std::ptrdiff_t>(index)); + } + + template <typename FirstIndex, typename... OtherIndices> + constexpr reference operator()(FirstIndex index, OtherIndices... indices) + { + index_type idx = {narrow_cast<std::ptrdiff_t>(index), + narrow_cast<std::ptrdiff_t>(indices...)}; + return this->operator[](idx); + } + + constexpr reference operator[](const index_type& idx) const noexcept + { + return data_[bounds_.linearize(idx)]; + } + + template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>> + constexpr Ret operator[](size_type idx) const noexcept + { + Expects(idx < bounds_.size()); // index is out of bounds of the array + const size_type ridx = idx * bounds_.stride(); + + // index is out of bounds of the underlying data + Expects(ridx < bounds_.total_size()); + return Ret{data_ + ridx, bounds_.slice()}; + } + + constexpr iterator begin() const noexcept { return iterator{this, true}; } + + constexpr iterator end() const noexcept { return iterator{this, false}; } + + constexpr const_iterator cbegin() const noexcept + { + return const_iterator{reinterpret_cast<const const_span*>(this), true}; + } + + constexpr const_iterator cend() const noexcept + { + return const_iterator{reinterpret_cast<const const_span*>(this), false}; + } + + constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } + + constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } + + constexpr const_reverse_iterator crbegin() const noexcept + { + return const_reverse_iterator{cend()}; + } + + constexpr const_reverse_iterator crend() const noexcept + { + return const_reverse_iterator{cbegin()}; + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator==(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return bounds_.size() == other.bounds_.size() && + (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin())); + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator!=(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return !(*this == other); + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator<(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end()); + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator<=(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return !(other < *this); + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator>(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return (other < *this); + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator>=(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return !(*this < other); + } +}; + +// +// Free functions for manipulating spans +// + +// reshape a multi_span into a different dimensionality +// DimCount and Enabled here are workarounds for a bug in MSVC 2015 +template <typename SpanType, typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2), + bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>> +constexpr auto as_multi_span(SpanType s, Dimensions2... dims) + -> multi_span<typename SpanType::value_type, Dimensions2::value...> +{ + static_assert(details::is_multi_span<SpanType>::value, + "Variadic as_multi_span() is for reshaping existing spans."); + using BoundsType = + typename multi_span<typename SpanType::value_type, (Dimensions2::value)...>::bounds_type; + auto tobounds = details::static_as_multi_span_helper<BoundsType>(dims..., details::Sep{}); + details::verifyBoundsReshape(s.bounds(), tobounds); + return {s.data(), tobounds}; +} + +// convert a multi_span<T> to a multi_span<const byte> +template <typename U, std::ptrdiff_t... Dimensions> +multi_span<const byte, dynamic_range> as_bytes(multi_span<U, Dimensions...> s) noexcept +{ + static_assert(std::is_trivial<std::decay_t<U>>::value, + "The value_type of multi_span must be a trivial type."); + return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; +} + +// convert a multi_span<T> to a multi_span<byte> (a writeable byte multi_span) +// this is not currently a portable function that can be relied upon to work +// on all implementations. It should be considered an experimental extension +// to the standard GSL interface. +template <typename U, std::ptrdiff_t... Dimensions> +multi_span<byte> as_writeable_bytes(multi_span<U, Dimensions...> s) noexcept +{ + static_assert(std::is_trivial<std::decay_t<U>>::value, + "The value_type of multi_span must be a trivial type."); + return {reinterpret_cast<byte*>(s.data()), s.size_bytes()}; +} + +// convert a multi_span<const byte> to a multi_span<const T> +// this is not currently a portable function that can be relied upon to work +// on all implementations. It should be considered an experimental extension +// to the standard GSL interface. +template <typename U, std::ptrdiff_t... Dimensions> +constexpr auto as_multi_span(multi_span<const byte, Dimensions...> s) noexcept -> multi_span< + const U, static_cast<std::ptrdiff_t>( + multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range + ? (static_cast<size_t>( + multi_span<const byte, Dimensions...>::bounds_type::static_size) / + sizeof(U)) + : dynamic_range)> +{ + using ConstByteSpan = multi_span<const byte, Dimensions...>; + static_assert( + std::is_trivial<std::decay_t<U>>::value && + (ConstByteSpan::bounds_type::static_size == dynamic_range || + ConstByteSpan::bounds_type::static_size % narrow_cast<std::ptrdiff_t>(sizeof(U)) == 0), + "Target type must be a trivial type and its size must match the byte array size"); + + Expects((s.size_bytes() % sizeof(U)) == 0 && (s.size_bytes() / sizeof(U)) < PTRDIFF_MAX); + return {reinterpret_cast<const U*>(s.data()), + s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))}; +} + +// convert a multi_span<byte> to a multi_span<T> +// this is not currently a portable function that can be relied upon to work +// on all implementations. It should be considered an experimental extension +// to the standard GSL interface. +template <typename U, std::ptrdiff_t... Dimensions> +constexpr auto as_multi_span(multi_span<byte, Dimensions...> s) noexcept + -> multi_span<U, narrow_cast<std::ptrdiff_t>( + multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range + ? static_cast<std::size_t>( + multi_span<byte, Dimensions...>::bounds_type::static_size) / + sizeof(U) + : dynamic_range)> +{ + using ByteSpan = multi_span<byte, Dimensions...>; + static_assert( + std::is_trivial<std::decay_t<U>>::value && + (ByteSpan::bounds_type::static_size == dynamic_range || + ByteSpan::bounds_type::static_size % static_cast<std::size_t>(sizeof(U)) == 0), + "Target type must be a trivial type and its size must match the byte array size"); + + Expects((s.size_bytes() % sizeof(U)) == 0); + return {reinterpret_cast<U*>(s.data()), + s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))}; +} + +template <typename T, std::ptrdiff_t... Dimensions> +constexpr auto as_multi_span(T* const& ptr, dim<Dimensions>... args) + -> multi_span<std::remove_all_extents_t<T>, Dimensions...> +{ + return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr), + details::static_as_multi_span_helper<static_bounds<Dimensions...>>(args..., + details::Sep{})}; +} + +template <typename T> +constexpr auto as_multi_span(T* arr, std::ptrdiff_t len) -> + typename details::SpanArrayTraits<T, dynamic_range>::type +{ + return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len}; +} + +template <typename T, size_t N> +constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type +{ + return {arr}; +} + +template <typename T, size_t N> +constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>& arr) +{ + return {arr}; +} + +template <typename T, size_t N> +constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>&&) = delete; + +template <typename T, size_t N> +constexpr multi_span<T, N> as_multi_span(std::array<T, N>& arr) +{ + return {arr}; +} + +template <typename T> +constexpr multi_span<T, dynamic_range> as_multi_span(T* begin, T* end) +{ + return {begin, end}; +} + +template <typename Cont> +constexpr auto as_multi_span(Cont& arr) -> std::enable_if_t< + !details::is_multi_span<std::decay_t<Cont>>::value, + multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> +{ + Expects(arr.size() < PTRDIFF_MAX); + return {arr.data(), narrow_cast<std::ptrdiff_t>(arr.size())}; +} + +template <typename Cont> +constexpr auto as_multi_span(Cont&& arr) -> std::enable_if_t< + !details::is_multi_span<std::decay_t<Cont>>::value, + multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete; + +// from basic_string which doesn't have nonconst .data() member like other contiguous containers +template <typename CharT, typename Traits, typename Allocator> +constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str) + -> multi_span<CharT, dynamic_range> +{ + Expects(str.size() < PTRDIFF_MAX); + return {&str[0], narrow_cast<std::ptrdiff_t>(str.size())}; +} + +// strided_span is an extension that is not strictly part of the GSL at this time. +// It is kept here while the multidimensional interface is still being defined. +template <typename ValueType, size_t Rank> +class strided_span +{ +public: + using bounds_type = strided_bounds<Rank>; + using size_type = typename bounds_type::size_type; + using index_type = typename bounds_type::index_type; + using value_type = ValueType; + using const_value_type = std::add_const_t<value_type>; + using pointer = std::add_pointer_t<value_type>; + using reference = std::add_lvalue_reference_t<value_type>; + using iterator = general_span_iterator<strided_span>; + using const_strided_span = strided_span<const_value_type, Rank>; + using const_iterator = general_span_iterator<const_strided_span>; + using reverse_iterator = std::reverse_iterator<iterator>; + using const_reverse_iterator = std::reverse_iterator<const_iterator>; + using sliced_type = + std::conditional_t<Rank == 1, value_type, strided_span<value_type, Rank - 1>>; + +private: + pointer data_; + bounds_type bounds_; + + friend iterator; + friend const_iterator; + template <typename OtherValueType, size_t OtherRank> + friend class strided_span; + +public: + // from raw data + constexpr strided_span(pointer ptr, size_type size, bounds_type bounds) + : data_(ptr), bounds_(std::move(bounds)) + { + Expects((bounds_.size() > 0 && ptr != nullptr) || bounds_.size() == 0); + // Bounds cross data boundaries + Expects(this->bounds().total_size() <= size); + (void) size; + } + + // from static array of size N + template <size_type N> + constexpr strided_span(value_type (&values)[N], bounds_type bounds) + : strided_span(values, N, std::move(bounds)) + { + } + + // from array view + template <typename OtherValueType, std::ptrdiff_t... Dimensions, + bool Enabled1 = (sizeof...(Dimensions) == Rank), + bool Enabled2 = std::is_convertible<OtherValueType*, ValueType*>::value, + typename Dummy = std::enable_if_t<Enabled1 && Enabled2>> + constexpr strided_span(multi_span<OtherValueType, Dimensions...> av, bounds_type bounds) + : strided_span(av.data(), av.bounds().total_size(), std::move(bounds)) + { + } + + // convertible + template <typename OtherValueType, typename Dummy = std::enable_if_t<std::is_convertible< + OtherValueType (*)[], value_type (*)[]>::value>> + constexpr strided_span(const strided_span<OtherValueType, Rank>& other) + : data_(other.data_), bounds_(other.bounds_) + { + } + + // convert from bytes + template <typename OtherValueType> + constexpr strided_span< + typename std::enable_if<std::is_same<value_type, const byte>::value, OtherValueType>::type, + Rank> + as_strided_span() const + { + static_assert((sizeof(OtherValueType) >= sizeof(value_type)) && + (sizeof(OtherValueType) % sizeof(value_type) == 0), + "OtherValueType should have a size to contain a multiple of ValueTypes"); + auto d = narrow_cast<size_type>(sizeof(OtherValueType) / sizeof(value_type)); + + size_type size = this->bounds().total_size() / d; + return {const_cast<OtherValueType*>(reinterpret_cast<const OtherValueType*>(this->data())), + size, bounds_type{resize_extent(this->bounds().index_bounds(), d), + resize_stride(this->bounds().strides(), d)}}; + } + + constexpr strided_span section(index_type origin, index_type extents) const + { + size_type size = this->bounds().total_size() - this->bounds().linearize(origin); + return {&this->operator[](origin), size, + bounds_type{extents, details::make_stride(bounds())}}; + } + + constexpr reference operator[](const index_type& idx) const + { + return data_[bounds_.linearize(idx)]; + } + + template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>> + constexpr Ret operator[](size_type idx) const + { + Expects(idx < bounds_.size()); // index is out of bounds of the array + const size_type ridx = idx * bounds_.stride(); + + // index is out of bounds of the underlying data + Expects(ridx < bounds_.total_size()); + return {data_ + ridx, bounds_.slice().total_size(), bounds_.slice()}; + } + + constexpr bounds_type bounds() const noexcept { return bounds_; } + + template <size_t Dim = 0> + constexpr size_type extent() const noexcept + { + static_assert(Dim < Rank, + "dimension should be less than Rank (dimension count starts from 0)"); + return bounds_.template extent<Dim>(); + } + + constexpr size_type size() const noexcept { return bounds_.size(); } + + constexpr pointer data() const noexcept { return data_; } + + constexpr explicit operator bool() const noexcept { return data_ != nullptr; } + + constexpr iterator begin() const { return iterator{this, true}; } + + constexpr iterator end() const { return iterator{this, false}; } + + constexpr const_iterator cbegin() const + { + return const_iterator{reinterpret_cast<const const_strided_span*>(this), true}; + } + + constexpr const_iterator cend() const + { + return const_iterator{reinterpret_cast<const const_strided_span*>(this), false}; + } + + constexpr reverse_iterator rbegin() const { return reverse_iterator{end()}; } + + constexpr reverse_iterator rend() const { return reverse_iterator{begin()}; } + + constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator{cend()}; } + + constexpr const_reverse_iterator crend() const { return const_reverse_iterator{cbegin()}; } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator==(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return bounds_.size() == other.bounds_.size() && + (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin())); + } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator!=(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return !(*this == other); + } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator<(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end()); + } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator<=(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return !(other < *this); + } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator>(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return (other < *this); + } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator>=(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return !(*this < other); + } + +private: + static index_type resize_extent(const index_type& extent, std::ptrdiff_t d) + { + // The last dimension of the array needs to contain a multiple of new type elements + Expects(extent[Rank - 1] >= d && (extent[Rank - 1] % d == 0)); + + index_type ret = extent; + ret[Rank - 1] /= d; + + return ret; + } + + template <bool Enabled = (Rank == 1), typename Dummy = std::enable_if_t<Enabled>> + static index_type resize_stride(const index_type& strides, std::ptrdiff_t, void* = 0) + { + // Only strided arrays with regular strides can be resized + Expects(strides[Rank - 1] == 1); + + return strides; + } + + template <bool Enabled = (Rank > 1), typename Dummy = std::enable_if_t<Enabled>> + static index_type resize_stride(const index_type& strides, std::ptrdiff_t d) + { + // Only strided arrays with regular strides can be resized + Expects(strides[Rank - 1] == 1); + // The strides must have contiguous chunks of + // memory that can contain a multiple of new type elements + Expects(strides[Rank - 2] >= d && (strides[Rank - 2] % d == 0)); + + for (size_t i = Rank - 1; i > 0; --i) { + // Only strided arrays with regular strides can be resized + Expects((strides[i - 1] >= strides[i]) && (strides[i - 1] % strides[i] == 0)); + } + + index_type ret = strides / d; + ret[Rank - 1] = 1; + + return ret; + } +}; + +template <class Span> +class contiguous_span_iterator + : public std::iterator<std::random_access_iterator_tag, typename Span::value_type> +{ + using Base = std::iterator<std::random_access_iterator_tag, typename Span::value_type>; + +public: + using typename Base::reference; + using typename Base::pointer; + using typename Base::difference_type; + +private: + template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> + friend class multi_span; + + pointer data_; + const Span* m_validator; + void validateThis() const + { + // iterator is out of range of the array + Expects(data_ >= m_validator->data_ && data_ < m_validator->data_ + m_validator->size()); + } + contiguous_span_iterator(const Span* container, bool isbegin) + : data_(isbegin ? container->data_ : container->data_ + container->size()) + , m_validator(container) + { + } + +public: + reference operator*() const noexcept + { + validateThis(); + return *data_; + } + pointer operator->() const noexcept + { + validateThis(); + return data_; + } + contiguous_span_iterator& operator++() noexcept + { + ++data_; + return *this; + } + contiguous_span_iterator operator++(int) noexcept + { + auto ret = *this; + ++(*this); + return ret; + } + contiguous_span_iterator& operator--() noexcept + { + --data_; + return *this; + } + contiguous_span_iterator operator--(int) noexcept + { + auto ret = *this; + --(*this); + return ret; + } + contiguous_span_iterator operator+(difference_type n) const noexcept + { + contiguous_span_iterator ret{*this}; + return ret += n; + } + contiguous_span_iterator& operator+=(difference_type n) noexcept + { + data_ += n; + return *this; + } + contiguous_span_iterator operator-(difference_type n) const noexcept + { + contiguous_span_iterator ret{*this}; + return ret -= n; + } + contiguous_span_iterator& operator-=(difference_type n) noexcept { return *this += -n; } + difference_type operator-(const contiguous_span_iterator& rhs) const noexcept + { + Expects(m_validator == rhs.m_validator); + return data_ - rhs.data_; + } + reference operator[](difference_type n) const noexcept { return *(*this + n); } + bool operator==(const contiguous_span_iterator& rhs) const noexcept + { + Expects(m_validator == rhs.m_validator); + return data_ == rhs.data_; + } + bool operator!=(const contiguous_span_iterator& rhs) const noexcept { return !(*this == rhs); } + bool operator<(const contiguous_span_iterator& rhs) const noexcept + { + Expects(m_validator == rhs.m_validator); + return data_ < rhs.data_; + } + bool operator<=(const contiguous_span_iterator& rhs) const noexcept { return !(rhs < *this); } + bool operator>(const contiguous_span_iterator& rhs) const noexcept { return rhs < *this; } + bool operator>=(const contiguous_span_iterator& rhs) const noexcept { return !(rhs > *this); } + void swap(contiguous_span_iterator& rhs) noexcept + { + std::swap(data_, rhs.data_); + std::swap(m_validator, rhs.m_validator); + } +}; + +template <typename Span> +contiguous_span_iterator<Span> operator+(typename contiguous_span_iterator<Span>::difference_type n, + const contiguous_span_iterator<Span>& rhs) noexcept +{ + return rhs + n; +} + +template <typename Span> +class general_span_iterator + : public std::iterator<std::random_access_iterator_tag, typename Span::value_type> +{ + using Base = std::iterator<std::random_access_iterator_tag, typename Span::value_type>; + +public: + using typename Base::reference; + using typename Base::pointer; + using typename Base::difference_type; + using typename Base::value_type; + +private: + template <typename ValueType, size_t Rank> + friend class strided_span; + + const Span* m_container; + typename Span::bounds_type::iterator m_itr; + general_span_iterator(const Span* container, bool isbegin) + : m_container(container) + , m_itr(isbegin ? m_container->bounds().begin() : m_container->bounds().end()) + { + } + +public: + reference operator*() noexcept { return (*m_container)[*m_itr]; } + pointer operator->() noexcept { return &(*m_container)[*m_itr]; } + general_span_iterator& operator++() noexcept + { + ++m_itr; + return *this; + } + general_span_iterator operator++(int) noexcept + { + auto ret = *this; + ++(*this); + return ret; + } + general_span_iterator& operator--() noexcept + { + --m_itr; + return *this; + } + general_span_iterator operator--(int) noexcept + { + auto ret = *this; + --(*this); + return ret; + } + general_span_iterator operator+(difference_type n) const noexcept + { + general_span_iterator ret{*this}; + return ret += n; + } + general_span_iterator& operator+=(difference_type n) noexcept + { + m_itr += n; + return *this; + } + general_span_iterator operator-(difference_type n) const noexcept + { + general_span_iterator ret{*this}; + return ret -= n; + } + general_span_iterator& operator-=(difference_type n) noexcept { return *this += -n; } + difference_type operator-(const general_span_iterator& rhs) const noexcept + { + Expects(m_container == rhs.m_container); + return m_itr - rhs.m_itr; + } + value_type operator[](difference_type n) const noexcept { return (*m_container)[m_itr[n]]; } + + bool operator==(const general_span_iterator& rhs) const noexcept + { + Expects(m_container == rhs.m_container); + return m_itr == rhs.m_itr; + } + bool operator!=(const general_span_iterator& rhs) const noexcept { return !(*this == rhs); } + bool operator<(const general_span_iterator& rhs) const noexcept + { + Expects(m_container == rhs.m_container); + return m_itr < rhs.m_itr; + } + bool operator<=(const general_span_iterator& rhs) const noexcept { return !(rhs < *this); } + bool operator>(const general_span_iterator& rhs) const noexcept { return rhs < *this; } + bool operator>=(const general_span_iterator& rhs) const noexcept { return !(rhs > *this); } + void swap(general_span_iterator& rhs) noexcept + { + std::swap(m_itr, rhs.m_itr); + std::swap(m_container, rhs.m_container); + } +}; + +template <typename Span> +general_span_iterator<Span> operator+(typename general_span_iterator<Span>::difference_type n, + const general_span_iterator<Span>& rhs) noexcept +{ + return rhs + n; +} + +} // namespace gsl + +#ifdef _MSC_VER + +#undef constexpr +#pragma pop_macro("constexpr") + +#if _MSC_VER <= 1800 +#pragma warning(pop) + +#ifndef GSL_THROW_ON_CONTRACT_VIOLATION +#undef noexcept +#pragma pop_macro("noexcept") +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +#undef GSL_MSVC_HAS_VARIADIC_CTOR_BUG + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#if defined(GSL_THROW_ON_CONTRACT_VIOLATION) + +#undef noexcept + +#ifdef _MSC_VER +#pragma warning(pop) +#pragma pop_macro("noexcept") +#endif + +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +#endif // GSL_MULTI_SPAN_H diff --git a/include/span.h b/include/span.h index a612983..a5d2823 100644 --- a/include/span.h +++ b/include/span.h @@ -1,3 +1,4 @@ + /////////////////////////////////////////////////////////////////////////////// // // Copyright (c) 2015 Microsoft Corporation. All rights reserved. @@ -20,17 +21,11 @@ #define GSL_SPAN_H #include "gsl_assert.h" +#include "gsl_byte.h" #include "gsl_util.h" -#include <algorithm> #include <array> -#include <cassert> -#include <cstddef> -#include <cstdint> -#include <functional> #include <iterator> #include <limits> -#include <new> -#include <numeric> #include <stdexcept> #include <type_traits> #include <utility> @@ -45,7 +40,7 @@ // blanket turn off warnings from CppCoreCheck for now // so people aren't annoyed by them when running the tool. // more targeted suppressions will be added in a future update to the GSL -#pragma warning(disable: 26481 26482 26483 26485 26490 26491 26492 26493 26495) +#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495) // No MSVC does constexpr fully yet #pragma push_macro("constexpr") @@ -55,14 +50,18 @@ #if _MSC_VER <= 1800 #define GSL_MSVC_HAS_VARIADIC_CTOR_BUG -#define GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT +#define GSL_MSVC_NO_DEFAULT_MOVE_CTOR +#define GSL_MSVC_NO_CPP14_STD_EQUAL -// noexcept is not understood +// noexcept is not understood #ifndef GSL_THROW_ON_CONTRACT_VIOLATION #pragma push_macro("noexcept") #define noexcept /* nothing */ #endif +#pragma push_macro("alignof") +#define alignof __alignof + // turn off some misguided warnings #pragma warning(push) #pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior @@ -85,2114 +84,706 @@ namespace gsl { -/* -** begin definitions of index and bounds -*/ +// [views.constants], constants +constexpr const std::ptrdiff_t dynamic_extent = -1; + +template <class ElementType, std::ptrdiff_t Extent = dynamic_extent> +class span; + +// implementation details namespace details { - template <typename SizeType> - struct SizeTypeTraits + template <class T> + struct is_span_oracle : std::false_type { - static const SizeType max_value = std::numeric_limits<SizeType>::max(); }; - template <typename... Ts> - class are_integral : public std::integral_constant<bool, true> + template <class ElementType, std::ptrdiff_t Extent> + struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type { }; - template <typename T, typename... Ts> - class are_integral<T, Ts...> - : public std::integral_constant<bool, - std::is_integral<T>::value && are_integral<Ts...>::value> + template <class T> + struct is_span : public is_span_oracle<std::remove_cv_t<T>> { }; -} - -template <size_t Rank> -class index final -{ - static_assert(Rank > 0, "Rank must be greater than 0!"); - - template <size_t OtherRank> - friend class index; - -public: - static const size_t rank = Rank; - using value_type = std::ptrdiff_t; - using size_type = value_type; - using reference = std::add_lvalue_reference_t<value_type>; - using const_reference = std::add_lvalue_reference_t<std::add_const_t<value_type>>; - - constexpr index() noexcept {} - - constexpr index(const value_type (&values)[Rank]) noexcept - { - std::copy(values, values + Rank, elems); - } - -#ifdef GSL_MSVC_HAS_VARIADIC_CTOR_BUG - template < - typename T, typename... Ts, - typename = std::enable_if_t<((sizeof...(Ts) + 1) == Rank) && std::is_integral<T>::value && - details::are_integral<Ts...>::value>> - constexpr index(T t, Ts... ds) - : index({narrow_cast<value_type>(t), narrow_cast<value_type>(ds)...}) - { - } -#else - template <typename... Ts, typename = std::enable_if_t<(sizeof...(Ts) == Rank) && - details::are_integral<Ts...>::value>> - constexpr index(Ts... ds) noexcept : elems{narrow_cast<value_type>(ds)...} - { - } -#endif - - constexpr index(const index& other) noexcept = default; - - constexpr index& operator=(const index& rhs) noexcept = default; - - // Preconditions: component_idx < rank - constexpr reference operator[](size_t component_idx) - { - Expects(component_idx < Rank); // Component index must be less than rank - return elems[component_idx]; - } - - // Preconditions: component_idx < rank - constexpr const_reference operator[](size_t component_idx) const noexcept - { - Expects(component_idx < Rank); // Component index must be less than rank - return elems[component_idx]; - } - - constexpr bool operator==(const index& rhs) const noexcept - { - return std::equal(elems, elems + rank, rhs.elems); - } - - constexpr bool operator!=(const index& rhs) const noexcept { return !(this == rhs); } - - constexpr index operator+() const noexcept { return *this; } - - constexpr index operator-() const noexcept - { - index ret = *this; - std::transform(ret, ret + rank, ret, std::negate<value_type>{}); - return ret; - } - constexpr index operator+(const index& rhs) const noexcept + template <class T> + struct is_std_array_oracle : std::false_type { - index ret = *this; - ret += rhs; - return ret; - } - - constexpr index operator-(const index& rhs) const noexcept - { - index ret = *this; - ret -= rhs; - return ret; - } - - constexpr index& operator+=(const index& rhs) noexcept - { - std::transform(elems, elems + rank, rhs.elems, elems, std::plus<value_type>{}); - return *this; - } + }; - constexpr index& operator-=(const index& rhs) noexcept + template <class ElementType, size_t Extent> + struct is_std_array_oracle<std::array<ElementType, Extent>> : std::true_type { - std::transform(elems, elems + rank, rhs.elems, elems, std::minus<value_type>{}); - return *this; - } + }; - constexpr index operator*(value_type v) const noexcept + template <class T> + struct is_std_array : public is_std_array_oracle<std::remove_cv_t<T>> { - index ret = *this; - ret *= v; - return ret; - } + }; - constexpr index operator/(value_type v) const noexcept + template <class From, class To> + struct is_allowed_pointer_conversion + : public std::integral_constant<bool, std::is_pointer<From>::value && + std::is_pointer<To>::value && + std::is_convertible<From, To>::value> { - index ret = *this; - ret /= v; - return ret; - } + }; - friend constexpr index operator*(value_type v, const index& rhs) noexcept + template <class From, class To> + struct is_allowed_integral_conversion + : public std::integral_constant< + bool, std::is_integral<From>::value && std::is_integral<To>::value && + sizeof(From) == sizeof(To) && alignof(From) == alignof(To) && + std::is_convertible<From, To>::value> { - return rhs * v; - } + }; - constexpr index& operator*=(value_type v) noexcept + template <std::ptrdiff_t From, std::ptrdiff_t To> + struct is_allowed_extent_conversion + : public std::integral_constant<bool, From == To || From == gsl::dynamic_extent || + To == gsl::dynamic_extent> { - std::transform(elems, elems + rank, elems, - [v](value_type x) { return std::multiplies<value_type>{}(x, v); }); - return *this; - } + }; - constexpr index& operator/=(value_type v) noexcept + template <class From, class To> + struct is_allowed_element_type_conversion + : public std::integral_constant<bool, std::is_same<From, std::remove_cv_t<To>>::value || + is_allowed_pointer_conversion<From, To>::value || + is_allowed_integral_conversion<From, To>::value> { - std::transform(elems, elems + rank, elems, - [v](value_type x) { return std::divides<value_type>{}(x, v); }); - return *this; - } - -private: - value_type elems[Rank] = {}; -}; - -#ifndef _MSC_VER + }; -struct static_bounds_dynamic_range_t -{ - template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> - constexpr operator T() const noexcept + template <class From> + struct is_allowed_element_type_conversion<From, byte> + : public std::integral_constant<bool, !std::is_const<From>::value> { - return narrow_cast<T>(-1); - } + }; - template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> - constexpr bool operator==(T other) const noexcept + template <class From> + struct is_allowed_element_type_conversion<From, const byte> : public std::true_type { - return narrow_cast<T>(-1) == other; - } + }; - template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> - constexpr bool operator!=(T other) const noexcept + template <class Span> + class const_span_iterator { - return narrow_cast<T>(-1) != other; - } -}; - -template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> -constexpr bool operator==(T left, static_bounds_dynamic_range_t right) noexcept -{ - return right == left; -} - -template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> -constexpr bool operator!=(T left, static_bounds_dynamic_range_t right) noexcept -{ - return right != left; -} - -constexpr static_bounds_dynamic_range_t dynamic_range{}; -#else -const std::ptrdiff_t dynamic_range = -1; -#endif - -struct generalized_mapping_tag -{ -}; -struct contiguous_mapping_tag : generalized_mapping_tag -{ -}; + public: + using iterator_category = std::random_access_iterator_tag; + using value_type = typename Span::element_type; + using difference_type = std::ptrdiff_t; -namespace details -{ + using const_pointer = std::add_const_t<value_type*>; + using pointer = const_pointer; - template <std::ptrdiff_t Left, std::ptrdiff_t Right> - struct LessThan - { - static const bool value = Left < Right; - }; + using const_reference = std::add_const_t<value_type&>; + using reference = const_reference; - template <std::ptrdiff_t... Ranges> - struct BoundsRanges - { - using size_type = std::ptrdiff_t; - static const size_type Depth = 0; - static const size_type DynamicNum = 0; - static const size_type CurrentRange = 1; - static const size_type TotalSize = 1; - - // TODO : following signature is for work around VS bug - template <typename OtherRange> - BoundsRanges(const OtherRange&, bool /* firstLevel */) + constexpr const_span_iterator() : const_span_iterator(nullptr, 0) {} + constexpr const_span_iterator(const Span* span, typename Span::index_type index) + : span_(span), index_(index) { + Expects(span == nullptr || (index_ >= 0 && index <= span_->length())); } - BoundsRanges(const BoundsRanges&) = default; - BoundsRanges& operator=(const BoundsRanges&) = default; - BoundsRanges(const std::ptrdiff_t* const) {} - BoundsRanges() = default; - - template <typename T, size_t Dim> - void serialize(T&) const + constexpr reference operator*() const { + Expects(span_); + return (*span_)[index_]; } - template <typename T, size_t Dim> - size_type linearize(const T&) const + constexpr pointer operator->() const { - return 0; + Expects(span_); + return &((*span_)[index_]); } - template <typename T, size_t Dim> - size_type contains(const T&) const + constexpr const_span_iterator& operator++() noexcept { - return -1; + Expects(span_ && index_ >= 0 && index_ < span_->length()); + ++index_; + return *this; } - size_type elementNum(size_t) const noexcept { return 0; } - - size_type totalSize() const noexcept { return TotalSize; } - - bool operator==(const BoundsRanges&) const noexcept { return true; } - }; - - template <std::ptrdiff_t... RestRanges> - struct BoundsRanges<dynamic_range, RestRanges...> : BoundsRanges<RestRanges...> - { - using Base = BoundsRanges<RestRanges...>; - using size_type = std::ptrdiff_t; - static const size_t Depth = Base::Depth + 1; - static const size_t DynamicNum = Base::DynamicNum + 1; - static const size_type CurrentRange = dynamic_range; - static const size_type TotalSize = dynamic_range; - const size_type m_bound; - - BoundsRanges(const BoundsRanges&) = default; - - BoundsRanges(const std::ptrdiff_t* const arr) - : Base(arr + 1), m_bound(*arr * this->Base::totalSize()) + constexpr const_span_iterator operator++(int) noexcept { - Expects(0 <= *arr); + auto ret = *this; + ++(*this); + return ret; } - BoundsRanges() : m_bound(0) {} - - template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges> - BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other, - bool /* firstLevel */ = true) - : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false) - , m_bound(other.totalSize()) + constexpr const_span_iterator& operator--() noexcept { + Expects(span_ && index_ > 0 && index_ <= span_->length()); + --index_; + return *this; } - template <typename T, size_t Dim = 0> - void serialize(T& arr) const + constexpr const_span_iterator operator--(int) noexcept { - arr[Dim] = elementNum(); - this->Base::template serialize<T, Dim + 1>(arr); + auto ret = *this; + --(*this); + return ret; } - template <typename T, size_t Dim = 0> - size_type linearize(const T& arr) const + constexpr const_span_iterator operator+(difference_type n) const noexcept { - const size_type index = this->Base::totalSize() * arr[Dim]; - Expects(index < m_bound); - return index + this->Base::template linearize<T, Dim + 1>(arr); + auto ret = *this; + return ret += n; } - template <typename T, size_t Dim = 0> - size_type contains(const T& arr) const + constexpr const_span_iterator& operator+=(difference_type n) noexcept { - const ptrdiff_t last = this->Base::template contains<T, Dim + 1>(arr); - if (last == -1) return -1; - const ptrdiff_t cur = this->Base::totalSize() * arr[Dim]; - return cur < m_bound ? cur + last : -1; + Expects(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->length()); + index_ += n; + return *this; } - size_type totalSize() const noexcept { return m_bound; } - - size_type elementNum() const noexcept { return totalSize() / this->Base::totalSize(); } - - size_type elementNum(size_t dim) const noexcept + constexpr const_span_iterator operator-(difference_type n) const noexcept { - if (dim > 0) - return this->Base::elementNum(dim - 1); - else - return elementNum(); + auto ret = *this; + return ret -= n; } - bool operator==(const BoundsRanges& rhs) const noexcept + constexpr const_span_iterator& operator-=(difference_type n) noexcept { - return m_bound == rhs.m_bound && - static_cast<const Base&>(*this) == static_cast<const Base&>(rhs); + return *this += -n; } - }; - template <std::ptrdiff_t CurRange, std::ptrdiff_t... RestRanges> - struct BoundsRanges<CurRange, RestRanges...> : BoundsRanges<RestRanges...> - { - using Base = BoundsRanges<RestRanges...>; - using size_type = std::ptrdiff_t; - static const size_t Depth = Base::Depth + 1; - static const size_t DynamicNum = Base::DynamicNum; - static const size_type CurrentRange = CurRange; - static const size_type TotalSize = - Base::TotalSize == dynamic_range ? dynamic_range : CurrentRange * Base::TotalSize; - - BoundsRanges(const BoundsRanges&) = default; - - BoundsRanges(const std::ptrdiff_t* const arr) : Base(arr) {} - BoundsRanges() = default; - - template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges> - BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other, - bool firstLevel = true) - : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false) + constexpr difference_type operator-(const const_span_iterator& rhs) const noexcept { - (void) firstLevel; + Expects(span_ == rhs.span_); + return index_ - rhs.index_; } - template <typename T, size_t Dim = 0> - void serialize(T& arr) const - { - arr[Dim] = elementNum(); - this->Base::template serialize<T, Dim + 1>(arr); - } + constexpr reference operator[](difference_type n) const noexcept { return *(*this + n); } - template <typename T, size_t Dim = 0> - size_type linearize(const T& arr) const + constexpr bool operator==(const const_span_iterator& rhs) const noexcept { - Expects(arr[Dim] < CurrentRange); // Index is out of range - return this->Base::totalSize() * arr[Dim] + - this->Base::template linearize<T, Dim + 1>(arr); + return span_ == rhs.span_ && index_ == rhs.index_; } - template <typename T, size_t Dim = 0> - size_type contains(const T& arr) const + constexpr bool operator!=(const const_span_iterator& rhs) const noexcept { - if (arr[Dim] >= CurrentRange) return -1; - const size_type last = this->Base::template contains<T, Dim + 1>(arr); - if (last == -1) return -1; - return this->Base::totalSize() * arr[Dim] + last; + return !(*this == rhs); } - size_type totalSize() const noexcept { return CurrentRange * this->Base::totalSize(); } - - size_type elementNum() const noexcept { return CurrentRange; } - - size_type elementNum(size_t dim) const noexcept + constexpr bool operator<(const const_span_iterator& rhs) const noexcept { - if (dim > 0) - return this->Base::elementNum(dim - 1); - else - return elementNum(); + Expects(span_ == rhs.span_); + return index_ < rhs.index_; } - bool operator==(const BoundsRanges& rhs) const noexcept + constexpr bool operator<=(const const_span_iterator& rhs) const noexcept { - return static_cast<const Base&>(*this) == static_cast<const Base&>(rhs); + return !(rhs < *this); } - }; - - template <typename SourceType, typename TargetType> - struct BoundsRangeConvertible - : public std::integral_constant<bool, (SourceType::TotalSize >= TargetType::TotalSize || - TargetType::TotalSize == dynamic_range || - SourceType::TotalSize == dynamic_range || - TargetType::TotalSize == 0)> - { - }; - - template <typename TypeChain> - struct TypeListIndexer - { - const TypeChain& obj_; - TypeListIndexer(const TypeChain& obj) : obj_(obj) {} - template <size_t N> - const TypeChain& getObj(std::true_type) + constexpr bool operator>(const const_span_iterator& rhs) const noexcept { - return obj_; + return rhs < *this; } - template <size_t N, typename MyChain = TypeChain, typename MyBase = typename MyChain::Base> - auto getObj(std::false_type) - -> decltype(TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>()) + constexpr bool operator>=(const const_span_iterator& rhs) const noexcept { - return TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>(); + return !(rhs > *this); } - template <size_t N> - auto get() -> decltype(getObj<N - 1>(std::integral_constant<bool, N == 0>())) + void swap(const_span_iterator& rhs) noexcept { - return getObj<N - 1>(std::integral_constant<bool, N == 0>()); - } - }; - - template <typename TypeChain> - TypeListIndexer<TypeChain> createTypeListIndexer(const TypeChain& obj) - { - return TypeListIndexer<TypeChain>(obj); - } - - template <size_t Rank, bool Enabled = (Rank > 1), - typename Ret = std::enable_if_t<Enabled, index<Rank - 1>>> - constexpr Ret shift_left(const index<Rank>& other) noexcept - { - Ret ret{}; - for (size_t i = 0; i < Rank - 1; ++i) { - ret[i] = other[i + 1]; + std::swap(index_, rhs.index_); + std::swap(span_, rhs.span_); } - return ret; - } -} - -template <typename IndexType> -class bounds_iterator; - -template <std::ptrdiff_t... Ranges> -class static_bounds -{ -public: - static_bounds(const details::BoundsRanges<Ranges...>&) {} -}; - -template <std::ptrdiff_t FirstRange, std::ptrdiff_t... RestRanges> -class static_bounds<FirstRange, RestRanges...> -{ - using MyRanges = details::BoundsRanges<FirstRange, RestRanges...>; - - MyRanges m_ranges; - constexpr static_bounds(const MyRanges& range) : m_ranges(range) {} - - template <std::ptrdiff_t... OtherRanges> - friend class static_bounds; - -public: - static const size_t rank = MyRanges::Depth; - static const size_t dynamic_rank = MyRanges::DynamicNum; - static const std::ptrdiff_t static_size = MyRanges::TotalSize; - - using size_type = std::ptrdiff_t; - using index_type = index<rank>; - using const_index_type = std::add_const_t<index_type>; - using iterator = bounds_iterator<const_index_type>; - using const_iterator = bounds_iterator<const_index_type>; - using difference_type = std::ptrdiff_t; - using sliced_type = static_bounds<RestRanges...>; - using mapping_type = contiguous_mapping_tag; - - constexpr static_bounds(const static_bounds&) = default; - - template <typename SourceType, typename TargetType, size_t Rank> - struct BoundsRangeConvertible2; - - template <size_t Rank, typename SourceType, typename TargetType, - typename Ret = BoundsRangeConvertible2<typename SourceType::Base, - typename TargetType::Base, Rank>> - static auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type) -> Ret; - - template <size_t Rank, typename SourceType, typename TargetType> - static auto helpBoundsRangeConvertible(SourceType, TargetType, ...) -> std::false_type; - - template <typename SourceType, typename TargetType, size_t Rank> - struct BoundsRangeConvertible2 - : decltype(helpBoundsRangeConvertible<Rank - 1>( - SourceType(), TargetType(), - std::integral_constant<bool, - SourceType::Depth == TargetType::Depth && - (SourceType::CurrentRange == TargetType::CurrentRange || - TargetType::CurrentRange == dynamic_range || - SourceType::CurrentRange == dynamic_range)>())) - { - }; - template <typename SourceType, typename TargetType> - struct BoundsRangeConvertible2<SourceType, TargetType, 0> : std::true_type - { - }; - - template <typename SourceType, typename TargetType, std::ptrdiff_t Rank = TargetType::Depth> - struct BoundsRangeConvertible - : decltype(helpBoundsRangeConvertible<Rank - 1>( - SourceType(), TargetType(), - std::integral_constant<bool, - SourceType::Depth == TargetType::Depth && - (!details::LessThan<SourceType::CurrentRange, - TargetType::CurrentRange>::value || - TargetType::CurrentRange == dynamic_range || - SourceType::CurrentRange == dynamic_range)>())) - { - }; - - template <typename SourceType, typename TargetType> - struct BoundsRangeConvertible<SourceType, TargetType, 0> : std::true_type - { + private: + const Span* span_; + std::ptrdiff_t index_; }; - template <std::ptrdiff_t... Ranges, - typename = std::enable_if_t<details::BoundsRangeConvertible< - details::BoundsRanges<Ranges...>, - details::BoundsRanges<FirstRange, RestRanges...>>::value>> - constexpr static_bounds(const static_bounds<Ranges...>& other) : m_ranges(other.m_ranges) - { - Expects((MyRanges::DynamicNum == 0 && details::BoundsRanges<Ranges...>::DynamicNum == 0) || - MyRanges::DynamicNum > 0 || other.m_ranges.totalSize() >= m_ranges.totalSize()); - } - - constexpr static_bounds(std::initializer_list<size_type> il) - : m_ranges(static_cast<const std::ptrdiff_t*>(il.begin())) + template <class Span> + class span_iterator { - // Size of the initializer list must match the rank of the array - Expects((MyRanges::DynamicNum == 0 && il.size() == 1 && *il.begin() == static_size) || - MyRanges::DynamicNum == il.size()); - // Size of the range must be less than the max element of the size type - Expects(m_ranges.totalSize() <= PTRDIFF_MAX); - } - - constexpr static_bounds() = default; - - constexpr static_bounds& operator=(const static_bounds& otherBounds) - { - new (&m_ranges) MyRanges(otherBounds.m_ranges); - return *this; - } - - constexpr sliced_type slice() const noexcept - { - return sliced_type{static_cast<const details::BoundsRanges<RestRanges...>&>(m_ranges)}; - } - - constexpr size_type stride() const noexcept { return rank > 1 ? slice().size() : 1; } + public: + using iterator_category = std::random_access_iterator_tag; + using value_type = typename Span::element_type; + using difference_type = std::ptrdiff_t; - constexpr size_type size() const noexcept { return m_ranges.totalSize(); } + using pointer = value_type*; + using reference = value_type&; - constexpr size_type total_size() const noexcept { return m_ranges.totalSize(); } - - constexpr size_type linearize(const index_type& idx) const { return m_ranges.linearize(idx); } - - constexpr bool contains(const index_type& idx) const noexcept - { - return m_ranges.contains(idx) != -1; - } - - constexpr size_type operator[](size_t index) const noexcept - { - return m_ranges.elementNum(index); - } - - template <size_t Dim = 0> - constexpr size_type extent() const noexcept - { - static_assert(Dim < rank, - "dimension should be less than rank (dimension count starts from 0)"); - return details::createTypeListIndexer(m_ranges).template get<Dim>().elementNum(); - } - - template <typename IntType> - constexpr size_type extent(IntType dim) const noexcept - { - static_assert(std::is_integral<IntType>::value, - "Dimension parameter must be supplied as an integral type."); - auto real_dim = narrow_cast<size_t>(dim); - Expects(real_dim < rank); - - return m_ranges.elementNum(real_dim); - } - - constexpr index_type index_bounds() const noexcept - { - size_type extents[rank] = {}; - m_ranges.serialize(extents); - return {extents}; - } - - template <std::ptrdiff_t... Ranges> - constexpr bool operator==(const static_bounds<Ranges...>& rhs) const noexcept - { - return this->size() == rhs.size(); - } - - template <std::ptrdiff_t... Ranges> - constexpr bool operator!=(const static_bounds<Ranges...>& rhs) const noexcept - { - return !(*this == rhs); - } - - constexpr const_iterator begin() const noexcept { return const_iterator(*this, index_type{}); } - - constexpr const_iterator end() const noexcept - { - return const_iterator(*this, this->index_bounds()); - } -}; - -template <size_t Rank> -class strided_bounds -{ - template <size_t OtherRank> - friend class strided_bounds; - -public: - static const size_t rank = Rank; - using value_type = std::ptrdiff_t; - using reference = std::add_lvalue_reference_t<value_type>; - using const_reference = std::add_const_t<reference>; - using size_type = value_type; - using difference_type = value_type; - using index_type = index<rank>; - using const_index_type = std::add_const_t<index_type>; - using iterator = bounds_iterator<const_index_type>; - using const_iterator = bounds_iterator<const_index_type>; - static const value_type dynamic_rank = rank; - static const value_type static_size = dynamic_range; - using sliced_type = std::conditional_t<rank != 0, strided_bounds<rank - 1>, void>; - using mapping_type = generalized_mapping_tag; - - constexpr strided_bounds(const strided_bounds&) noexcept = default; - - constexpr strided_bounds& operator=(const strided_bounds&) noexcept = default; - - constexpr strided_bounds(const value_type (&values)[rank], index_type strides) - : m_extents(values), m_strides(std::move(strides)) - { - } - - constexpr strided_bounds(const index_type& extents, const index_type& strides) noexcept - : m_extents(extents), - m_strides(strides) - { - } - - constexpr index_type strides() const noexcept { return m_strides; } - - constexpr size_type total_size() const noexcept - { - size_type ret = 0; - for (size_t i = 0; i < rank; ++i) { - ret += (m_extents[i] - 1) * m_strides[i]; + constexpr span_iterator() : span_iterator(nullptr, 0) {} + constexpr span_iterator(const Span* span, typename Span::index_type index) + : span_(span), index_(index) + { + Expects(span == nullptr || (index_ >= 0 && index <= span_->length())); } - return ret + 1; - } - constexpr size_type size() const noexcept - { - size_type ret = 1; - for (size_t i = 0; i < rank; ++i) { - ret *= m_extents[i]; + constexpr reference operator*() const + { + Expects(span_); + return (*span_)[index_]; } - return ret; - } - constexpr bool contains(const index_type& idx) const noexcept - { - for (size_t i = 0; i < rank; ++i) { - if (idx[i] < 0 || idx[i] >= m_extents[i]) return false; + constexpr pointer operator->() const + { + Expects(span_); + return &((*span_)[index_]); } - return true; - } - constexpr size_type linearize(const index_type& idx) const noexcept - { - size_type ret = 0; - for (size_t i = 0; i < rank; i++) { - Expects(idx[i] < m_extents[i]); // index is out of bounds of the array - ret += idx[i] * m_strides[i]; + constexpr span_iterator& operator++() noexcept + { + Expects(span_ && index_ >= 0 && index_ < span_->length()); + ++index_; + return *this; } - return ret; - } - - constexpr size_type stride() const noexcept { return m_strides[0]; } - - template <bool Enabled = (rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>> - constexpr sliced_type slice() const - { - return {details::shift_left(m_extents), details::shift_left(m_strides)}; - } - - template <size_t Dim = 0> - constexpr size_type extent() const noexcept - { - static_assert(Dim < Rank, - "dimension should be less than rank (dimension count starts from 0)"); - return m_extents[Dim]; - } - - constexpr index_type index_bounds() const noexcept { return m_extents; } - constexpr const_iterator begin() const noexcept { return const_iterator{*this, index_type{}}; } - - constexpr const_iterator end() const noexcept { return const_iterator{*this, index_bounds()}; } - -private: - index_type m_extents; - index_type m_strides; -}; - -template <typename T> -struct is_bounds : std::integral_constant<bool, false> -{ -}; -template <std::ptrdiff_t... Ranges> -struct is_bounds<static_bounds<Ranges...>> : std::integral_constant<bool, true> -{ -}; -template <size_t Rank> -struct is_bounds<strided_bounds<Rank>> : std::integral_constant<bool, true> -{ -}; - -template <typename IndexType> -class bounds_iterator : public std::iterator<std::random_access_iterator_tag, IndexType> -{ -private: - using Base = std::iterator<std::random_access_iterator_tag, IndexType>; - -public: - static const size_t rank = IndexType::rank; - using typename Base::reference; - using typename Base::pointer; - using typename Base::difference_type; - using typename Base::value_type; - using index_type = value_type; - using index_size_type = typename IndexType::value_type; - template <typename Bounds> - explicit bounds_iterator(const Bounds& bnd, value_type curr) noexcept - : boundary_(bnd.index_bounds()), - curr_(std::move(curr)) - { - static_assert(is_bounds<Bounds>::value, "Bounds type must be provided"); - } - - constexpr reference operator*() const noexcept { return curr_; } - - constexpr pointer operator->() const noexcept { return &curr_; } - constexpr bounds_iterator& operator++() noexcept - { - for (size_t i = rank; i-- > 0;) { - if (curr_[i] < boundary_[i] - 1) { - curr_[i]++; - return *this; - } - curr_[i] = 0; + constexpr span_iterator operator++(int) noexcept + { + auto ret = *this; + ++(*this); + return ret; } - // If we're here we've wrapped over - set to past-the-end. - curr_ = boundary_; - return *this; - } - - constexpr bounds_iterator operator++(int) noexcept - { - auto ret = *this; - ++(*this); - return ret; - } - constexpr bounds_iterator& operator--() noexcept - { - if (!less(curr_, boundary_)) { - // if at the past-the-end, set to last element - for (size_t i = 0; i < rank; ++i) { - curr_[i] = boundary_[i] - 1; - } + constexpr span_iterator& operator--() noexcept + { + Expects(span_ && index_ > 0 && index_ <= span_->length()); + --index_; return *this; } - for (size_t i = rank; i-- > 0;) { - if (curr_[i] >= 1) { - curr_[i]--; - return *this; - } - curr_[i] = boundary_[i] - 1; - } - // If we're here the preconditions were violated - // "pre: there exists s such that r == ++s" - Expects(false); - return *this; - } - - constexpr bounds_iterator operator--(int) noexcept - { - auto ret = *this; - --(*this); - return ret; - } - constexpr bounds_iterator operator+(difference_type n) const noexcept - { - bounds_iterator ret{*this}; - return ret += n; - } - - constexpr bounds_iterator& operator+=(difference_type n) noexcept - { - auto linear_idx = linearize(curr_) + n; - std::remove_const_t<value_type> stride = 0; - stride[rank - 1] = 1; - for (size_t i = rank - 1; i-- > 0;) { - stride[i] = stride[i + 1] * boundary_[i + 1]; - } - for (size_t i = 0; i < rank; ++i) { - curr_[i] = linear_idx / stride[i]; - linear_idx = linear_idx % stride[i]; + constexpr span_iterator operator--(int) noexcept + { + auto ret = *this; + --(*this); + return ret; } - // index is out of bounds of the array - Expects(!less(curr_, index_type{}) && !less(boundary_, curr_)); - return *this; - } - constexpr bounds_iterator operator-(difference_type n) const noexcept - { - bounds_iterator ret{*this}; - return ret -= n; - } + constexpr span_iterator operator+(difference_type n) const noexcept + { + auto ret = *this; + return ret += n; + } - constexpr bounds_iterator& operator-=(difference_type n) noexcept { return * this += -n; } + constexpr span_iterator& operator+=(difference_type n) noexcept + { + Expects(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->length()); + index_ += n; + return *this; + } - constexpr difference_type operator-(const bounds_iterator& rhs) const noexcept - { - return linearize(curr_) - linearize(rhs.curr_); - } + constexpr span_iterator operator-(difference_type n) const noexcept + { + auto ret = *this; + return ret -= n; + } - constexpr value_type operator[](difference_type n) const noexcept { return *(*this + n); } + constexpr span_iterator& operator-=(difference_type n) noexcept { return *this += -n; } - constexpr bool operator==(const bounds_iterator& rhs) const noexcept - { - return curr_ == rhs.curr_; - } + constexpr difference_type operator-(const span_iterator& rhs) const noexcept + { + Expects(span_ == rhs.span_); + return index_ - rhs.index_; + } - constexpr bool operator!=(const bounds_iterator& rhs) const noexcept { return !(*this == rhs); } + constexpr reference operator[](difference_type n) const noexcept { return *(*this + n); } - constexpr bool operator<(const bounds_iterator& rhs) const noexcept - { - return less(curr_, rhs.curr_); - } + constexpr bool operator==(const span_iterator& rhs) const noexcept + { + return span_ == rhs.span_ && index_ == rhs.index_; + } - constexpr bool operator<=(const bounds_iterator& rhs) const noexcept { return !(rhs < *this); } + constexpr bool operator!=(const span_iterator& rhs) const noexcept + { + return !(*this == rhs); + } - constexpr bool operator>(const bounds_iterator& rhs) const noexcept { return rhs < *this; } + constexpr bool operator<(const span_iterator& rhs) const noexcept + { + Expects(span_ == rhs.span_); + return index_ < rhs.index_; + } - constexpr bool operator>=(const bounds_iterator& rhs) const noexcept { return !(rhs > *this); } + constexpr bool operator<=(const span_iterator& rhs) const noexcept + { + return !(rhs < *this); + } - void swap(bounds_iterator& rhs) noexcept - { - std::swap(boundary_, rhs.boundary_); - std::swap(curr_, rhs.curr_); - } + constexpr bool operator>(const span_iterator& rhs) const noexcept { return rhs < *this; } -private: - constexpr bool less(index_type& one, index_type& other) const noexcept - { - for (size_t i = 0; i < rank; ++i) { - if (one[i] < other[i]) return true; + constexpr bool operator>=(const span_iterator& rhs) const noexcept + { + return !(rhs > *this); } - return false; - } - constexpr index_size_type linearize(const value_type& idx) const noexcept - { - // TODO: Smarter impl. - // Check if past-the-end - index_size_type multiplier = 1; - index_size_type res = 0; - if (!less(idx, boundary_)) { - res = 1; - for (size_t i = rank; i-- > 0;) { - res += (idx[i] - 1) * multiplier; - multiplier *= boundary_[i]; - } - } - else + void swap(span_iterator& rhs) noexcept { - for (size_t i = rank; i-- > 0;) { - res += idx[i] * multiplier; - multiplier *= boundary_[i]; - } + std::swap(index_, rhs.index_); + std::swap(span_, rhs.span_); } - return res; - } - value_type boundary_; - std::remove_const_t<value_type> curr_; -}; - -template <typename IndexType> -bounds_iterator<IndexType> operator+(typename bounds_iterator<IndexType>::difference_type n, - const bounds_iterator<IndexType>& rhs) noexcept -{ - return rhs + n; -} + private: + const Span* span_; + std::ptrdiff_t index_; + }; -namespace details -{ - template <typename Bounds> - constexpr std::enable_if_t< - std::is_same<typename Bounds::mapping_type, generalized_mapping_tag>::value, - typename Bounds::index_type> - make_stride(const Bounds& bnd) noexcept + template <typename Span> + constexpr const_span_iterator<Span> + operator+(typename const_span_iterator<Span>::difference_type n, + const const_span_iterator<Span>& rhs) noexcept { - return bnd.strides(); + return rhs + n; } - // Make a stride vector from bounds, assuming contiguous memory. - template <typename Bounds> - constexpr std::enable_if_t< - std::is_same<typename Bounds::mapping_type, contiguous_mapping_tag>::value, - typename Bounds::index_type> - make_stride(const Bounds& bnd) noexcept + template <typename Span> + constexpr const_span_iterator<Span> + operator-(typename const_span_iterator<Span>::difference_type n, + const const_span_iterator<Span>& rhs) noexcept { - auto extents = bnd.index_bounds(); - typename Bounds::size_type stride[Bounds::rank] = {}; - - stride[Bounds::rank - 1] = 1; - for (size_t i = 1; i < Bounds::rank; ++i) { - stride[Bounds::rank - i - 1] = stride[Bounds::rank - i] * extents[Bounds::rank - i]; - } - return {stride}; + return rhs - n; } - template <typename BoundsSrc, typename BoundsDest> - void verifyBoundsReshape(const BoundsSrc& src, const BoundsDest& dest) + template <typename Span> + constexpr span_iterator<Span> operator+(typename span_iterator<Span>::difference_type n, + const span_iterator<Span>& rhs) noexcept { - static_assert(is_bounds<BoundsSrc>::value && is_bounds<BoundsDest>::value, - "The src type and dest type must be bounds"); - static_assert(std::is_same<typename BoundsSrc::mapping_type, contiguous_mapping_tag>::value, - "The source type must be a contiguous bounds"); - static_assert(BoundsDest::static_size == dynamic_range || - BoundsSrc::static_size == dynamic_range || - BoundsDest::static_size == BoundsSrc::static_size, - "The source bounds must have same size as dest bounds"); - Expects(src.size() == dest.size()); + return rhs + n; } -} // namespace details - -template <typename Span> -class contiguous_span_iterator; -template <typename Span> -class general_span_iterator; -enum class byte : std::uint8_t -{ -}; - -template <std::ptrdiff_t DimSize = dynamic_range> -struct dim -{ - static const std::ptrdiff_t value = DimSize; -}; -template <> -struct dim<dynamic_range> -{ - static const std::ptrdiff_t value = dynamic_range; - const std::ptrdiff_t dvalue; - dim(std::ptrdiff_t size) : dvalue(size) {} -}; - -template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range, - std::ptrdiff_t... RestDimensions> -class span; - -template <typename ValueType, size_t Rank> -class strided_span; - -namespace details -{ - template <typename T, typename = std::true_type> - struct SpanTypeTraits + template <typename Span> + constexpr span_iterator<Span> operator-(typename span_iterator<Span>::difference_type n, + const span_iterator<Span>& rhs) noexcept { - using value_type = T; - using size_type = size_t; - }; + return rhs - n; + } - template <typename Traits> - struct SpanTypeTraits<Traits, typename std::is_reference<typename Traits::span_traits&>::type> + template <std::ptrdiff_t Ext> + class extent_type { - using value_type = typename Traits::span_traits::value_type; - using size_type = typename Traits::span_traits::size_type; - }; + public: + using index_type = std::ptrdiff_t; - template <typename T, std::ptrdiff_t... Ranks> - struct SpanArrayTraits - { - using type = span<T, Ranks...>; - using value_type = T; - using bounds_type = static_bounds<Ranks...>; - using pointer = T*; - using reference = T&; - }; - template <typename T, std::ptrdiff_t N, std::ptrdiff_t... Ranks> - struct SpanArrayTraits<T[N], Ranks...> : SpanArrayTraits<T, Ranks..., N> - { - }; + static_assert(Ext >= 0, "A fixed-size span must be >= 0 in size."); - template <typename BoundsType> - BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::true_type) // dynamic size - { - Expects(totalSize >= 0 && totalSize <= PTRDIFF_MAX); - return BoundsType{totalSize}; - } - template <typename BoundsType> - BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::false_type) // static size - { - Expects(BoundsType::static_size <= totalSize); - return {}; - } - template <typename BoundsType> - BoundsType newBoundsHelper(std::ptrdiff_t totalSize) - { - static_assert(BoundsType::dynamic_rank <= 1, "dynamic rank must less or equal to 1"); - return newBoundsHelperImpl<BoundsType>( - totalSize, std::integral_constant<bool, BoundsType::dynamic_rank == 1>()); - } + constexpr extent_type() noexcept {} - struct Sep - { - }; + template <index_type Other> + constexpr extent_type(extent_type<Other> ext) noexcept + { + static_assert(Other == Ext || Other == dynamic_extent, + "Mismatch between fixed-size extent and size of initializing data."); + Expects(ext.size() == Ext); + } - template <typename T, typename... Args> - T static_as_span_helper(Sep, Args... args) - { - return T{narrow_cast<typename T::size_type>(args)...}; - } - template <typename T, typename Arg, typename... Args> - std::enable_if_t< - !std::is_same<Arg, dim<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T> - static_as_span_helper(Arg, Args... args) - { - return static_as_span_helper<T>(args...); - } - template <typename T, typename... Args> - T static_as_span_helper(dim<dynamic_range> val, Args... args) - { - return static_as_span_helper<T>(args..., val.dvalue); - } + constexpr extent_type(index_type size) { Expects(size == Ext); } - template <typename... Dimensions> - struct static_as_span_static_bounds_helper - { - using type = static_bounds<(Dimensions::value)...>; + constexpr inline index_type size() const noexcept { return Ext; } }; - template <typename T> - struct is_span_oracle : std::false_type + template <> + class extent_type<dynamic_extent> { - }; + public: + using index_type = std::ptrdiff_t; - template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> - struct is_span_oracle<span<ValueType, FirstDimension, RestDimensions...>> : std::true_type - { - }; + template <index_type Other> + explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size()) + { + } - template <typename ValueType, std::ptrdiff_t Rank> - struct is_span_oracle<strided_span<ValueType, Rank>> : std::true_type - { - }; + explicit constexpr extent_type(index_type size) : size_(size) { Expects(size >= 0); } - template <typename T> - struct is_span : is_span_oracle<std::remove_cv_t<T>> - { + constexpr inline index_type size() const noexcept { return size_; } + + private: + index_type size_; }; -} +} // namespace details -template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> +// [span], class template span +template <class ElementType, std::ptrdiff_t Extent> class span { - // TODO do we still need this? - template <typename ValueType2, std::ptrdiff_t FirstDimension2, - std::ptrdiff_t... RestDimensions2> - friend class span; - public: - using bounds_type = static_bounds<FirstDimension, RestDimensions...>; - static const size_t Rank = bounds_type::rank; - using size_type = typename bounds_type::size_type; - using index_type = typename bounds_type::index_type; - using value_type = ValueType; - using const_value_type = std::add_const_t<value_type>; - using pointer = std::add_pointer_t<value_type>; - using reference = std::add_lvalue_reference_t<value_type>; - using iterator = contiguous_span_iterator<span>; - using const_span = span<const_value_type, FirstDimension, RestDimensions...>; - using const_iterator = contiguous_span_iterator<const_span>; + // constants and types + using element_type = ElementType; + using index_type = std::ptrdiff_t; + using pointer = element_type*; + using reference = element_type&; + + using iterator = details::span_iterator<span<ElementType, Extent>>; + using const_iterator = details::const_span_iterator<span<ElementType, Extent>>; using reverse_iterator = std::reverse_iterator<iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>; - using sliced_type = - std::conditional_t<Rank == 1, value_type, span<value_type, RestDimensions...>>; -private: - pointer data_; - bounds_type bounds_; + constexpr static const index_type extent = Extent; - friend iterator; - friend const_iterator; + // [span.cons], span constructors, copy, assignment, and destructor + constexpr span() noexcept : storage_(nullptr, details::extent_type<0>()) {} -public: - // default constructor - same as constructing from nullptr_t - constexpr span() noexcept : span(nullptr, bounds_type{}) - { - static_assert(bounds_type::dynamic_rank != 0 || - (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0), - "Default construction of span<T> only possible " - "for dynamic or fixed, zero-length spans."); - } + constexpr span(std::nullptr_t) noexcept : span() {} - // construct from nullptr - get an empty span - constexpr span(std::nullptr_t) noexcept : span(nullptr, bounds_type{}) - { - static_assert(bounds_type::dynamic_rank != 0 || - (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0), - "nullptr_t construction of span<T> only possible " - "for dynamic or fixed, zero-length spans."); - } + constexpr span(pointer ptr, index_type count) : storage_(ptr, count) {} - // construct from nullptr with size of 0 (helps with template function calls) - template <class IntType, typename = std::enable_if_t<std::is_integral<IntType>::value>> - constexpr span(std::nullptr_t, IntType size) noexcept : span(nullptr, bounds_type{}) + constexpr span(pointer firstElem, pointer lastElem) + : storage_(firstElem, std::distance(firstElem, lastElem)) { - static_assert(bounds_type::dynamic_rank != 0 || - (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0), - "nullptr_t construction of span<T> only possible " - "for dynamic or fixed, zero-length spans."); - Expects(size == 0); } - // construct from a single element - constexpr span(reference data) noexcept : span(&data, bounds_type{1}) + template <size_t N> + constexpr span(element_type (&arr)[N]) noexcept : storage_(&arr[0], details::extent_type<N>()) { - static_assert(bounds_type::dynamic_rank > 0 || bounds_type::static_size == 0 || - bounds_type::static_size == 1, - "Construction from a single element only possible " - "for dynamic or fixed spans of length 0 or 1."); } - // prevent constructing from temporaries for single-elements - constexpr span(value_type&&) = delete; - - // construct from pointer + length - constexpr span(pointer ptr, size_type size) noexcept : span(ptr, bounds_type{size}) {} - - // construct from pointer + length - multidimensional - constexpr span(pointer data, bounds_type bounds) noexcept : data_(data), - bounds_(std::move(bounds)) + template <size_t N, class ArrayElementType = std::remove_const_t<element_type>> + constexpr span(std::array<ArrayElementType, N>& arr) noexcept + : storage_(&arr[0], details::extent_type<N>()) { - Expects((bounds_.size() > 0 && data != nullptr) || bounds_.size() == 0); } - // construct from begin,end pointer pair - template <typename Ptr, - typename = std::enable_if_t<std::is_convertible<Ptr, pointer>::value && - details::LessThan<bounds_type::dynamic_rank, 2>::value>> - constexpr span(pointer begin, Ptr end) - : span(begin, details::newBoundsHelper<bounds_type>(static_cast<pointer>(end) - begin)) + template <size_t N> + constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr) noexcept + : storage_(&arr[0], details::extent_type<N>()) { - Expects(begin != nullptr && end != nullptr && begin <= static_cast<pointer>(end)); } - // construct from n-dimensions static array - template <typename T, size_t N, typename Helper = details::SpanArrayTraits<T, N>> - constexpr span(T (&arr)[N]) - : span(reinterpret_cast<pointer>(arr), bounds_type{typename Helper::bounds_type{}}) + // NB: the SFINAE here uses .data() as a incomplete/imperfect proxy for the requirement + // on Container to be a contiguous sequence container. + template <class Container, + class = std::enable_if_t< + !details::is_span<Container>::value && !details::is_std_array<Container>::value && + std::is_convertible<typename Container::pointer, pointer>::value && + std::is_convertible<typename Container::pointer, + decltype(std::declval<Container>().data())>::value>> + constexpr span(Container& cont) : span(cont.data(), cont.size()) { - static_assert( - std::is_convertible<typename Helper::value_type(*) [], value_type(*) []>::value, - "Cannot convert from source type to target span type."); - static_assert(std::is_convertible<typename Helper::bounds_type, bounds_type>::value, - "Cannot construct a span from an array with fewer elements."); } - // construct from n-dimensions dynamic array (e.g. new int[m][4]) - // (precedence will be lower than the 1-dimension pointer) - template <typename T, typename Helper = details::SpanArrayTraits<T, dynamic_range>> - constexpr span(T* const& data, size_type size) - : span(reinterpret_cast<pointer>(data), typename Helper::bounds_type{size}) + template <class Container, + class = std::enable_if_t< + std::is_const<element_type>::value && !details::is_span<Container>::value && + std::is_convertible<typename Container::pointer, pointer>::value && + std::is_convertible<typename Container::pointer, + decltype(std::declval<Container>().data())>::value>> + constexpr span(const Container& cont) : span(cont.data(), cont.size()) { - static_assert( - std::is_convertible<typename Helper::value_type(*) [], value_type(*) []>::value, - "Cannot convert from source type to target span type."); } - // construct from std::array - template <typename T, size_t N> - constexpr span(std::array<T, N>& arr) : span(arr.data(), bounds_type{static_bounds<N>{}}) - { - static_assert( - std::is_convertible<T(*) [], typename std::remove_const_t<value_type>(*) []>::value, - "Cannot convert from source type to target span type."); - static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value, - "You cannot construct a span from a std::array of smaller size."); - } + constexpr span(const span& other) noexcept = default; +#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + constexpr span(span&& other) noexcept = default; +#else + constexpr span(span&& other) noexcept : storage_(std::move(other.storage_)) {} +#endif - // construct from const std::array - template <typename T, size_t N> - constexpr span(const std::array<std::remove_const_t<value_type>, N>& arr) - : span(arr.data(), static_bounds<N>()) + template < + class OtherElementType, std::ptrdiff_t OtherExtent, + class = std::enable_if_t< + details::is_allowed_extent_conversion<OtherExtent, Extent>::value && + details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>> + constexpr span(const span<OtherElementType, OtherExtent>& other) + : storage_(reinterpret_cast<pointer>(other.data()), + details::extent_type<OtherExtent>(other.size())) { - static_assert(std::is_convertible<T(*) [], std::remove_const_t<value_type>>::value, - "Cannot convert from source type to target span type."); - static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value, - "You cannot construct a span from a std::array of smaller size."); } - // prevent constructing from temporary std::array - template <typename T, size_t N> - constexpr span(std::array<T, N>&& arr) = delete; - - // construct from containers - // future: could use contiguous_iterator_traits to identify only contiguous containers - // type-requirements: container must have .size(), operator[] which are value_type compatible - template <typename Cont, typename DataType = typename Cont::value_type, - typename = std::enable_if_t< - !details::is_span<Cont>::value && - std::is_convertible<DataType (*)[], value_type (*)[]>::value && - std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), - *std::declval<Cont>().data())>, - DataType>::value>> - constexpr span(Cont& cont) - : span(static_cast<pointer>(cont.data()), - details::newBoundsHelper<bounds_type>(narrow_cast<size_type>(cont.size()))) + template < + class OtherElementType, std::ptrdiff_t OtherExtent, + class = std::enable_if_t< + details::is_allowed_extent_conversion<OtherExtent, Extent>::value && + details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>> + constexpr span(span<OtherElementType, OtherExtent>&& other) + : storage_(reinterpret_cast<pointer>(other.data()), + details::extent_type<OtherExtent>(other.size())) { } - // prevent constructing from temporary containers - template <typename Cont, typename DataType = typename Cont::value_type, - typename = std::enable_if_t< - !details::is_span<Cont>::value && - std::is_convertible<DataType (*)[], value_type (*)[]>::value && - std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), - *std::declval<Cont>().data())>, - DataType>::value>> - explicit constexpr span(Cont&& cont) = delete; - - // construct from a convertible span - template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, - typename OtherBounds = static_bounds<OtherDimensions...>, - typename = std::enable_if_t<std::is_convertible<OtherValueType, ValueType>::value && - std::is_convertible<OtherBounds, bounds_type>::value>> - constexpr span(span<OtherValueType, OtherDimensions...> other) noexcept : data_(other.data_), - bounds_(other.bounds_) + ~span() noexcept = default; + constexpr span& operator=(const span& other) noexcept = default; + +#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + constexpr span& operator=(span&& other) noexcept = default; +#else + constexpr span& operator=(span&& other) noexcept { + storage_ = std::move(other.storage_); + return *this; } - -// trivial copy and move -#ifndef GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT - constexpr span(span&&) = default; #endif - constexpr span(const span&) = default; - -// trivial assignment -#ifndef GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT - constexpr span& operator=(span&&) = default; -#endif - constexpr span& operator=(const span&) = default; - - // first() - extract the first Count elements into a new span + // [span.sub], span subviews template <std::ptrdiff_t Count> - constexpr span<ValueType, Count> first() const noexcept + constexpr span<element_type, Count> first() const { - static_assert(Count >= 0, "Count must be >= 0."); - static_assert(bounds_type::static_size == dynamic_range || - Count <= bounds_type::static_size, - "Count is out of bounds."); - - Expects(bounds_type::static_size != dynamic_range || Count <= this->size()); - return {this->data(), Count}; + Expects(Count >= 0 && Count <= size()); + return {data(), Count}; } - // first() - extract the first count elements into a new span - constexpr span<ValueType, dynamic_range> first(size_type count) const noexcept - { - Expects(count >= 0 && count <= this->size()); - return {this->data(), count}; - } - - // last() - extract the last Count elements into a new span template <std::ptrdiff_t Count> - constexpr span<ValueType, Count> last() const noexcept + constexpr span<element_type, Count> last() const { - static_assert(Count >= 0, "Count must be >= 0."); - static_assert(bounds_type::static_size == dynamic_range || - Count <= bounds_type::static_size, - "Count is out of bounds."); - - Expects(bounds_type::static_size != dynamic_range || Count <= this->size()); - return {this->data() + this->size() - Count, Count}; + Expects(Count >= 0 && Count <= size()); + return {data() + (size() - Count), Count}; } - // last() - extract the last count elements into a new span - constexpr span<ValueType, dynamic_range> last(size_type count) const noexcept + template <std::ptrdiff_t Offset, std::ptrdiff_t Count = dynamic_extent> + constexpr span<element_type, Count> subspan() const { - Expects(count >= 0 && count <= this->size()); - return {this->data() + this->size() - count, count}; + Expects((Offset == 0 || (Offset > 0 && Offset <= size())) && + (Count == dynamic_extent || (Count >= 0 && Offset + Count <= size()))); + return {data() + Offset, Count == dynamic_extent ? size() - Offset : Count}; } - // subspan() - create a subview of Count elements starting at Offset - template <std::ptrdiff_t Offset, std::ptrdiff_t Count> - constexpr span<ValueType, Count> subspan() const noexcept + constexpr span<element_type, dynamic_extent> first(index_type count) const { - static_assert(Count >= 0, "Count must be >= 0."); - static_assert(Offset >= 0, "Offset must be >= 0."); - static_assert(bounds_type::static_size == dynamic_range || - ((Offset <= bounds_type::static_size) && - Count <= bounds_type::static_size - Offset), - "You must describe a sub-range within bounds of the span."); - - Expects(bounds_type::static_size != dynamic_range || - (Offset <= this->size() && Count <= this->size() - Offset)); - return {this->data() + Offset, Count}; + Expects(count >= 0 && count <= size()); + return {data(), count}; } - // subspan() - create a subview of count elements starting at offset - // supplying dynamic_range for count will consume all available elements from offset - constexpr span<ValueType, dynamic_range> subspan(size_type offset, - size_type count = dynamic_range) const noexcept + constexpr span<element_type, dynamic_extent> last(index_type count) const { - Expects((offset >= 0 && offset <= this->size()) && - (count == dynamic_range || (count <= this->size() - offset))); - return {this->data() + offset, count == dynamic_range ? this->length() - offset : count}; + Expects(count >= 0 && count <= size()); + return {data() + (size() - count), count}; } - // section - creates a non-contiguous, strided span from a contiguous one - constexpr strided_span<ValueType, Rank> section(index_type origin, index_type extents) const - noexcept + constexpr span<element_type, dynamic_extent> subspan(index_type offset, + index_type count = dynamic_extent) const { - size_type size = this->bounds().total_size() - this->bounds().linearize(origin); - return {&this->operator[](origin), size, - strided_bounds<Rank>{extents, details::make_stride(bounds())}}; + Expects((offset == 0 || (offset > 0 && offset <= size())) && + (count == dynamic_extent || (count >= 0 && offset + count <= size()))); + return {data() + offset, count == dynamic_extent ? size() - offset : count}; } - // length of the span in elements - constexpr size_type size() const noexcept { return bounds_.size(); } - - // length of the span in elements - constexpr size_type length() const noexcept { return this->size(); } - - // length of the span in bytes - constexpr size_type size_bytes() const noexcept { return sizeof(value_type) * this->size(); } - - // length of the span in bytes - constexpr size_type length_bytes() const noexcept { return this->size_bytes(); } - - constexpr bool empty() const noexcept { return this->size() == 0; } - - static constexpr std::size_t rank() { return Rank; } + // [span.obs], span observers + constexpr index_type length() const noexcept { return size(); } + constexpr index_type size() const noexcept { return storage_.size(); } + constexpr index_type length_bytes() const noexcept { return size_bytes(); } + constexpr index_type size_bytes() const noexcept { return size() * sizeof(element_type); } + constexpr bool empty() const noexcept { return size() == 0; } - template <size_t Dim = 0> - constexpr size_type extent() const noexcept + // [span.elem], span element access + constexpr reference operator[](index_type idx) const { - static_assert(Dim < Rank, - "Dimension should be less than rank (dimension count starts from 0)."); - return bounds_.template extent<Dim>(); + Expects(idx >= 0 && idx < storage_.size()); + return data()[idx]; } + constexpr reference operator()(index_type idx) const { return this->operator[](idx); } + constexpr pointer data() const noexcept { return storage_.data(); } - template <typename IntType> - constexpr size_type extent(IntType dim) const noexcept - { - return bounds_.extent(dim); - } - - constexpr bounds_type bounds() const noexcept { return bounds_; } + // [span.iter], span iterator support + iterator begin() const noexcept { return {this, 0}; } + iterator end() const noexcept { return {this, length()}; } - constexpr pointer data() const noexcept { return data_; } - - template <typename FirstIndex> - constexpr reference operator()(FirstIndex index) - { - return this->operator[](narrow_cast<std::ptrdiff_t>(index)); - } + const_iterator cbegin() const noexcept { return {this, 0}; } + const_iterator cend() const noexcept { return {this, length()}; } - template <typename FirstIndex, typename... OtherIndices> - constexpr reference operator()(FirstIndex index, OtherIndices... indices) - { - index_type idx = {narrow_cast<std::ptrdiff_t>(index), - narrow_cast<std::ptrdiff_t>(indices...)}; - return this->operator[](idx); - } + reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } + reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } - constexpr reference operator[](const index_type& idx) const noexcept - { - return data_[bounds_.linearize(idx)]; - } + const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator{cend()}; } + const_reverse_iterator crend() const noexcept { return const_reverse_iterator{cbegin()}; } - template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>> - constexpr Ret operator[](size_type idx) const noexcept - { - Expects(idx < bounds_.size()); // index is out of bounds of the array - const size_type ridx = idx * bounds_.stride(); - - // index is out of bounds of the underlying data - Expects(ridx < bounds_.total_size()); - return Ret{data_ + ridx, bounds_.slice()}; - } - - constexpr iterator begin() const noexcept { return iterator{this, true}; } - - constexpr iterator end() const noexcept { return iterator{this, false}; } - - constexpr const_iterator cbegin() const noexcept - { - return const_iterator{reinterpret_cast<const const_span*>(this), true}; - } - - constexpr const_iterator cend() const noexcept - { - return const_iterator{reinterpret_cast<const const_span*>(this), false}; - } - - constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } - - constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } - - constexpr const_reverse_iterator crbegin() const noexcept - { - return const_reverse_iterator{cend()}; - } - - constexpr const_reverse_iterator crend() const noexcept - { - return const_reverse_iterator{cbegin()}; - } - - template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator==(const span<OtherValueType, OtherDimensions...>& other) const noexcept - { - return bounds_.size() == other.bounds_.size() && - (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin())); - } - - template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator!=(const span<OtherValueType, OtherDimensions...>& other) const noexcept - { - return !(*this == other); - } - - template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator<(const span<OtherValueType, OtherDimensions...>& other) const noexcept - { - return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end()); - } +private: + // this implementation detail class lets us take advantage of the + // empty base class optimization to pay for only storage of a single + // pointer in the case of fixed-size spans + template <class ExtentType> + class storage_type : public ExtentType + { + public: + template <class OtherExtentType> + constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data) + { + Expects((!data && ExtentType::size() == 0) || (data && ExtentType::size() >= 0)); + } - template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator<=(const span<OtherValueType, OtherDimensions...>& other) const noexcept - { - return !(other < *this); - } + constexpr inline pointer data() const noexcept { return data_; } - template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator>(const span<OtherValueType, OtherDimensions...>& other) const noexcept - { - return (other < *this); - } + private: + pointer data_; + }; - template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator>=(const span<OtherValueType, OtherDimensions...>& other) const noexcept - { - return !(*this < other); - } + storage_type<details::extent_type<Extent>> storage_; }; -// -// Free functions for manipulating spans -// - -// reshape a span into a different dimensionality -// DimCount and Enabled here are workarounds for a bug in MSVC 2015 -template <typename SpanType, typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2), - bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>> -constexpr span<typename SpanType::value_type, Dimensions2::value...> as_span(SpanType s, - Dimensions2... dims) -{ - static_assert(details::is_span<SpanType>::value, - "Variadic as_span() is for reshaping existing spans."); - using BoundsType = - typename span<typename SpanType::value_type, (Dimensions2::value)...>::bounds_type; - auto tobounds = details::static_as_span_helper<BoundsType>(dims..., details::Sep{}); - details::verifyBoundsReshape(s.bounds(), tobounds); - return {s.data(), tobounds}; -} - -// convert a span<T> to a span<const byte> -template <typename U, std::ptrdiff_t... Dimensions> -span<const byte, dynamic_range> as_bytes(span<U, Dimensions...> s) noexcept -{ - static_assert(std::is_trivial<std::decay_t<U>>::value, - "The value_type of span must be a trivial type."); - return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; -} - -// convert a span<T> to a span<byte> (a writeable byte span) -// this is not currently a portable function that can be relied upon to work -// on all implementations. It should be considered an experimental extension -// to the standard GSL interface. -template <typename U, std::ptrdiff_t... Dimensions> -span<byte> as_writeable_bytes(span<U, Dimensions...> s) noexcept -{ - static_assert(std::is_trivial<std::decay_t<U>>::value, - "The value_type of span must be a trivial type."); - return {reinterpret_cast<byte*>(s.data()), s.size_bytes()}; -} - -// convert a span<const byte> to a span<const T> -// this is not currently a portable function that can be relied upon to work -// on all implementations. It should be considered an experimental extension -// to the standard GSL interface. -template <typename U, std::ptrdiff_t... Dimensions> -constexpr auto as_span(span<const byte, Dimensions...> s) noexcept - -> span<const U, static_cast<std::ptrdiff_t>( - span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range - ? (static_cast<size_t>( - span<const byte, Dimensions...>::bounds_type::static_size) / - sizeof(U)) - : dynamic_range)> -{ - using ConstByteSpan = span<const byte, Dimensions...>; - static_assert( - std::is_trivial<std::decay_t<U>>::value && - (ConstByteSpan::bounds_type::static_size == dynamic_range || - ConstByteSpan::bounds_type::static_size % narrow_cast<std::ptrdiff_t>(sizeof(U)) == 0), - "Target type must be a trivial type and its size must match the byte array size"); - - Expects((s.size_bytes() % sizeof(U)) == 0 && (s.size_bytes() / sizeof(U)) < PTRDIFF_MAX); - return {reinterpret_cast<const U*>(s.data()), - s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))}; -} - -// convert a span<byte> to a span<T> -// this is not currently a portable function that can be relied upon to work -// on all implementations. It should be considered an experimental extension -// to the standard GSL interface. -template <typename U, std::ptrdiff_t... Dimensions> -constexpr auto as_span(span<byte, Dimensions...> s) noexcept -> span< - U, narrow_cast<std::ptrdiff_t>( - span<byte, Dimensions...>::bounds_type::static_size != dynamic_range - ? static_cast<std::size_t>(span<byte, Dimensions...>::bounds_type::static_size) / - sizeof(U) - : dynamic_range)> +// [span.comparison], span comparison operators +template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondExtent> +constexpr bool operator==(const span<ElementType, FirstExtent>& l, + const span<ElementType, SecondExtent>& r) { - using ByteSpan = span<byte, Dimensions...>; - static_assert( - std::is_trivial<std::decay_t<U>>::value && - (ByteSpan::bounds_type::static_size == dynamic_range || - ByteSpan::bounds_type::static_size % static_cast<std::size_t>(sizeof(U)) == 0), - "Target type must be a trivial type and its size must match the byte array size"); - - Expects((s.size_bytes() % sizeof(U)) == 0); - return {reinterpret_cast<U*>(s.data()), - s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))}; -} - -template <typename T, std::ptrdiff_t... Dimensions> -constexpr auto as_span(T* const& ptr, dim<Dimensions>... args) - -> span<std::remove_all_extents_t<T>, Dimensions...> -{ - return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr), - details::static_as_span_helper<static_bounds<Dimensions...>>(args..., details::Sep{})}; -} - -template <typename T> -constexpr auto as_span(T* arr, std::ptrdiff_t len) -> - typename details::SpanArrayTraits<T, dynamic_range>::type -{ - return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len}; -} - -template <typename T, size_t N> -constexpr auto as_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type -{ - return {arr}; +#ifdef GSL_MSVC_NO_CPP14_STD_EQUAL + return (l.size() == r.size()) && std::equal(l.begin(), l.end(), r.begin()); +#else + return std::equal(l.begin(), l.end(), r.begin(), r.end()); +#endif } -template <typename T, size_t N> -constexpr span<const T, N> as_span(const std::array<T, N>& arr) +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) { - return {arr}; + return !(l == r); } -template <typename T, size_t N> -constexpr span<const T, N> as_span(const std::array<T, N>&&) = delete; - -template <typename T, size_t N> -constexpr span<T, N> as_span(std::array<T, N>& arr) +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) { - return {arr}; + return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end()); } -template <typename T> -constexpr span<T, dynamic_range> as_span(T* begin, T* end) +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) { - return {begin, end}; + return !(l > r); } -template <typename Cont> -constexpr auto as_span(Cont& arr) -> std::enable_if_t< - !details::is_span<std::decay_t<Cont>>::value, - span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) { - Expects(arr.size() < PTRDIFF_MAX); - return {arr.data(), narrow_cast<std::ptrdiff_t>(arr.size())}; + return r < l; } -template <typename Cont> -constexpr auto as_span(Cont&& arr) -> std::enable_if_t< - !details::is_span<std::decay_t<Cont>>::value, - span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete; - -// from basic_string which doesn't have nonconst .data() member like other contiguous containers -template <typename CharT, typename Traits, typename Allocator> -constexpr auto as_span(std::basic_string<CharT, Traits, Allocator>& str) - -> span<CharT, dynamic_range> +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) { - Expects(str.size() < PTRDIFF_MAX); - return {&str[0], narrow_cast<std::ptrdiff_t>(str.size())}; + return !(l < r); } -// strided_span is an extension that is not strictly part of the GSL at this time. -// It is kept here while the multidimensional interface is still being defined. -template <typename ValueType, size_t Rank> -class strided_span -{ -public: - using bounds_type = strided_bounds<Rank>; - using size_type = typename bounds_type::size_type; - using index_type = typename bounds_type::index_type; - using value_type = ValueType; - using const_value_type = std::add_const_t<value_type>; - using pointer = std::add_pointer_t<value_type>; - using reference = std::add_lvalue_reference_t<value_type>; - using iterator = general_span_iterator<strided_span>; - using const_strided_span = strided_span<const_value_type, Rank>; - using const_iterator = general_span_iterator<const_strided_span>; - using reverse_iterator = std::reverse_iterator<iterator>; - using const_reverse_iterator = std::reverse_iterator<const_iterator>; - using sliced_type = - std::conditional_t<Rank == 1, value_type, strided_span<value_type, Rank - 1>>; - -private: - pointer data_; - bounds_type bounds_; - - friend iterator; - friend const_iterator; - template <typename OtherValueType, size_t OtherRank> - friend class strided_span; - -public: - // from raw data - constexpr strided_span(pointer ptr, size_type size, bounds_type bounds) - : data_(ptr), bounds_(std::move(bounds)) - { - Expects((bounds_.size() > 0 && ptr != nullptr) || bounds_.size() == 0); - // Bounds cross data boundaries - Expects(this->bounds().total_size() <= size); - (void) size; - } - - // from static array of size N - template <size_type N> - constexpr strided_span(value_type (&values)[N], bounds_type bounds) - : strided_span(values, N, std::move(bounds)) - { - } - - // from array view - template <typename OtherValueType, std::ptrdiff_t... Dimensions, - bool Enabled1 = (sizeof...(Dimensions) == Rank), - bool Enabled2 = std::is_convertible<OtherValueType*, ValueType*>::value, - typename Dummy = std::enable_if_t<Enabled1 && Enabled2>> - constexpr strided_span(span<OtherValueType, Dimensions...> av, bounds_type bounds) - : strided_span(av.data(), av.bounds().total_size(), std::move(bounds)) - { - } - - // convertible - template <typename OtherValueType, typename Dummy = std::enable_if_t<std::is_convertible< - OtherValueType (*)[], value_type (*)[]>::value>> - constexpr strided_span(const strided_span<OtherValueType, Rank>& other) - : data_(other.data_), bounds_(other.bounds_) - { - } - - // convert from bytes - template <typename OtherValueType> - constexpr strided_span< - typename std::enable_if<std::is_same<value_type, const byte>::value, OtherValueType>::type, - Rank> - as_strided_span() const - { - static_assert((sizeof(OtherValueType) >= sizeof(value_type)) && - (sizeof(OtherValueType) % sizeof(value_type) == 0), - "OtherValueType should have a size to contain a multiple of ValueTypes"); - auto d = narrow_cast<size_type>(sizeof(OtherValueType) / sizeof(value_type)); - - size_type size = this->bounds().total_size() / d; - return {const_cast<OtherValueType*>(reinterpret_cast<const OtherValueType*>(this->data())), size, - bounds_type{resize_extent(this->bounds().index_bounds(), d), - resize_stride(this->bounds().strides(), d)}}; - } - - constexpr strided_span section(index_type origin, index_type extents) const - { - size_type size = this->bounds().total_size() - this->bounds().linearize(origin); - return {&this->operator[](origin), size, - bounds_type{extents, details::make_stride(bounds())}}; - } - - constexpr reference operator[](const index_type& idx) const - { - return data_[bounds_.linearize(idx)]; - } - - template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>> - constexpr Ret operator[](size_type idx) const - { - Expects(idx < bounds_.size()); // index is out of bounds of the array - const size_type ridx = idx * bounds_.stride(); - - // index is out of bounds of the underlying data - Expects(ridx < bounds_.total_size()); - return {data_ + ridx, bounds_.slice().total_size(), bounds_.slice()}; - } - - constexpr bounds_type bounds() const noexcept { return bounds_; } - - template <size_t Dim = 0> - constexpr size_type extent() const noexcept - { - static_assert(Dim < Rank, - "dimension should be less than Rank (dimension count starts from 0)"); - return bounds_.template extent<Dim>(); - } - - constexpr size_type size() const noexcept { return bounds_.size(); } - - constexpr pointer data() const noexcept { return data_; } - - constexpr explicit operator bool() const noexcept { return data_ != nullptr; } - - constexpr iterator begin() const { return iterator{this, true}; } - - constexpr iterator end() const { return iterator{this, false}; } - - constexpr const_iterator cbegin() const - { - return const_iterator{reinterpret_cast<const const_strided_span*>(this), true}; - } - - constexpr const_iterator cend() const - { - return const_iterator{reinterpret_cast<const const_strided_span*>(this), false}; - } - - constexpr reverse_iterator rbegin() const { return reverse_iterator{end()}; } - - constexpr reverse_iterator rend() const { return reverse_iterator{begin()}; } - - constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator{cend()}; } - - constexpr const_reverse_iterator crend() const { return const_reverse_iterator{cbegin()}; } - - template <typename OtherValueType, std::ptrdiff_t OtherRank, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator==(const strided_span<OtherValueType, OtherRank>& other) const noexcept - { - return bounds_.size() == other.bounds_.size() && - (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin())); - } - - template <typename OtherValueType, std::ptrdiff_t OtherRank, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator!=(const strided_span<OtherValueType, OtherRank>& other) const noexcept - { - return !(*this == other); - } - - template <typename OtherValueType, std::ptrdiff_t OtherRank, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator<(const strided_span<OtherValueType, OtherRank>& other) const noexcept - { - return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end()); - } - - template <typename OtherValueType, std::ptrdiff_t OtherRank, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator<=(const strided_span<OtherValueType, OtherRank>& other) const noexcept - { - return !(other < *this); - } - - template <typename OtherValueType, std::ptrdiff_t OtherRank, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator>(const strided_span<OtherValueType, OtherRank>& other) const noexcept - { - return (other < *this); - } - - template <typename OtherValueType, std::ptrdiff_t OtherRank, - typename Dummy = std::enable_if_t<std::is_same< - std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> - constexpr bool operator>=(const strided_span<OtherValueType, OtherRank>& other) const noexcept - { - return !(*this < other); - } - -private: - static index_type resize_extent(const index_type& extent, std::ptrdiff_t d) - { - // The last dimension of the array needs to contain a multiple of new type elements - Expects(extent[Rank - 1] >= d && (extent[Rank - 1] % d == 0)); - - index_type ret = extent; - ret[Rank - 1] /= d; - - return ret; - } - - template <bool Enabled = (Rank == 1), typename Dummy = std::enable_if_t<Enabled>> - static index_type resize_stride(const index_type& strides, std::ptrdiff_t, void* = 0) - { - // Only strided arrays with regular strides can be resized - Expects(strides[Rank - 1] == 1); - - return strides; - } - - template <bool Enabled = (Rank > 1), typename Dummy = std::enable_if_t<Enabled>> - static index_type resize_stride(const index_type& strides, std::ptrdiff_t d) - { - // Only strided arrays with regular strides can be resized - Expects(strides[Rank - 1] == 1); - // The strides must have contiguous chunks of - // memory that can contain a multiple of new type elements - Expects(strides[Rank - 2] >= d && (strides[Rank - 2] % d == 0)); - - for (size_t i = Rank - 1; i > 0; --i) { - // Only strided arrays with regular strides can be resized - Expects((strides[i - 1] >= strides[i]) && (strides[i - 1] % strides[i] == 0)); - } - - index_type ret = strides / d; - ret[Rank - 1] = 1; - - return ret; - } -}; - -template <class Span> -class contiguous_span_iterator - : public std::iterator<std::random_access_iterator_tag, typename Span::value_type> +namespace details { - using Base = std::iterator<std::random_access_iterator_tag, typename Span::value_type>; - -public: - using typename Base::reference; - using typename Base::pointer; - using typename Base::difference_type; + // if we only supported compilers with good constexpr support then + // this pair of classes could collapse down to a constexpr function -private: - template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> - friend class span; - - pointer data_; - const Span* m_validator; - void validateThis() const + // we should use a narrow_cast<> to go to size_t, but older compilers may not see it as + // constexpr + // and so will fail compilation of the template + template <class ElementType, std::ptrdiff_t Extent> + struct calculate_byte_size + : std::integral_constant<std::ptrdiff_t, + static_cast<std::ptrdiff_t>(sizeof(ElementType) * + static_cast<std::size_t>(Extent))> { - // iterator is out of range of the array - Expects(data_ >= m_validator->data_ && data_ < m_validator->data_ + m_validator->size()); - } - contiguous_span_iterator(const Span* container, bool isbegin) - : data_(isbegin ? container->data_ : container->data_ + container->size()) - , m_validator(container) - { - } + }; -public: - reference operator*() const noexcept - { - validateThis(); - return *data_; - } - pointer operator->() const noexcept - { - validateThis(); - return data_; - } - contiguous_span_iterator& operator++() noexcept - { - ++data_; - return *this; - } - contiguous_span_iterator operator++(int) noexcept - { - auto ret = *this; - ++(*this); - return ret; - } - contiguous_span_iterator& operator--() noexcept - { - --data_; - return *this; - } - contiguous_span_iterator operator--(int) noexcept - { - auto ret = *this; - --(*this); - return ret; - } - contiguous_span_iterator operator+(difference_type n) const noexcept - { - contiguous_span_iterator ret{*this}; - return ret += n; - } - contiguous_span_iterator& operator+=(difference_type n) noexcept - { - data_ += n; - return *this; - } - contiguous_span_iterator operator-(difference_type n) const noexcept - { - contiguous_span_iterator ret{*this}; - return ret -= n; - } - contiguous_span_iterator& operator-=(difference_type n) noexcept { return * this += -n; } - difference_type operator-(const contiguous_span_iterator& rhs) const noexcept - { - Expects(m_validator == rhs.m_validator); - return data_ - rhs.data_; - } - reference operator[](difference_type n) const noexcept { return *(*this + n); } - bool operator==(const contiguous_span_iterator& rhs) const noexcept + template <class ElementType> + struct calculate_byte_size<ElementType, dynamic_extent> + : std::integral_constant<std::ptrdiff_t, dynamic_extent> { - Expects(m_validator == rhs.m_validator); - return data_ == rhs.data_; - } - bool operator!=(const contiguous_span_iterator& rhs) const noexcept { return !(*this == rhs); } - bool operator<(const contiguous_span_iterator& rhs) const noexcept - { - Expects(m_validator == rhs.m_validator); - return data_ < rhs.data_; - } - bool operator<=(const contiguous_span_iterator& rhs) const noexcept { return !(rhs < *this); } - bool operator>(const contiguous_span_iterator& rhs) const noexcept { return rhs < *this; } - bool operator>=(const contiguous_span_iterator& rhs) const noexcept { return !(rhs > *this); } - void swap(contiguous_span_iterator& rhs) noexcept - { - std::swap(data_, rhs.data_); - std::swap(m_validator, rhs.m_validator); - } -}; - -template <typename Span> -contiguous_span_iterator<Span> operator+(typename contiguous_span_iterator<Span>::difference_type n, - const contiguous_span_iterator<Span>& rhs) noexcept -{ - return rhs + n; + }; } -template <typename Span> -class general_span_iterator - : public std::iterator<std::random_access_iterator_tag, typename Span::value_type> +// [span.objectrep], views of object representation +template <class ElementType, std::ptrdiff_t Extent> +span<const byte, details::calculate_byte_size<ElementType, Extent>::value> +as_bytes(span<ElementType, Extent> s) noexcept { - using Base = std::iterator<std::random_access_iterator_tag, typename Span::value_type>; - -public: - using typename Base::reference; - using typename Base::pointer; - using typename Base::difference_type; - using typename Base::value_type; - -private: - template <typename ValueType, size_t Rank> - friend class strided_span; - - const Span* m_container; - typename Span::bounds_type::iterator m_itr; - general_span_iterator(const Span* container, bool isbegin) - : m_container(container) - , m_itr(isbegin ? m_container->bounds().begin() : m_container->bounds().end()) - { - } - -public: - reference operator*() noexcept { return (*m_container)[*m_itr]; } - pointer operator->() noexcept { return &(*m_container)[*m_itr]; } - general_span_iterator& operator++() noexcept - { - ++m_itr; - return *this; - } - general_span_iterator operator++(int) noexcept - { - auto ret = *this; - ++(*this); - return ret; - } - general_span_iterator& operator--() noexcept - { - --m_itr; - return *this; - } - general_span_iterator operator--(int) noexcept - { - auto ret = *this; - --(*this); - return ret; - } - general_span_iterator operator+(difference_type n) const noexcept - { - general_span_iterator ret{*this}; - return ret += n; - } - general_span_iterator& operator+=(difference_type n) noexcept - { - m_itr += n; - return *this; - } - general_span_iterator operator-(difference_type n) const noexcept - { - general_span_iterator ret{*this}; - return ret -= n; - } - general_span_iterator& operator-=(difference_type n) noexcept { return * this += -n; } - difference_type operator-(const general_span_iterator& rhs) const noexcept - { - Expects(m_container == rhs.m_container); - return m_itr - rhs.m_itr; - } - value_type operator[](difference_type n) const noexcept - { - return (*m_container)[m_itr[n]]; - ; - } - bool operator==(const general_span_iterator& rhs) const noexcept - { - Expects(m_container == rhs.m_container); - return m_itr == rhs.m_itr; - } - bool operator!=(const general_span_iterator& rhs) const noexcept { return !(*this == rhs); } - bool operator<(const general_span_iterator& rhs) const noexcept - { - Expects(m_container == rhs.m_container); - return m_itr < rhs.m_itr; - } - bool operator<=(const general_span_iterator& rhs) const noexcept { return !(rhs < *this); } - bool operator>(const general_span_iterator& rhs) const noexcept { return rhs < *this; } - bool operator>=(const general_span_iterator& rhs) const noexcept { return !(rhs > *this); } - void swap(general_span_iterator& rhs) noexcept - { - std::swap(m_itr, rhs.m_itr); - std::swap(m_container, rhs.m_container); - } -}; + return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; +} -template <typename Span> -general_span_iterator<Span> operator+(typename general_span_iterator<Span>::difference_type n, - const general_span_iterator<Span>& rhs) noexcept +template <class ElementType, std::ptrdiff_t Extent, + class = std::enable_if_t<!std::is_const<ElementType>::value>> +span<byte, details::calculate_byte_size<ElementType, Extent>::value> +as_writeable_bytes(span<ElementType, Extent> s) noexcept { - return rhs + n; + return {reinterpret_cast<byte*>(s.data()), s.size_bytes()}; } } // namespace gsl @@ -2210,6 +801,8 @@ general_span_iterator<Span> operator+(typename general_span_iterator<Span>::diff #pragma pop_macro("noexcept") #endif // GSL_THROW_ON_CONTRACT_VIOLATION +#pragma pop_macro("alignof") + #undef GSL_MSVC_HAS_VARIADIC_CTOR_BUG #endif // _MSC_VER <= 1800 diff --git a/include/string_span.h b/include/string_span.h index fdcbf31..e18e07a 100644 --- a/include/string_span.h +++ b/include/string_span.h @@ -22,6 +22,7 @@ #include "gsl_assert.h" #include "gsl_util.h" #include "span.h" +#include <cstdint> #include <cstring> #include <string> @@ -36,8 +37,7 @@ // blanket turn off warnings from CppCoreCheck for now // so people aren't annoyed by them when running the tool. // more targeted suppressions will be added in a future update to the GSL -#pragma warning(disable: 26481 26482 26483 26485 26490 26491 26492 26493 26495) - +#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495) // VS 2013 workarounds #if _MSC_VER <= 1800 @@ -80,19 +80,19 @@ namespace gsl // (sometimes needlessly) break existing programs when introduced. // -template<typename CharT, std::ptrdiff_t Extent = dynamic_range> +template <typename CharT, std::ptrdiff_t Extent = dynamic_extent> using basic_zstring = CharT*; -template<std::ptrdiff_t Extent = dynamic_range> +template <std::ptrdiff_t Extent = dynamic_extent> using czstring = basic_zstring<const char, Extent>; -template<std::ptrdiff_t Extent = dynamic_range> +template <std::ptrdiff_t Extent = dynamic_extent> using cwzstring = basic_zstring<const wchar_t, Extent>; -template<std::ptrdiff_t Extent = dynamic_range> +template <std::ptrdiff_t Extent = dynamic_extent> using zstring = basic_zstring<char, Extent>; -template<std::ptrdiff_t Extent = dynamic_range> +template <std::ptrdiff_t Extent = dynamic_extent> using wzstring = basic_zstring<wchar_t, Extent>; // @@ -103,85 +103,93 @@ using wzstring = basic_zstring<wchar_t, Extent>; // // Will fail-fast if sentinel cannot be found before max elements are examined. // -template<typename T, const T Sentinel> -span<T, dynamic_range> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX) +template <typename T, const T Sentinel> +span<T, dynamic_extent> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX) { auto cur = seq; while ((cur - seq) < max && *cur != Sentinel) ++cur; Ensures(*cur == Sentinel); - return{ seq, cur - seq }; + return {seq, cur - seq}; } - // // ensure_z - creates a span for a czstring or cwzstring. // Will fail fast if a null-terminator cannot be found before // the limit of size_type. // -template<typename T> -inline span<T, dynamic_range> ensure_z(T* const & sz, std::ptrdiff_t max = PTRDIFF_MAX) +template <typename T> +inline span<T, dynamic_extent> ensure_z(T* const& sz, std::ptrdiff_t max = PTRDIFF_MAX) { return ensure_sentinel<T, 0>(sz, max); } -// TODO (neilmac) there is probably a better template-magic way to get the const and non-const overloads to share an implementation -inline span<char, dynamic_range> ensure_z(char* const& sz, std::ptrdiff_t max) +// TODO (neilmac) there is probably a better template-magic way to get the const and non-const +// overloads to share an implementation +inline span<char, dynamic_extent> ensure_z(char* const& sz, std::ptrdiff_t max) { auto len = strnlen(sz, narrow_cast<size_t>(max)); Ensures(sz[len] == 0); - return{ sz, static_cast<std::ptrdiff_t>(len) }; + return {sz, static_cast<std::ptrdiff_t>(len)}; } -inline span<const char, dynamic_range> ensure_z(const char* const& sz, std::ptrdiff_t max) +inline span<const char, dynamic_extent> ensure_z(const char* const& sz, std::ptrdiff_t max) { auto len = strnlen(sz, narrow_cast<size_t>(max)); Ensures(sz[len] == 0); - return{ sz, static_cast<std::ptrdiff_t>(len) }; + return {sz, static_cast<std::ptrdiff_t>(len)}; } -inline span<wchar_t, dynamic_range> ensure_z(wchar_t* const& sz, std::ptrdiff_t max) +inline span<wchar_t, dynamic_extent> ensure_z(wchar_t* const& sz, std::ptrdiff_t max) { auto len = wcsnlen(sz, narrow_cast<size_t>(max)); Ensures(sz[len] == 0); - return{ sz, static_cast<std::ptrdiff_t>(len) }; + return {sz, static_cast<std::ptrdiff_t>(len)}; } -inline span<const wchar_t, dynamic_range> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max) +inline span<const wchar_t, dynamic_extent> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max) { auto len = wcsnlen(sz, narrow_cast<size_t>(max)); Ensures(sz[len] == 0); - return{ sz, static_cast<std::ptrdiff_t>(len) }; + return {sz, static_cast<std::ptrdiff_t>(len)}; } -template<typename T, size_t N> -span<T, dynamic_range> ensure_z(T(&sz)[N]) { return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); } +template <typename T, size_t N> +span<T, dynamic_extent> ensure_z(T (&sz)[N]) +{ + return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); +} -template<class Cont> -span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_range> ensure_z(Cont& cont) +template <class Cont> +span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent> +ensure_z(Cont& cont) { return ensure_z(cont.data(), static_cast<std::ptrdiff_t>(cont.length())); } -template<typename CharT, std::ptrdiff_t> +template <typename CharT, std::ptrdiff_t> class basic_string_span; namespace details { template <typename T> struct is_basic_string_span_oracle : std::false_type - {}; + { + }; template <typename CharT, std::ptrdiff_t Extent> struct is_basic_string_span_oracle<basic_string_span<CharT, Extent>> : std::true_type - {}; + { + }; template <typename T> struct is_basic_string_span : is_basic_string_span_oracle<std::remove_cv_t<T>> - {}; + { + }; template <typename T> struct length_func - {}; + { + }; template <> struct length_func<char> @@ -220,53 +228,46 @@ namespace details }; } - // // string_span and relatives // -// Note that Extent is always single-dimension only -// -template <typename CharT, std::ptrdiff_t Extent = dynamic_range> +template <typename CharT, std::ptrdiff_t Extent = dynamic_extent> class basic_string_span { public: - using value_type = CharT; - using const_value_type = std::add_const_t<value_type>; - using pointer = std::add_pointer_t<value_type>; - using reference = std::add_lvalue_reference_t<value_type>; - using const_reference = std::add_lvalue_reference_t<const_value_type>; - using bounds_type = static_bounds<Extent>; - using impl_type = span<value_type, Extent>; + using element_type = CharT; + using pointer = std::add_pointer_t<element_type>; + using reference = std::add_lvalue_reference_t<element_type>; + using const_reference = std::add_lvalue_reference_t<std::add_const_t<element_type>>; + using impl_type = span<element_type, Extent>; - using size_type = ptrdiff_t; + using index_type = typename impl_type::index_type; using iterator = typename impl_type::iterator; using const_iterator = typename impl_type::const_iterator; using reverse_iterator = typename impl_type::reverse_iterator; using const_reverse_iterator = typename impl_type::const_reverse_iterator; // default (empty) - constexpr basic_string_span() = default; + constexpr basic_string_span() noexcept = default; // copy - constexpr basic_string_span(const basic_string_span& other) = default; + constexpr basic_string_span(const basic_string_span& other) noexcept = default; - // move +// move #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR - constexpr basic_string_span(basic_string_span&& other) = default; + constexpr basic_string_span(basic_string_span&& other) noexcept = default; #else - constexpr basic_string_span(basic_string_span&& other) - : span_(std::move(other.span_)) - {} + constexpr basic_string_span(basic_string_span&& other) : span_(std::move(other.span_)) {} #endif // assign - constexpr basic_string_span& operator=(const basic_string_span& other) = default; + constexpr basic_string_span& operator=(const basic_string_span& other) noexcept = default; - // move assign +// move assign #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR - constexpr basic_string_span& operator=(basic_string_span&& other) = default; + constexpr basic_string_span& operator=(basic_string_span&& other) noexcept = default; #else - constexpr basic_string_span& operator=(basic_string_span&& other) + constexpr basic_string_span& operator=(basic_string_span&& other) noexcept { span_ = std::move(other.span_); return *this; @@ -274,211 +275,137 @@ public: #endif // from nullptr - constexpr basic_string_span(std::nullptr_t ptr) noexcept - : span_(ptr) - {} + constexpr basic_string_span(std::nullptr_t ptr) noexcept : span_(ptr) {} - // from nullptr and length - constexpr basic_string_span(std::nullptr_t ptr, size_type length) noexcept - : span_(ptr, length) - {} + constexpr basic_string_span(pointer ptr, index_type length) : span_(ptr, length) {} + constexpr basic_string_span(pointer firstElem, pointer lastElem) : span_(firstElem, lastElem) {} // From static arrays - if 0-terminated, remove 0 from the view - - // from static arrays and string literals - template<size_t N> - constexpr basic_string_span(value_type(&arr)[N]) noexcept - : span_(remove_z(arr)) - {} - - // Those allow 0s within the length, so we do not remove them - - // from raw data and length - constexpr basic_string_span(pointer ptr, size_type length) noexcept - : span_(ptr, length) - {} - - // from string - constexpr basic_string_span(std::string& s) noexcept - : span_(const_cast<pointer>(s.data()), narrow_cast<std::ptrdiff_t>(s.length())) - {} - - // from containers. Containers must have .size() and .data() function signatures - template <typename Cont, typename DataType = typename Cont::value_type, - typename Dummy = std::enable_if_t<!details::is_span<Cont>::value - && !details::is_basic_string_span<Cont>::value - && !(!std::is_const<value_type>::value && std::is_const<Cont>::value) // no converting const containers to non-const span - && std::is_convertible<DataType*, value_type*>::value - && std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), *std::declval<Cont>().data())>, DataType>::value> - > - constexpr basic_string_span(Cont& cont) - : span_(cont.data(), cont.size()) - {} - - // disallow creation from temporary containers and strings - template <typename Cont, typename DataType = typename Cont::value_type, - typename Dummy = std::enable_if_t<!details::is_span<Cont>::value - && !details::is_basic_string_span<Cont>::value - && std::is_convertible<DataType*, value_type*>::value - && std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), *std::declval<Cont>().data())>, DataType>::value> - > - basic_string_span(Cont&& cont) = delete; - -#ifndef GSL_MSVC_HAS_SFINAE_SUBSTITUTION_ICE - // from span - template <typename OtherValueType, std::ptrdiff_t OtherExtent, - typename Dummy = std::enable_if_t< - std::is_convertible<OtherValueType*, value_type*>::value - && std::is_convertible<static_bounds<OtherExtent>, bounds_type>::value> - > - constexpr basic_string_span(span<OtherValueType, OtherExtent> other) noexcept - : span_(other) - {} -#else - // from span - constexpr basic_string_span(span<value_type, Extent> other) noexcept - : span_(other) - {} - - template <typename Dummy = std::enable_if_t<!std::is_same<std::remove_const_t<value_type>, value_type>::value>> - constexpr basic_string_span(span<std::remove_const_t<value_type>, Extent> other) noexcept - : span_(other) - {} -#endif - - // from string_span - template <typename OtherValueType, std::ptrdiff_t OtherExtent, - typename OtherBounds = static_bounds<OtherExtent>, - typename Dummy = std::enable_if_t<std::is_convertible<OtherValueType*, value_type*>::value && std::is_convertible<OtherBounds, bounds_type>::value> - > - constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other) noexcept - : span_(other.data(), other.length()) - {} - - constexpr bool empty() const noexcept + // All other containers allow 0s within the length, so we do not remove them + template <size_t N> + constexpr basic_string_span(element_type (&arr)[N]) : span_(remove_z(arr)) { - return length() == 0; } - // first Count elements - template<size_type Count> - constexpr basic_string_span<value_type, Count> first() const noexcept + template <size_t N, class ArrayElementType = std::remove_const_t<element_type>> + constexpr basic_string_span(std::array<ArrayElementType, N>& arr) noexcept : span_(arr) { - return{ span_.template first<Count>() }; } - constexpr basic_string_span<value_type, dynamic_range> first(size_type count) const noexcept + template <size_t N, class ArrayElementType = std::remove_const_t<element_type>> + constexpr basic_string_span(const std::array<ArrayElementType, N>& arr) noexcept : span_(arr) { - return{ span_.first(count) }; } - // last Count elements - template<size_type Count> - constexpr basic_string_span<value_type, Count> last() const noexcept + // Container signature should work for basic_string after C++17 version exists + template <class Traits, class Allocator> + constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator>& str) + : span_(&str[0], str.length()) { - return{ span_.template last<Count>() }; } - constexpr basic_string_span<value_type, dynamic_range> last(size_type count) const noexcept + template <class Traits, class Allocator> + constexpr basic_string_span(const std::basic_string<element_type, Traits, Allocator>& str) + : span_(&str[0], str.length()) { - return{ span_.last(count) }; } - // create a subview of Count elements starting from Offset - template<size_type Offset, size_type Count> - constexpr basic_string_span<value_type, Count> subspan() const noexcept + // from containers. Containers must have a pointer type and data() function signatures + template <class Container, + class = std::enable_if_t< + !details::is_basic_string_span<Container>::value && + std::is_convertible<typename Container::pointer, pointer>::value && + std::is_convertible<typename Container::pointer, + decltype(std::declval<Container>().data())>::value>> + constexpr basic_string_span(Container& cont) : span_(cont) { - return{ span_.template subspan<Offset, Count>() }; } - constexpr basic_string_span<value_type, dynamic_range> subspan(size_type offset, size_type count = dynamic_range) const noexcept + template <class Container, + class = std::enable_if_t< + !details::is_basic_string_span<Container>::value && + std::is_convertible<typename Container::pointer, pointer>::value && + std::is_convertible<typename Container::pointer, + decltype(std::declval<Container>().data())>::value>> + constexpr basic_string_span(const Container& cont) : span_(cont) { - return{ span_.subspan(offset, count) }; } - constexpr reference operator[](size_type idx) const noexcept + // from string_span + template < + class OtherValueType, std::ptrdiff_t OtherExtent, + class = std::enable_if_t<std::is_convertible< + typename basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value>> + constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other) + : span_(other.data(), other.length()) { - return span_[idx]; } - constexpr pointer data() const noexcept + template <index_type Count> + constexpr basic_string_span<element_type, Count> first() const { - return span_.data(); + return {span_.template first<Count>()}; } - // length of the span in elements - constexpr size_type length() const noexcept + constexpr basic_string_span<element_type, dynamic_extent> first(index_type count) const { - return span_.size(); + return {span_.first(count)}; } - // length of the span in elements - constexpr size_type size() const noexcept + template <index_type Count> + constexpr basic_string_span<element_type, Count> last() const { - return span_.size(); + return {span_.template last<Count>()}; } - // length of the span in bytes - constexpr size_type size_bytes() const noexcept + constexpr basic_string_span<element_type, dynamic_extent> last(index_type count) const { - return span_.size_bytes(); + return {span_.last(count)}; } - // length of the span in bytes - constexpr size_type length_bytes() const noexcept + template <index_type Offset, index_type Count> + constexpr basic_string_span<element_type, Count> subspan() const { - return span_.length_bytes(); + return {span_.template subspan<Offset, Count>()}; } - constexpr iterator begin() const noexcept + constexpr basic_string_span<element_type, dynamic_extent> + subspan(index_type offset, index_type count = dynamic_extent) const { - return span_.begin(); + return {span_.subspan(offset, count)}; } - constexpr iterator end() const noexcept - { - return span_.end(); - } + constexpr reference operator[](index_type idx) const { return span_[idx]; } + constexpr reference operator()(index_type idx) const { return span_[idx]; } - constexpr const_iterator cbegin() const noexcept - { - return span_.cbegin(); - } + constexpr pointer data() const { return span_.data(); } - constexpr const_iterator cend() const noexcept - { - return span_.cend(); - } + constexpr index_type length() const noexcept { return span_.size(); } + constexpr index_type size() const noexcept { return span_.size(); } + constexpr index_type size_bytes() const noexcept { return span_.size_bytes(); } + constexpr index_type length_bytes() const noexcept { return span_.length_bytes(); } + constexpr bool empty() const noexcept { return size() == 0; } - constexpr reverse_iterator rbegin() const noexcept - { - return span_.rbegin(); - } + constexpr iterator begin() const noexcept { return span_.begin(); } + constexpr iterator end() const noexcept { return span_.end(); } - constexpr reverse_iterator rend() const noexcept - { - return span_.rend(); - } + constexpr const_iterator cbegin() const noexcept { return span_.cbegin(); } + constexpr const_iterator cend() const noexcept { return span_.cend(); } - constexpr const_reverse_iterator crbegin() const noexcept - { - return span_.crbegin(); - } + constexpr reverse_iterator rbegin() const noexcept { return span_.rbegin(); } + constexpr reverse_iterator rend() const noexcept { return span_.rend(); } - constexpr const_reverse_iterator crend() const noexcept - { - return span_.crend(); - } + constexpr const_reverse_iterator crbegin() const noexcept { return span_.crbegin(); } + constexpr const_reverse_iterator crend() const noexcept { return span_.crend(); } private: - - static impl_type remove_z(pointer const& sz, std::ptrdiff_t max) noexcept + static impl_type remove_z(pointer const& sz, std::ptrdiff_t max) { - return{ sz, details::length_func<value_type>()(sz, max)}; + return {sz, details::length_func<element_type>()(sz, max)}; } - template<size_t N> - static impl_type remove_z(value_type(&sz)[N]) noexcept + template <size_t N> + static impl_type remove_z(element_type (&sz)[N]) { return remove_z(&sz[0], narrow_cast<std::ptrdiff_t>(N)); } @@ -486,16 +413,16 @@ private: impl_type span_; }; -template<std::ptrdiff_t Extent = dynamic_range> +template <std::ptrdiff_t Extent = dynamic_extent> using string_span = basic_string_span<char, Extent>; -template<std::ptrdiff_t Extent = dynamic_range> +template <std::ptrdiff_t Extent = dynamic_extent> using cstring_span = basic_string_span<const char, Extent>; -template<std::ptrdiff_t Extent = dynamic_range> +template <std::ptrdiff_t Extent = dynamic_extent> using wstring_span = basic_string_span<wchar_t, Extent>; -template<std::ptrdiff_t Extent = dynamic_range> +template <std::ptrdiff_t Extent = dynamic_extent> using cwstring_span = basic_string_span<const wchar_t, Extent>; // @@ -503,39 +430,40 @@ using cwstring_span = basic_string_span<const wchar_t, Extent>; // #ifndef GSL_MSVC_HAS_TYPE_DEDUCTION_BUG -template<typename CharT, ptrdiff_t Extent> -std::basic_string<typename std::remove_const<CharT>::type> to_string(basic_string_span<CharT, Extent> view) +template <typename CharT, std::ptrdiff_t Extent> +std::basic_string<typename std::remove_const<CharT>::type> +to_string(basic_string_span<CharT, Extent> view) { - return{ view.data(), static_cast<size_t>(view.length()) }; + return {view.data(), static_cast<size_t>(view.length())}; } #else inline std::string to_string(cstring_span<> view) { - return{ view.data(), static_cast<size_t>(view.length()) }; + return {view.data(), static_cast<size_t>(view.length())}; } inline std::string to_string(string_span<> view) { - return{ view.data(), static_cast<size_t>(view.length()) }; + return {view.data(), static_cast<size_t>(view.length())}; } inline std::wstring to_string(cwstring_span<> view) { - return{ view.data(), static_cast<size_t>(view.length()) }; + return {view.data(), static_cast<size_t>(view.length())}; } inline std::wstring to_string(wstring_span<> view) { - return{ view.data(), static_cast<size_t>(view.length()) }; + return {view.data(), static_cast<size_t>(view.length())}; } #endif // zero-terminated string span, used to convert // zero-terminated spans to legacy strings -template<typename CharT, std::ptrdiff_t Extent = dynamic_range> +template <typename CharT, std::ptrdiff_t Extent = dynamic_extent> class basic_zstring_span { public: @@ -551,29 +479,26 @@ public: using impl_type = span<value_type, Extent>; using string_span_type = basic_string_span<value_type, Extent>; - constexpr basic_zstring_span(impl_type span) noexcept - : span_(span) + constexpr basic_zstring_span(impl_type s) noexcept : span_(s) { // expects a zero-terminated span - Expects(span[span.size() - 1] == '\0'); + Expects(s[s.size() - 1] == '\0'); } // copy constexpr basic_zstring_span(const basic_zstring_span& other) = default; - // move +// move #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR constexpr basic_zstring_span(basic_zstring_span&& other) = default; #else - constexpr basic_zstring_span(basic_zstring_span&& other) - : span_(std::move(other.span_)) - {} + constexpr basic_zstring_span(basic_zstring_span&& other) : span_(std::move(other.span_)) {} #endif // assign constexpr basic_zstring_span& operator=(const basic_zstring_span& other) = default; - // move assign +// move assign #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR constexpr basic_zstring_span& operator=(basic_zstring_span&& other) = default; #else @@ -586,7 +511,10 @@ public: constexpr bool empty() const noexcept { return span_.size() == 0; } - constexpr string_span_type as_string_span() const noexcept { return span_.first(span_.size()-1); } + constexpr string_span_type as_string_span() const noexcept + { + return span_.first(span_.size() - 1); + } constexpr string_span_type ensure_z() const noexcept { return gsl::ensure_z(span_); } @@ -596,28 +524,26 @@ private: impl_type span_; }; -template <std::ptrdiff_t Max = dynamic_range> +template <std::ptrdiff_t Max = dynamic_extent> using zstring_span = basic_zstring_span<char, Max>; -template <std::ptrdiff_t Max = dynamic_range> +template <std::ptrdiff_t Max = dynamic_extent> using wzstring_span = basic_zstring_span<wchar_t, Max>; -template <std::ptrdiff_t Max = dynamic_range> +template <std::ptrdiff_t Max = dynamic_extent> using czstring_span = basic_zstring_span<const char, Max>; -template <std::ptrdiff_t Max = dynamic_range> +template <std::ptrdiff_t Max = dynamic_extent> using cwzstring_span = basic_zstring_span<const wchar_t, Max>; -} // namespace GSL - // operator == -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value> -> -bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept +template <class CharT, std::ptrdiff_t Extent, class T, + class = std::enable_if_t< + details::is_basic_string_span<T>::value || + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>> +bool operator==(const gsl::basic_string_span<CharT, Extent>& one, const T& other) noexcept { - gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other); + gsl::basic_string_span<std::add_const_t<CharT>> tmp(other); #ifdef GSL_MSVC_NO_CPP14_STD_EQUAL return (one.size() == tmp.size()) && std::equal(one.begin(), one.end(), tmp.begin()); #else @@ -625,14 +551,13 @@ bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc #endif } -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename Dummy = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value - && !gsl::details::is_basic_string_span<T>::value> -> -bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept +template <class CharT, std::ptrdiff_t Extent, class T, + class = std::enable_if_t< + !details::is_basic_string_span<T>::value && + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>> +bool operator==(const T& one, const gsl::basic_string_span<CharT, Extent>& other) noexcept { - gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one); + gsl::basic_string_span<std::add_const_t<CharT>> tmp(one); #ifdef GSL_MSVC_NO_CPP14_STD_EQUAL return (tmp.size() == other.size()) && std::equal(tmp.begin(), tmp.end(), other.begin()); #else @@ -640,141 +565,73 @@ bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc #endif } -#ifndef _MSC_VER - -// VS treats temp and const containers as convertible to basic_string_span, -// so the cases below are already covered by the previous operators - -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename DataType = typename T::value_type, - typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> -bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept -{ - gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other); - return std::equal(one.begin(), one.end(), tmp.begin(), tmp.end()); -} - -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename DataType = typename T::value_type, - typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> -bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept -{ - gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one); - return std::equal(tmp.begin(), tmp.end(), other.begin(), other.end()); -} -#endif - // operator != -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value> -> +template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename = std::enable_if_t<std::is_convertible< + T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>> bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept { return !(one == other); } -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename Dummy = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value - && !gsl::details::is_basic_string_span<T>::value> -> + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value && + !gsl::details::is_basic_string_span<T>::value>> bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept { return !(one == other); } -#ifndef _MSC_VER - -// VS treats temp and const containers as convertible to basic_string_span, -// so the cases below are already covered by the previous operators - -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename DataType = typename T::value_type, - typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> -bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept -{ - return !(one == other); -} - -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename DataType = typename T::value_type, - typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> -bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept -{ - return !(one == other); -} -#endif - // operator< -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value> -> +template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename = std::enable_if_t<std::is_convertible< + T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>> bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept { gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other); return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end()); } -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename Dummy = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value - && !gsl::details::is_basic_string_span<T>::value> -> + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value && + !gsl::details::is_basic_string_span<T>::value>> bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept { gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one); return std::lexicographical_compare(tmp.begin(), tmp.end(), other.begin(), other.end()); } -#ifndef _MSC_VER +#ifndef _MSC_VER // VS treats temp and const containers as convertible to basic_string_span, // so the cases below are already covered by the previous operators -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename DataType = typename T::value_type, typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept { gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other); return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end()); } -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename DataType = typename T::value_type, typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept { gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one); @@ -783,51 +640,50 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexce #endif // operator <= -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value> -> +template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename = std::enable_if_t<std::is_convertible< + T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>> bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept { return !(other < one); } -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename Dummy = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value - && !gsl::details::is_basic_string_span<T>::value> -> + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value && + !gsl::details::is_basic_string_span<T>::value>> bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept { return !(other < one); } -#ifndef _MSC_VER +#ifndef _MSC_VER // VS treats temp and const containers as convertible to basic_string_span, // so the cases below are already covered by the previous operators -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename DataType = typename T::value_type, typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept { return !(other < one); } -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename DataType = typename T::value_type, typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept { return !(other < one); @@ -835,51 +691,50 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc #endif // operator> -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value> -> +template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename = std::enable_if_t<std::is_convertible< + T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>> bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept { return other < one; } -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename Dummy = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value - && !gsl::details::is_basic_string_span<T>::value> -> + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value && + !gsl::details::is_basic_string_span<T>::value>> bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept { return other < one; } -#ifndef _MSC_VER +#ifndef _MSC_VER // VS treats temp and const containers as convertible to basic_string_span, // so the cases below are already covered by the previous operators -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename DataType = typename T::value_type, typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept { return other < one; } -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename DataType = typename T::value_type, typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept { return other < one; @@ -887,56 +742,56 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexce #endif // operator >= -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, - typename = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value> -> +template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename = std::enable_if_t<std::is_convertible< + T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>> bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept { return !(one < other); } -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename Dummy = std::enable_if_t< - std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value - && !gsl::details::is_basic_string_span<T>::value> -> + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value && + !gsl::details::is_basic_string_span<T>::value>> bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept { return !(one < other); } -#ifndef _MSC_VER +#ifndef _MSC_VER // VS treats temp and const containers as convertible to basic_string_span, // so the cases below are already covered by the previous operators -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename DataType = typename T::value_type, typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept { return !(one < other); } -template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T, +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, typename DataType = typename T::value_type, typename Dummy = std::enable_if_t< - !gsl::details::is_span<T>::value - && !gsl::details::is_basic_string_span<T>::value - && std::is_convertible<DataType*, CharT*>::value - && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value> -> + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept { return !(one < other); } #endif +} // namespace GSL #ifdef _MSC_VER diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index e6527da..79931f7 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -33,7 +33,7 @@ else() endif() function(add_gsl_test name) - add_executable(${name} ${name}.cpp ../include/gsl.h ../include/gsl_assert.h ../include/gsl_util.h ../include/span.h ../include/string_span.h) + add_executable(${name} ${name}.cpp ../include/gsl.h ../include/gsl_assert.h ../include/gsl_util.h ../include/multi_span.h ../include/span.h ../include/string_span.h) target_link_libraries(${name} UnitTest++) install(TARGETS ${name} RUNTIME DESTINATION bin @@ -45,6 +45,7 @@ function(add_gsl_test name) endfunction() add_gsl_test(span_tests) +add_gsl_test(multi_span_tests) add_gsl_test(strided_span_tests) add_gsl_test(string_span_tests) add_gsl_test(at_tests) @@ -53,3 +54,4 @@ add_gsl_test(notnull_tests) add_gsl_test(assertion_tests) add_gsl_test(utils_tests) add_gsl_test(owner_tests) +add_gsl_test(byte_tests)
\ No newline at end of file diff --git a/tests/bounds_tests.cpp b/tests/bounds_tests.cpp index 0665260..736a85c 100644 --- a/tests/bounds_tests.cpp +++ b/tests/bounds_tests.cpp @@ -15,7 +15,7 @@ /////////////////////////////////////////////////////////////////////////////// #include <UnitTest++/UnitTest++.h> -#include <span.h> +#include <multi_span.h> #include <vector> using namespace std; @@ -58,7 +58,7 @@ SUITE(bounds_test) auto itr = bounds.begin(); (void)itr; #ifdef CONFIRM_COMPILATION_ERRORS - span<int, 4, dynamic_range, 2> av(nullptr, bounds); + multi_span<int, 4, dynamic_range, 2> av(nullptr, bounds); auto itr2 = av.cbegin(); diff --git a/tests/byte_tests.cpp b/tests/byte_tests.cpp new file mode 100644 index 0000000..5d4e7f6 --- /dev/null +++ b/tests/byte_tests.cpp @@ -0,0 +1,93 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl_byte.h> + +#include <iostream> +#include <list> +#include <map> +#include <memory> +#include <string> +#include <vector> + +using namespace std; +using namespace gsl; + +namespace +{ + +SUITE(byte_tests) +{ + TEST(construction) + { + { + byte b = static_cast<byte>(4); + CHECK(static_cast<unsigned char>(b) == 4); + } + + { + byte b = byte(12); + CHECK(static_cast<unsigned char>(b) == 12); + } + + // waiting for C++17 enum class direct initializer support + //{ + // byte b { 14 }; + // CHECK(static_cast<unsigned char>(b) == 14); + //} + } + + TEST(bitwise_operations) + { + byte b = byte(0xFF); + + byte a = byte(0x00); + CHECK((b | a) == byte(0xFF)); + CHECK(a == byte(0x00)); + + a |= b; + CHECK(a == byte(0xFF)); + + a = byte(0x01); + CHECK((b & a) == byte(0x01)); + + a &= b; + CHECK(a == byte(0x01)); + + CHECK((b ^ a) == byte(0xFE)); + + CHECK(a == byte(0x01)); + a ^= b; + CHECK(a == byte(0xFE)); + + a = byte(0x01); + CHECK(~a == byte(0xFE)); + + a = byte(0xFF); + CHECK((a << 4) == byte(0xF0)); + CHECK((a >> 4) == byte(0x0F)); + + a <<= 4; + CHECK(a == byte(0xF0)); + a >>= 4; + CHECK(a == byte(0x0F)); + } +} + +} + +int main(int, const char* []) { return UnitTest::RunAllTests(); } diff --git a/tests/multi_span_tests.cpp b/tests/multi_span_tests.cpp new file mode 100644 index 0000000..7432057 --- /dev/null +++ b/tests/multi_span_tests.cpp @@ -0,0 +1,1679 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <multi_span.h> + +#include <iostream> +#include <list> +#include <map> +#include <memory> +#include <string> +#include <vector> + +using namespace std; +using namespace gsl; + +namespace +{ +struct BaseClass +{ +}; +struct DerivedClass : BaseClass +{ +}; +} + +SUITE(multi_span_tests) +{ + + TEST(default_constructor) + { + { + multi_span<int> s; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int> cs; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + multi_span<int, 0> s; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int, 0> cs; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 1> s; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile +#endif + } + + { + multi_span<int> s{}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int> cs{}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_nullptr_constructor) + { + { + multi_span<int> s = nullptr; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int> cs = nullptr; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + multi_span<int, 0> s = nullptr; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int, 0> cs = nullptr; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 1> s = nullptr; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile +#endif + } + + { + multi_span<int> s{nullptr}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int> cs{nullptr}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + multi_span<int*> s{nullptr}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int*> cs{nullptr}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_nullptr_length_constructor) + { + { + multi_span<int> s{nullptr, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int> cs{nullptr, 0}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + multi_span<int, 0> s{nullptr, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int, 0> cs{nullptr, 0}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 1> s{nullptr, 0}; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile +#endif + } + + { + auto workaround_macro = []() { multi_span<int> s{nullptr, 1}; }; + CHECK_THROW(workaround_macro(), fail_fast); + + auto const_workaround_macro = []() { multi_span<const int> cs{nullptr, 1}; }; + CHECK_THROW(const_workaround_macro(), fail_fast); + } + + { + auto workaround_macro = []() { multi_span<int, 0> s{nullptr, 1}; }; + CHECK_THROW(workaround_macro(), fail_fast); + + auto const_workaround_macro = []() { multi_span<const int, 0> s{nullptr, 1}; }; + CHECK_THROW(const_workaround_macro(), fail_fast); + } + + { + multi_span<int*> s{nullptr, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int*> cs{nullptr, 0}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_element_constructor) + { + int i = 5; + + { + multi_span<int> s = i; + CHECK(s.length() == 1 && s.data() == &i); + CHECK(s[0] == 5); + + multi_span<const int> cs = i; + CHECK(cs.length() == 1 && cs.data() == &i); + CHECK(cs[0] == 5); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + const j = 1; + multi_span<int, 0> s = j; +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 0> s = i; + CHECK(s.length() == 0 && s.data() == &i); +#endif + } + + { + multi_span<int, 1> s = i; + CHECK(s.length() == 1 && s.data() == &i); + CHECK(s[0] == 5); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 2> s = i; + CHECK(s.length() == 2 && s.data() == &i); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_a_temp = []() -> int { return 4; }; + auto use_a_span = [](multi_span<int> s) { (void) s; }; + use_a_span(get_a_temp()); +#endif + } + } + + TEST(from_pointer_length_constructor) + { + int arr[4] = {1, 2, 3, 4}; + + { + multi_span<int> s{&arr[0], 2}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + multi_span<int, 2> s{&arr[0], 2}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + int* p = nullptr; + multi_span<int> s{p, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + } + + { + int* p = nullptr; + auto workaround_macro = [=]() { multi_span<int> s{p, 2}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + } + + TEST(from_pointer_pointer_constructor) + { + int arr[4] = {1, 2, 3, 4}; + + { + multi_span<int> s{&arr[0], &arr[2]}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + multi_span<int, 2> s{&arr[0], &arr[2]}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + multi_span<int> s{&arr[0], &arr[0]}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + { + multi_span<int, 0> s{&arr[0], &arr[0]}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + { + auto workaround_macro = [&]() { multi_span<int> s{&arr[1], &arr[0]}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + { + int* p = nullptr; + auto workaround_macro = [&]() { multi_span<int> s{&arr[0], p}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + { + int* p = nullptr; + auto workaround_macro = [&]() { multi_span<int> s{p, p}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + { + int* p = nullptr; + auto workaround_macro = [&]() { multi_span<int> s{&arr[0], p}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + } + + TEST(from_array_constructor) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + multi_span<int> s{arr}; + CHECK(s.length() == 5 && s.data() == &arr[0]); + } + + { + multi_span<int, 5> s{arr}; + CHECK(s.length() == 5 && s.data() == &arr[0]); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 6> s{arr}; +#endif + } + + { + multi_span<int, 0> s{arr}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + int arr2d[2][3] = {1, 2, 3, 4, 5, 6}; + + { + multi_span<int> s{arr2d}; + CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } + + { + multi_span<int, 0> s{arr2d}; + CHECK(s.length() == 0 && s.data() == &arr2d[0][0]); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 5> s{arr2d}; +#endif + } + + { + multi_span<int, 6> s{arr2d}; + CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 7> s{arr2d}; +#endif + } + + { + multi_span<int[3]> s{arr2d[0]}; + CHECK(s.length() == 1 && s.data() == &arr2d[0]); + } + + { + multi_span<int, 2, 3> s{arr2d}; + CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); + auto workaround_macro = [&]() { return s[{1, 2}] == 6; }; + CHECK(workaround_macro()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 3, 3> s{arr2d}; +#endif + } + + int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; + + { + multi_span<int> s{arr3d}; + CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); + CHECK(s[0] == 1 && s[11] == 12); + } + + { + multi_span<int, 0> s{arr3d}; + CHECK(s.length() == 0 && s.data() == &arr3d[0][0][0]); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 11> s{arr3d}; +#endif + } + + { + multi_span<int, 12> s{arr3d}; + CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 13> s{arr3d}; +#endif + } + + { + multi_span<int[3][2]> s{arr3d[0]}; + CHECK(s.length() == 1 && s.data() == &arr3d[0]); + } + + { + multi_span<int, 3, 2, 2> s{arr3d}; + CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); + auto workaround_macro = [&]() { return s[{2, 1, 0}] == 11; }; + CHECK(workaround_macro()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 3, 3, 3> s{arr3d}; +#endif + } + } + + TEST(from_dynamic_array_constructor) + { + double(*arr)[3][4] = new double[100][3][4]; + + { + multi_span<double, dynamic_range, 3, 4> s(arr, 10); + CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); + CHECK_THROW(s[10][3][4], fail_fast); + } + + { + multi_span<double, dynamic_range, 4, 3> s(arr, 10); + CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); + } + + { + multi_span<double> s(arr, 10); + CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); + } + + { + multi_span<double, dynamic_range, 3, 4> s(arr, 0); + CHECK(s.length() == 0 && s.data() == &arr[0][0][0]); + } + + delete[] arr; + } + + TEST(from_std_array_constructor) + { + std::array<int, 4> arr = {1, 2, 3, 4}; + + { + multi_span<int> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + + multi_span<const int> cs{arr}; + CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data()); + } + + { + multi_span<int, 4> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + + multi_span<const int, 4> cs{arr}; + CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data()); + } + + { + multi_span<int, 2> s{arr}; + CHECK(s.size() == 2 && s.data() == arr.data()); + + multi_span<const int, 2> cs{arr}; + CHECK(cs.size() == 2 && cs.data() == arr.data()); + } + + { + multi_span<int, 0> s{arr}; + CHECK(s.size() == 0 && s.data() == arr.data()); + + multi_span<const int, 0> cs{arr}; + CHECK(cs.size() == 0 && cs.data() == arr.data()); + } + + // TODO This is currently an unsupported scenario. We will come back to it as we revise + // the multidimensional interface and what transformations between dimensionality look like + //{ + // multi_span<int, 2, 2> s{arr}; + // CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + //} + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 5> s{arr}; +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_an_array = []() { return std::array<int, 4>{1, 2, 3, 4}; }; + auto take_a_span = [](multi_span<int> s) { (void) s; }; + // try to take a temporary std::array + take_a_span(get_an_array()); +#endif + } + } + + TEST(from_const_std_array_constructor) + { + const std::array<int, 4> arr = {1, 2, 3, 4}; + + { + multi_span<const int> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + } + + { + multi_span<const int, 4> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + } + + { + multi_span<const int, 2> s{arr}; + CHECK(s.size() == 2 && s.data() == arr.data()); + } + + { + multi_span<const int, 0> s{arr}; + CHECK(s.size() == 0 && s.data() == arr.data()); + } + + // TODO This is currently an unsupported scenario. We will come back to it as we revise + // the multidimensional interface and what transformations between dimensionality look like + //{ + // multi_span<int, 2, 2> s{arr}; + // CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + //} + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<const int, 5> s{arr}; +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; }; + auto take_a_span = [](multi_span<const int> s) { (void) s; }; + // try to take a temporary std::array + take_a_span(get_an_array()); +#endif + } + } + + TEST(from_container_constructor) + { + std::vector<int> v = {1, 2, 3}; + const std::vector<int> cv = v; + + { + multi_span<int> s{v}; + CHECK(s.size() == narrow_cast<std::ptrdiff_t>(v.size()) && s.data() == v.data()); + + multi_span<const int> cs{v}; + CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(v.size()) && cs.data() == v.data()); + } + + std::string str = "hello"; + const std::string cstr = "hello"; + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<char> s{str}; + CHECK(s.size() == narrow_cast<std::ptrdiff_t>(str.size()) && s.data() == str.data()); +#endif + multi_span<const char> cs{str}; + CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(str.size()) && cs.data() == str.data()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<char> s{cstr}; +#endif + multi_span<const char> cs{cstr}; + CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(cstr.size()) && + cs.data() == cstr.data()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_vector = []() -> std::vector<int> { return {}; }; + auto use_span = [](multi_span<int> s) { (void) s; }; + use_span(get_temp_vector()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_string = []() -> std::string { return {}; }; + auto use_span = [](multi_span<char> s) { (void) s; }; + use_span(get_temp_string()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_vector = []() -> const std::vector<int> { return {}; }; + auto use_span = [](multi_span<const char> s) { (void) s; }; + use_span(get_temp_vector()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_string = []() -> const std::string { return {}; }; + auto use_span = [](multi_span<const char> s) { (void) s; }; + use_span(get_temp_string()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + std::map<int, int> m; + multi_span<int> s{m}; +#endif + } + } + + TEST(from_convertible_span_constructor) + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 7, 4, 2> av1(nullptr, b1); + + auto f = [&]() { multi_span<int, 7, 4, 2> av1(nullptr); }; + CHECK_THROW(f(), fail_fast); +#endif + +#ifdef CONFIRM_COMPILATION_ERRORS + static_bounds<size_t, 7, dynamic_range, 2> b12(b11); + b12 = b11; + b11 = b12; + + multi_span<int, dynamic_range> av1 = nullptr; + multi_span<int, 7, dynamic_range, 2> av2(av1); + multi_span<int, 7, 4, 2> av2(av1); +#endif + + multi_span<DerivedClass> avd; +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<BaseClass> avb = avd; +#endif + multi_span<const DerivedClass> avcd = avd; + (void) avcd; + } + + TEST(copy_move_and_assignment) + { + multi_span<int> s1; + CHECK(s1.empty()); + + int arr[] = {3, 4, 5}; + + multi_span<const int> s2 = arr; + CHECK(s2.length() == 3 && s2.data() == &arr[0]); + + s2 = s1; + CHECK(s2.empty()); + + auto get_temp_span = [&]() -> multi_span<int> { return {&arr[1], 2}; }; + auto use_span = [&](multi_span<const int> s) { CHECK(s.length() == 2 && s.data() == &arr[1]); }; + use_span(get_temp_span()); + + s1 = get_temp_span(); + CHECK(s1.length() == 2 && s1.data() == &arr[1]); + } + + template <class Bounds> + void fn(const Bounds&) + { + static_assert(Bounds::static_size == 60, "static bounds is wrong size"); + } + TEST(as_multi_span_reshape) + { + int a[3][4][5]; + auto av = as_multi_span(a); + fn(av.bounds()); + auto av2 = as_multi_span(av, dim<60>()); + auto av3 = as_multi_span(av2, dim<3>(), dim<4>(), dim<5>()); + auto av4 = as_multi_span(av3, dim<4>(), dim<>(3), dim<5>()); + auto av5 = as_multi_span(av4, dim<3>(), dim<4>(), dim<5>()); + auto av6 = as_multi_span(av5, dim<12>(), dim<>(5)); + + fill(av6.begin(), av6.end(), 1); + + auto av7 = as_bytes(av6); + + auto av8 = as_multi_span<int>(av7); + + CHECK(av8.size() == av6.size()); + for (auto i = 0; i < av8.size(); i++) { + CHECK(av8[i] == 1); + } + } + + TEST(first) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + multi_span<int, 5> av = arr; + CHECK((av.first<2>().bounds() == static_bounds<2>())); + CHECK(av.first<2>().length() == 2); + CHECK(av.first(2).length() == 2); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.first<0>().bounds() == static_bounds<0>())); + CHECK(av.first<0>().length() == 0); + CHECK(av.first(0).length() == 0); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.first<5>().bounds() == static_bounds<5>())); + CHECK(av.first<5>().length() == 5); + CHECK(av.first(5).length() == 5); + } + + { + multi_span<int, 5> av = arr; +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(av.first<6>().bounds() == static_bounds<6>()); + CHECK(av.first<6>().length() == 6); + CHECK(av.first<-1>().length() == -1); +#endif + CHECK_THROW(av.first(6).length(), fail_fast); + } + + { + multi_span<int, dynamic_range> av; + CHECK((av.first<0>().bounds() == static_bounds<0>())); + CHECK(av.first<0>().length() == 0); + CHECK(av.first(0).length() == 0); + } + } + + TEST(last) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + multi_span<int, 5> av = arr; + CHECK((av.last<2>().bounds() == static_bounds<2>())); + CHECK(av.last<2>().length() == 2); + CHECK(av.last(2).length() == 2); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.last<0>().bounds() == static_bounds<0>())); + CHECK(av.last<0>().length() == 0); + CHECK(av.last(0).length() == 0); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.last<5>().bounds() == static_bounds<5>())); + CHECK(av.last<5>().length() == 5); + CHECK(av.last(5).length() == 5); + } + + { + multi_span<int, 5> av = arr; +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK((av.last<6>().bounds() == static_bounds<6>())); + CHECK(av.last<6>().length() == 6); +#endif + CHECK_THROW(av.last(6).length(), fail_fast); + } + + { + multi_span<int, dynamic_range> av; + CHECK((av.last<0>().bounds() == static_bounds<0>())); + CHECK(av.last<0>().length() == 0); + CHECK(av.last(0).length() == 0); + } + } + + TEST(subspan) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + multi_span<int, 5> av = arr; + CHECK((av.subspan<2, 2>().bounds() == static_bounds<2>())); + CHECK((av.subspan<2, 2>().length() == 2)); + CHECK(av.subspan(2, 2).length() == 2); + CHECK(av.subspan(2, 3).length() == 3); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>())); + CHECK((av.subspan<0, 0>().length() == 0)); + CHECK(av.subspan(0, 0).length() == 0); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.subspan<0, 5>().bounds() == static_bounds<5>())); + CHECK((av.subspan<0, 5>().length() == 5)); + CHECK(av.subspan(0, 5).length() == 5); + CHECK_THROW(av.subspan(0, 6).length(), fail_fast); + CHECK_THROW(av.subspan(1, 5).length(), fail_fast); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.subspan<5, 0>().bounds() == static_bounds<0>())); + CHECK((av.subspan<5, 0>().length() == 0)); + CHECK(av.subspan(5, 0).length() == 0); + CHECK_THROW(av.subspan(6, 0).length(), fail_fast); + } + + { + multi_span<int, dynamic_range> av; + CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>())); + CHECK((av.subspan<0, 0>().length() == 0)); + CHECK(av.subspan(0, 0).length() == 0); + CHECK_THROW((av.subspan<1, 0>().length()), fail_fast); + } + + { + multi_span<int> av; + CHECK(av.subspan(0).length() == 0); + CHECK_THROW(av.subspan(1).length(), fail_fast); + } + + { + multi_span<int> av = arr; + CHECK(av.subspan(0).length() == 5); + CHECK(av.subspan(1).length() == 4); + CHECK(av.subspan(4).length() == 1); + CHECK(av.subspan(5).length() == 0); + CHECK_THROW(av.subspan(6).length(), fail_fast); + auto av2 = av.subspan(1); + for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2); + } + + { + multi_span<int, 5> av = arr; + CHECK(av.subspan(0).length() == 5); + CHECK(av.subspan(1).length() == 4); + CHECK(av.subspan(4).length() == 1); + CHECK(av.subspan(5).length() == 0); + CHECK_THROW(av.subspan(6).length(), fail_fast); + auto av2 = av.subspan(1); + for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2); + } + } + + TEST(rank) + { + int arr[2] = {1, 2}; + + { + multi_span<int> s; + CHECK(s.rank() == 1); + } + + { + multi_span<int, 2> s = arr; + CHECK(s.rank() == 1); + } + + int arr2d[1][1] = {}; + { + multi_span<int, 1, 1> s = arr2d; + CHECK(s.rank() == 2); + } + } + + TEST(extent) + { + { + multi_span<int> s; + CHECK(s.extent() == 0); + CHECK(s.extent(0) == 0); + CHECK_THROW(s.extent(1), fail_fast); +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(s.extent<1>() == 0); +#endif + } + + { + multi_span<int, 0> s; + CHECK(s.extent() == 0); + CHECK(s.extent(0) == 0); + CHECK_THROW(s.extent(1), fail_fast); + } + + { + int arr2d[1][2] = {}; + + multi_span<int, 1, 2> s = arr2d; + CHECK(s.extent() == 1); + CHECK(s.extent<0>() == 1); + CHECK(s.extent<1>() == 2); + CHECK(s.extent(0) == 1); + CHECK(s.extent(1) == 2); + CHECK_THROW(s.extent(3), fail_fast); + } + + { + int arr2d[1][2] = {}; + + multi_span<int, 0, 2> s = arr2d; + CHECK(s.extent() == 0); + CHECK(s.extent<0>() == 0); + CHECK(s.extent<1>() == 2); + CHECK(s.extent(0) == 0); + CHECK(s.extent(1) == 2); + CHECK_THROW(s.extent(3), fail_fast); + } + } + + TEST(operator_function_call) + { + int arr[4] = {1, 2, 3, 4}; + + { + multi_span<int> s = arr; + CHECK(s(0) == 1); + CHECK_THROW(s(5), fail_fast); + } + + int arr2d[2][3] = {1, 2, 3, 4, 5, 6}; + + { + multi_span<int, 2, 3> s = arr2d; + CHECK(s(0, 0) == 1); + CHECK(s(1, 2) == 6); + } + } + + TEST(comparison_operators) + { + { + int arr[10][2]; + auto s1 = as_multi_span(arr); + multi_span<const int, dynamic_range, 2> s2 = s1; + + CHECK(s1 == s2); + + multi_span<int, 20> s3 = as_multi_span(s1, dim<>(20)); + CHECK(s3 == s2 && s3 == s1); + } + + { + auto s1 = nullptr; + auto s2 = nullptr; + CHECK(s1 == s2); + CHECK(!(s1 != s2)); + CHECK(!(s1 < s2)); + CHECK(s1 <= s2); + CHECK(!(s1 > s2)); + CHECK(s1 >= s2); + CHECK(s2 == s1); + CHECK(!(s2 != s1)); + CHECK(!(s2 < s1)); + CHECK(s2 <= s1); + CHECK(!(s2 > s1)); + CHECK(s2 >= s1); + } + + { + int arr[] = {2, 1}; // bigger + + multi_span<int> s1 = nullptr; + multi_span<int> s2 = arr; + + CHECK(s1 != s2); + CHECK(s2 != s1); + CHECK(!(s1 == s2)); + CHECK(!(s2 == s1)); + CHECK(s1 < s2); + CHECK(!(s2 < s1)); + CHECK(s1 <= s2); + CHECK(!(s2 <= s1)); + CHECK(s2 > s1); + CHECK(!(s1 > s2)); + CHECK(s2 >= s1); + CHECK(!(s1 >= s2)); + } + + { + int arr1[] = {1, 2}; + int arr2[] = {1, 2}; + multi_span<int> s1 = arr1; + multi_span<int> s2 = arr2; + + CHECK(s1 == s2); + CHECK(!(s1 != s2)); + CHECK(!(s1 < s2)); + CHECK(s1 <= s2); + CHECK(!(s1 > s2)); + CHECK(s1 >= s2); + CHECK(s2 == s1); + CHECK(!(s2 != s1)); + CHECK(!(s2 < s1)); + CHECK(s2 <= s1); + CHECK(!(s2 > s1)); + CHECK(s2 >= s1); + } + + { + int arr[] = {1, 2, 3}; + + multi_span<int> s1 = {&arr[0], 2}; // shorter + multi_span<int> s2 = arr; // longer + + CHECK(s1 != s2); + CHECK(s2 != s1); + CHECK(!(s1 == s2)); + CHECK(!(s2 == s1)); + CHECK(s1 < s2); + CHECK(!(s2 < s1)); + CHECK(s1 <= s2); + CHECK(!(s2 <= s1)); + CHECK(s2 > s1); + CHECK(!(s1 > s2)); + CHECK(s2 >= s1); + CHECK(!(s1 >= s2)); + } + + { + int arr1[] = {1, 2}; // smaller + int arr2[] = {2, 1}; // bigger + + multi_span<int> s1 = arr1; + multi_span<int> s2 = arr2; + + CHECK(s1 != s2); + CHECK(s2 != s1); + CHECK(!(s1 == s2)); + CHECK(!(s2 == s1)); + CHECK(s1 < s2); + CHECK(!(s2 < s1)); + CHECK(s1 <= s2); + CHECK(!(s2 <= s1)); + CHECK(s2 > s1); + CHECK(!(s1 > s2)); + CHECK(s2 >= s1); + CHECK(!(s1 >= s2)); + } + } + + TEST(basics) + { + auto ptr = as_multi_span(new int[10], 10); + fill(ptr.begin(), ptr.end(), 99); + for (int num : ptr) { + CHECK(num == 99); + } + + delete[] ptr.data(); + } + + TEST(bounds_checks) + { + int arr[10][2]; + auto av = as_multi_span(arr); + + fill(begin(av), end(av), 0); + + av[2][0] = 1; + av[1][1] = 3; + + // out of bounds + CHECK_THROW(av[1][3] = 3, fail_fast); + CHECK_THROW((av[{1, 3}] = 3), fail_fast); + + CHECK_THROW(av[10][2], fail_fast); + CHECK_THROW((av[{10, 2}]), fail_fast); + } + + void overloaded_func(multi_span<const int, dynamic_range, 3, 5> exp, int expected_value) + { + for (auto val : exp) { + CHECK(val == expected_value); + } + } + + void overloaded_func(multi_span<const char, dynamic_range, 3, 5> exp, char expected_value) + { + for (auto val : exp) { + CHECK(val == expected_value); + } + } + + void fixed_func(multi_span<int, 3, 3, 5> exp, int expected_value) + { + for (auto val : exp) { + CHECK(val == expected_value); + } + } + + TEST(span_parameter_test) + { + auto data = new int[4][3][5]; + + auto av = as_multi_span(data, 4); + + CHECK(av.size() == 60); + + fill(av.begin(), av.end(), 34); + + int count = 0; + for_each(av.rbegin(), av.rend(), [&](int val) { count += val; }); + CHECK(count == 34 * 60); + overloaded_func(av, 34); + + overloaded_func(as_multi_span(av, dim<>(4), dim<>(3), dim<>(5)), 34); + + // fixed_func(av, 34); + delete[] data; + } + + TEST(md_access) + { + auto width = 5, height = 20; + + auto imgSize = width * height; + auto image_ptr = new int[imgSize][3]; + + // size check will be done + auto image_view = + as_multi_span(as_multi_span(image_ptr, imgSize), dim<>(height), dim<>(width), dim<3>()); + + iota(image_view.begin(), image_view.end(), 1); + + int expected = 0; + for (auto i = 0; i < height; i++) { + for (auto j = 0; j < width; j++) { + CHECK(expected + 1 == image_view[i][j][0]); + CHECK(expected + 2 == image_view[i][j][1]); + CHECK(expected + 3 == image_view[i][j][2]); + + auto val = image_view[{i, j, 0}]; + CHECK(expected + 1 == val); + val = image_view[{i, j, 1}]; + CHECK(expected + 2 == val); + val = image_view[{i, j, 2}]; + CHECK(expected + 3 == val); + + expected += 3; + } + } + } + + TEST(as_multi_span) + { + { + int* arr = new int[150]; + + auto av = as_multi_span(arr, dim<10>(), dim<>(3), dim<5>()); + + fill(av.begin(), av.end(), 24); + overloaded_func(av, 24); + + delete[] arr; + + array<int, 15> stdarr{0}; + auto av2 = as_multi_span(stdarr); + overloaded_func(as_multi_span(av2, dim<>(1), dim<3>(), dim<5>()), 0); + + string str = "ttttttttttttttt"; // size = 15 + auto t = str.data(); + (void) t; + auto av3 = as_multi_span(str); + overloaded_func(as_multi_span(av3, dim<>(1), dim<3>(), dim<5>()), 't'); + } + + { + string str; + multi_span<char> strspan = as_multi_span(str); + (void) strspan; + const string cstr; + multi_span<const char> cstrspan = as_multi_span(cstr); + (void) cstrspan; + } + + { + int a[3][4][5]; + auto av = as_multi_span(a); + const int(*b)[4][5]; + b = a; + auto bv = as_multi_span(b, 3); + + CHECK(av == bv); + + const std::array<double, 3> arr = {0.0, 0.0, 0.0}; + auto cv = as_multi_span(arr); + (void) cv; + + vector<float> vec(3); + auto dv = as_multi_span(vec); + (void) dv; + +#ifdef CONFIRM_COMPILATION_ERRORS + auto dv2 = as_multi_span(std::move(vec)); +#endif + } + } + + TEST(empty_spans) + { + { + multi_span<int, 0> empty_av(nullptr); + + CHECK(empty_av.bounds().index_bounds() == index<1>{0}); + CHECK_THROW(empty_av[0], fail_fast); + CHECK_THROW(empty_av.begin()[0], fail_fast); + CHECK_THROW(empty_av.cbegin()[0], fail_fast); + for (auto& v : empty_av) { + (void) v; + CHECK(false); + } + } + + { + multi_span<int> empty_av = {}; + CHECK(empty_av.bounds().index_bounds() == index<1>{0}); + CHECK_THROW(empty_av[0], fail_fast); + CHECK_THROW(empty_av.begin()[0], fail_fast); + CHECK_THROW(empty_av.cbegin()[0], fail_fast); + for (auto& v : empty_av) { + (void) v; + CHECK(false); + } + } + } + + TEST(index_constructor) + { + auto arr = new int[8]; + for (int i = 0; i < 4; ++i) { + arr[2 * i] = 4 + i; + arr[2 * i + 1] = i; + } + + multi_span<int, dynamic_range> av(arr, 8); + + ptrdiff_t a[1] = {0}; + index<1> i = a; + + CHECK(av[i] == 4); + + auto av2 = as_multi_span(av, dim<4>(), dim<>(2)); + ptrdiff_t a2[2] = {0, 1}; + index<2> i2 = a2; + + CHECK(av2[i2] == 0); + CHECK(av2[0][i] == 4); + + delete[] arr; + } + + TEST(index_constructors) + { + { + // components of the same type + index<3> i1(0, 1, 2); + CHECK(i1[0] == 0); + + // components of different types + size_t c0 = 0; + size_t c1 = 1; + index<3> i2(c0, c1, 2); + CHECK(i2[0] == 0); + + // from array + index<3> i3 = {0, 1, 2}; + CHECK(i3[0] == 0); + + // from other index of the same size type + index<3> i4 = i3; + CHECK(i4[0] == 0); + + // default + index<3> i7; + CHECK(i7[0] == 0); + + // default + index<3> i9 = {}; + CHECK(i9[0] == 0); + } + + { + // components of the same type + index<1> i1(0); + CHECK(i1[0] == 0); + + // components of different types + size_t c0 = 0; + index<1> i2(c0); + CHECK(i2[0] == 0); + + // from array + index<1> i3 = {0}; + CHECK(i3[0] == 0); + + // from int + index<1> i4 = 0; + CHECK(i4[0] == 0); + + // from other index of the same size type + index<1> i5 = i3; + CHECK(i5[0] == 0); + + // default + index<1> i8; + CHECK(i8[0] == 0); + + // default + index<1> i9 = {}; + CHECK(i9[0] == 0); + } + +#ifdef CONFIRM_COMPILATION_ERRORS + { + index<3> i1(0, 1); + index<3> i2(0, 1, 2, 3); + index<3> i3 = {0}; + index<3> i4 = {0, 1, 2, 3}; + index<1> i5 = {0, 1}; + } +#endif + } + + TEST(index_operations) + { + ptrdiff_t a[3] = {0, 1, 2}; + ptrdiff_t b[3] = {3, 4, 5}; + index<3> i = a; + index<3> j = b; + + CHECK(i[0] == 0); + CHECK(i[1] == 1); + CHECK(i[2] == 2); + + { + index<3> k = i + j; + + CHECK(i[0] == 0); + CHECK(i[1] == 1); + CHECK(i[2] == 2); + CHECK(k[0] == 3); + CHECK(k[1] == 5); + CHECK(k[2] == 7); + } + + { + index<3> k = i * 3; + + CHECK(i[0] == 0); + CHECK(i[1] == 1); + CHECK(i[2] == 2); + CHECK(k[0] == 0); + CHECK(k[1] == 3); + CHECK(k[2] == 6); + } + + { + index<3> k = 3 * i; + + CHECK(i[0] == 0); + CHECK(i[1] == 1); + CHECK(i[2] == 2); + CHECK(k[0] == 0); + CHECK(k[1] == 3); + CHECK(k[2] == 6); + } + + { + index<2> k = details::shift_left(i); + + CHECK(i[0] == 0); + CHECK(i[1] == 1); + CHECK(i[2] == 2); + CHECK(k[0] == 1); + CHECK(k[1] == 2); + } + } + + void iterate_second_column(multi_span<int, dynamic_range, dynamic_range> av) + { + auto length = av.size() / 2; + + // view to the second column + auto section = av.section({0, 1}, {length, 1}); + + CHECK(section.size() == length); + for (auto i = 0; i < section.size(); ++i) { + CHECK(section[i][0] == av[i][1]); + } + + for (auto i = 0; i < section.size(); ++i) { + auto idx = index<2>{i, 0}; // avoid braces inside the CHECK macro + CHECK(section[idx] == av[i][1]); + } + + CHECK(section.bounds().index_bounds()[0] == length); + CHECK(section.bounds().index_bounds()[1] == 1); + for (auto i = 0; i < section.bounds().index_bounds()[0]; ++i) { + for (auto j = 0; j < section.bounds().index_bounds()[1]; ++j) { + auto idx = index<2>{i, j}; // avoid braces inside the CHECK macro + CHECK(section[idx] == av[i][1]); + } + } + + size_t check_sum = 0; + for (auto i = 0; i < length; ++i) { + check_sum += av[i][1]; + } + + { + auto idx = 0; + size_t sum = 0; + for (auto num : section) { + CHECK(num == av[idx][1]); + sum += num; + idx++; + } + + CHECK(sum == check_sum); + } + { + size_t idx = length - 1; + size_t sum = 0; + for (auto iter = section.rbegin(); iter != section.rend(); ++iter) { + CHECK(*iter == av[idx][1]); + sum += *iter; + idx--; + } + + CHECK(sum == check_sum); + } + } + + TEST(span_section_iteration) + { + int arr[4][2] = {{4, 0}, {5, 1}, {6, 2}, {7, 3}}; + + // static bounds + { + multi_span<int, 4, 2> av = arr; + iterate_second_column(av); + } + // first bound is dynamic + { + multi_span<int, dynamic_range, 2> av = arr; + iterate_second_column(av); + } + // second bound is dynamic + { + multi_span<int, 4, dynamic_range> av = arr; + iterate_second_column(av); + } + // both bounds are dynamic + { + multi_span<int, dynamic_range, dynamic_range> av = arr; + iterate_second_column(av); + } + } + + TEST(dynamic_span_section_iteration) + { + auto height = 4, width = 2; + auto size = height * width; + + auto arr = new int[size]; + for (auto i = 0; i < size; ++i) { + arr[i] = i; + } + + auto av = as_multi_span(arr, size); + + // first bound is dynamic + { + multi_span<int, dynamic_range, 2> av2 = as_multi_span(av, dim<>(height), dim<>(width)); + iterate_second_column(av2); + } + // second bound is dynamic + { + multi_span<int, 4, dynamic_range> av2 = as_multi_span(av, dim<>(height), dim<>(width)); + iterate_second_column(av2); + } + // both bounds are dynamic + { + multi_span<int, dynamic_range, dynamic_range> av2 = as_multi_span(av, dim<>(height), dim<>(width)); + iterate_second_column(av2); + } + + delete[] arr; + } + + TEST(span_structure_size) + { + double(*arr)[3][4] = new double[100][3][4]; + multi_span<double, dynamic_range, 3, 4> av1(arr, 10); + + struct EffectiveStructure + { + double* v1; + ptrdiff_t v2; + }; + CHECK(sizeof(av1) == sizeof(EffectiveStructure)); + + CHECK_THROW(av1[10][3][4], fail_fast); + + multi_span<const double, dynamic_range, 6, 4> av2 = as_multi_span(av1, dim<>(5), dim<6>(), dim<4>()); + (void) av2; + } + + TEST(fixed_size_conversions) + { + int arr[] = {1, 2, 3, 4}; + + // converting to an multi_span from an equal size array is ok + multi_span<int, 4> av4 = arr; + CHECK(av4.length() == 4); + + // converting to dynamic_range a_v is always ok + { + multi_span<int, dynamic_range> av = av4; + (void) av; + } + { + multi_span<int, dynamic_range> av = arr; + (void) av; + } + +// initialization or assignment to static multi_span that REDUCES size is NOT ok +#ifdef CONFIRM_COMPILATION_ERRORS + { + multi_span<int, 2> av2 = arr; + } + { + multi_span<int, 2> av2 = av4; + } +#endif + + { + multi_span<int, dynamic_range> av = arr; + multi_span<int, 2> av2 = av; + (void) av2; + } + +#ifdef CONFIRM_COMPILATION_ERRORS + { + multi_span<int, dynamic_range> av = arr; + multi_span<int, 2, 1> av2 = av.as_multi_span(dim<2>(), dim<2>()); + } +#endif + + { + multi_span<int, dynamic_range> av = arr; + multi_span<int, 2, 1> av2 = as_multi_span(av, dim<>(2), dim<>(2)); + auto workaround_macro = [&]() { return av2[{1, 0}] == 2; }; + CHECK(workaround_macro()); + } + + // but doing so explicitly is ok + + // you can convert statically + { + multi_span<int, 2> av2 = {arr, 2}; + (void) av2; + } + { + multi_span<int, 1> av2 = av4.first<1>(); + (void) av2; + } + + // ...or dynamically + { + // NB: implicit conversion to multi_span<int,2> from multi_span<int,dynamic_range> + multi_span<int, 1> av2 = av4.first(1); + (void) av2; + } + + // initialization or assignment to static multi_span that requires size INCREASE is not ok. + int arr2[2] = {1, 2}; + +#ifdef CONFIRM_COMPILATION_ERRORS + { + multi_span<int, 4> av4 = arr2; + } + { + multi_span<int, 2> av2 = arr2; + multi_span<int, 4> av4 = av2; + } +#endif + { + auto f = [&]() { + multi_span<int, 4> av9 = {arr2, 2}; + (void) av9; + }; + CHECK_THROW(f(), fail_fast); + } + + // this should fail - we are trying to assign a small dynamic a_v to a fixed_size larger one + multi_span<int, dynamic_range> av = arr2; + auto f = [&]() { + multi_span<int, 4> av2 = av; + (void) av2; + }; + CHECK_THROW(f(), fail_fast); + } + + TEST(as_writeable_bytes) + { + int a[] = {1, 2, 3, 4}; + + { +#ifdef CONFIRM_COMPILATION_ERRORS + // you should not be able to get writeable bytes for const objects + multi_span<const int, dynamic_range> av = a; + auto wav = av.as_writeable_bytes(); +#endif + } + + { + multi_span<int, dynamic_range> av; + auto wav = as_writeable_bytes(av); + CHECK(wav.length() == av.length()); + CHECK(wav.length() == 0); + CHECK(wav.size_bytes() == 0); + } + + { + multi_span<int, dynamic_range> av = a; + auto wav = as_writeable_bytes(av); + CHECK(wav.data() == (byte*) &a[0]); + CHECK(wav.length() == sizeof(a)); + } + } + + TEST(iterator) + { + int a[] = {1, 2, 3, 4}; + + { + multi_span<int, dynamic_range> av = a; + auto wav = as_writeable_bytes(av); + for (auto& b : wav) { + b = byte(0); + } + for (size_t i = 0; i < 4; ++i) { + CHECK(a[i] == 0); + } + } + + { + multi_span<int, dynamic_range> av = a; + for (auto& n : av) { + n = 1; + } + for (size_t i = 0; i < 4; ++i) { + CHECK(a[i] == 1); + } + } + } +} + +int main(int, const char* []) { return UnitTest::RunAllTests(); } diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp index 8b39639..8c9829d 100644 --- a/tests/span_tests.cpp +++ b/tests/span_tests.cpp @@ -39,7 +39,6 @@ struct DerivedClass : BaseClass SUITE(span_tests) { - TEST(default_constructor) { { @@ -74,6 +73,19 @@ SUITE(span_tests) } } + TEST(size_optimization) + { + { + span<int> s; + CHECK(sizeof(s) == sizeof(int*) + sizeof(ptrdiff_t)); + } + + { + span<int, 0> s; + CHECK(sizeof(s) == sizeof(int*)); + } + } + TEST(from_nullptr_constructor) { { @@ -119,26 +131,24 @@ SUITE(span_tests) TEST(from_nullptr_length_constructor) { { - span<int> s{nullptr, 0}; + span<int> s{nullptr, static_cast<span<int>::index_type>(0)}; CHECK(s.length() == 0 && s.data() == nullptr); - span<const int> cs{nullptr, 0}; + span<const int> cs{nullptr, static_cast<span<int>::index_type>(0)}; CHECK(cs.length() == 0 && cs.data() == nullptr); } { - span<int, 0> s{nullptr, 0}; + span<int, 0> s{nullptr, static_cast<span<int>::index_type>(0)}; CHECK(s.length() == 0 && s.data() == nullptr); - span<const int, 0> cs{nullptr, 0}; + span<const int, 0> cs{nullptr, static_cast<span<int>::index_type>(0)}; CHECK(cs.length() == 0 && cs.data() == nullptr); } { -#ifdef CONFIRM_COMPILATION_ERRORS - span<int, 1> s{nullptr, 0}; - CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile -#endif + auto workaround_macro = []() { span<int, 1> s{ nullptr, static_cast<span<int>::index_type>(0) }; }; + CHECK_THROW(workaround_macro(), fail_fast); } { @@ -158,64 +168,14 @@ SUITE(span_tests) } { - span<int*> s{nullptr, 0}; + span<int*> s{nullptr, static_cast<span<int>::index_type>(0)}; CHECK(s.length() == 0 && s.data() == nullptr); - span<const int*> cs{nullptr, 0}; + span<const int*> cs{nullptr, static_cast<span<int>::index_type>(0)}; CHECK(cs.length() == 0 && cs.data() == nullptr); } } - TEST(from_element_constructor) - { - int i = 5; - - { - span<int> s = i; - CHECK(s.length() == 1 && s.data() == &i); - CHECK(s[0] == 5); - - span<const int> cs = i; - CHECK(cs.length() == 1 && cs.data() == &i); - CHECK(cs[0] == 5); - } - - { -#ifdef CONFIRM_COMPILATION_ERRORS - const j = 1; - span<int, 0> s = j; -#endif - } - - { -#ifdef CONFIRM_COMPILATION_ERRORS - span<int, 0> s = i; - CHECK(s.length() == 0 && s.data() == &i); -#endif - } - - { - span<int, 1> s = i; - CHECK(s.length() == 1 && s.data() == &i); - CHECK(s[0] == 5); - } - - { -#ifdef CONFIRM_COMPILATION_ERRORS - span<int, 2> s = i; - CHECK(s.length() == 2 && s.data() == &i); -#endif - } - - { -#ifdef CONFIRM_COMPILATION_ERRORS - auto get_a_temp = []() -> int { return 4; }; - auto use_a_span = [](span<int> s) { (void) s; }; - use_a_span(get_a_temp()); -#endif - } - } - TEST(from_pointer_length_constructor) { int arr[4] = {1, 2, 3, 4}; @@ -234,7 +194,7 @@ SUITE(span_tests) { int* p = nullptr; - span<int> s{p, 0}; + span<int> s{p, static_cast<span<int>::index_type>(0)}; CHECK(s.length() == 0 && s.data() == nullptr); } @@ -271,28 +231,37 @@ SUITE(span_tests) CHECK(s.length() == 0 && s.data() == &arr[0]); } - { - auto workaround_macro = [&]() { span<int> s{&arr[1], &arr[0]}; }; - CHECK_THROW(workaround_macro(), fail_fast); - } + // this will fail the std::distance() precondition, which asserts on MSVC debug builds + //{ + // auto workaround_macro = [&]() { span<int> s{&arr[1], &arr[0]}; }; + // CHECK_THROW(workaround_macro(), fail_fast); + //} - { - int* p = nullptr; - auto workaround_macro = [&]() { span<int> s{&arr[0], p}; }; - CHECK_THROW(workaround_macro(), fail_fast); - } + // this will fail the std::distance() precondition, which asserts on MSVC debug builds + //{ + // int* p = nullptr; + // auto workaround_macro = [&]() { span<int> s{&arr[0], p}; }; + // CHECK_THROW(workaround_macro(), fail_fast); + //} { int* p = nullptr; - auto workaround_macro = [&]() { span<int> s{p, p}; }; - CHECK_THROW(workaround_macro(), fail_fast); + span<int> s{ p, p }; + CHECK(s.length() == 0 && s.data() == nullptr); } { int* p = nullptr; - auto workaround_macro = [&]() { span<int> s{&arr[0], p}; }; - CHECK_THROW(workaround_macro(), fail_fast); + span<int, 0> s{ p, p }; + CHECK(s.length() == 0 && s.data() == nullptr); } + + // this will fail the std::distance() precondition, which asserts on MSVC debug builds + //{ + // int* p = nullptr; + // auto workaround_macro = [&]() { span<int> s{&arr[0], p}; }; + // CHECK_THROW(workaround_macro(), fail_fast); + //} } TEST(from_array_constructor) @@ -309,10 +278,11 @@ SUITE(span_tests) CHECK(s.length() == 5 && s.data() == &arr[0]); } - { + int arr2d[2][3] = { 1, 2, 3, 4, 5, 6 }; + #ifdef CONFIRM_COMPILATION_ERRORS + { span<int, 6> s{arr}; -#endif } { @@ -320,8 +290,6 @@ SUITE(span_tests) CHECK(s.length() == 0 && s.data() == &arr[0]); } - int arr2d[2][3] = {1, 2, 3, 4, 5, 6}; - { span<int> s{arr2d}; CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); @@ -334,43 +302,17 @@ SUITE(span_tests) } { -#ifdef CONFIRM_COMPILATION_ERRORS - span<int, 5> s{arr2d}; -#endif - } - - { - span<int, 6> s{arr2d}; - CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); - CHECK(s[0] == 1 && s[5] == 6); + span<int, 6> s{ arr2d }; } - - { -#ifdef CONFIRM_COMPILATION_ERRORS - span<int, 7> s{arr2d}; #endif - } - { - span<int[3]> s{arr2d[0]}; + span<int[3]> s{ &(arr2d[0]), 1 }; CHECK(s.length() == 1 && s.data() == &arr2d[0]); } - { - span<int, 2, 3> s{arr2d}; - CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); - auto workaround_macro = [&]() { return s[{1, 2}] == 6; }; - CHECK(workaround_macro()); - } - - { -#ifdef CONFIRM_COMPILATION_ERRORS - span<int, 3, 3> s{arr2d}; -#endif - } - int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; +#ifdef CONFIRM_COMPILATION_ERRORS { span<int> s{arr3d}; CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); @@ -383,9 +325,7 @@ SUITE(span_tests) } { -#ifdef CONFIRM_COMPILATION_ERRORS span<int, 11> s{arr3d}; -#endif } { @@ -393,30 +333,11 @@ SUITE(span_tests) CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); CHECK(s[0] == 1 && s[5] == 6); } - - { -#ifdef CONFIRM_COMPILATION_ERRORS - span<int, 13> s{arr3d}; #endif - } - { - span<int[3][2]> s{arr3d[0]}; + span<int[3][2]> s{&arr3d[0], 1}; CHECK(s.length() == 1 && s.data() == &arr3d[0]); } - - { - span<int, 3, 2, 2> s{arr3d}; - CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); - auto workaround_macro = [&]() { return s[{2, 1, 0}] == 11; }; - CHECK(workaround_macro()); - } - - { -#ifdef CONFIRM_COMPILATION_ERRORS - span<int, 3, 3, 3> s{arr3d}; -#endif - } } TEST(from_dynamic_array_constructor) @@ -424,24 +345,8 @@ SUITE(span_tests) double(*arr)[3][4] = new double[100][3][4]; { - span<double, dynamic_range, 3, 4> s(arr, 10); - CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); - CHECK_THROW(s[10][3][4], fail_fast); - } - - { - span<double, dynamic_range, 4, 3> s(arr, 10); - CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); - } - - { - span<double> s(arr, 10); - CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); - } - - { - span<double, dynamic_range, 3, 4> s(arr, 0); - CHECK(s.length() == 0 && s.data() == &arr[0][0][0]); + span<double> s(&arr[0][0][0], 10); + CHECK(s.length() == 10 && s.data() == &arr[0][0][0]); } delete[] arr; @@ -467,6 +372,7 @@ SUITE(span_tests) CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data()); } +#ifdef CONFIRM_COMPILATION_ERRORS { span<int, 2> s{arr}; CHECK(s.size() == 2 && s.data() == arr.data()); @@ -483,26 +389,23 @@ SUITE(span_tests) CHECK(cs.size() == 0 && cs.data() == arr.data()); } - // TODO This is currently an unsupported scenario. We will come back to it as we revise - // the multidimensional interface and what transformations between dimensionality look like - //{ - // span<int, 2, 2> s{arr}; - // CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); - //} - { -#ifdef CONFIRM_COMPILATION_ERRORS span<int, 5> s{arr}; -#endif } { -#ifdef CONFIRM_COMPILATION_ERRORS - auto get_an_array = []() { return std::array<int, 4>{1, 2, 3, 4}; }; - auto take_a_span = [](span<int> s) { (void) s; }; + auto get_an_array = []()->std::array<int, 4> { return{1, 2, 3, 4}; }; + auto take_a_span = [](span<int> s) { static_cast<void>(s); }; // try to take a temporary std::array take_a_span(get_an_array()); + } #endif + + { + auto get_an_array = []() -> std::array<int, 4> { return { 1, 2, 3, 4 }; }; + auto take_a_span = [](span<const int> s) { static_cast<void>(s); }; + // try to take a temporary std::array + take_a_span(get_an_array()); } } @@ -519,7 +422,7 @@ SUITE(span_tests) span<const int, 4> s{arr}; CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); } - +#ifdef CONFIRM_COMPILATION_ERRORS { span<const int, 2> s{arr}; CHECK(s.size() == 2 && s.data() == arr.data()); @@ -530,27 +433,51 @@ SUITE(span_tests) CHECK(s.size() == 0 && s.data() == arr.data()); } - // TODO This is currently an unsupported scenario. We will come back to it as we revise - // the multidimensional interface and what transformations between dimensionality look like - //{ - // span<int, 2, 2> s{arr}; - // CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); - //} - { -#ifdef CONFIRM_COMPILATION_ERRORS span<const int, 5> s{arr}; -#endif } { -#ifdef CONFIRM_COMPILATION_ERRORS auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; }; - auto take_a_span = [](span<const int> s) { (void) s; }; + auto take_a_span = [](span<const int> s) { static_cast<void>(s); }; // try to take a temporary std::array take_a_span(get_an_array()); + } #endif + } + + TEST(from_std_array_const_constructor) + { + std::array<const int, 4> arr = {1, 2, 3, 4}; + + { + span<const int> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); } + + { + span<const int, 4> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + } +#ifdef CONFIRM_COMPILATION_ERRORS + { + span<const int, 2> s{arr}; + CHECK(s.size() == 2 && s.data() == arr.data()); + } + + { + span<const int, 0> s{arr}; + CHECK(s.size() == 0 && s.data() == arr.data()); + } + + { + span<const int, 5> s{arr}; + } + + { + span<int, 4> s{arr}; + } +#endif } TEST(from_container_constructor) @@ -590,23 +517,35 @@ SUITE(span_tests) { #ifdef CONFIRM_COMPILATION_ERRORS auto get_temp_vector = []() -> std::vector<int> { return {}; }; - auto use_span = [](span<int> s) { (void) s; }; + auto use_span = [](span<int> s) { static_cast<void>(s); }; use_span(get_temp_vector()); #endif } { + auto get_temp_vector = []() -> std::vector<int> { return{}; }; + auto use_span = [](span<const int> s) { static_cast<void>(s); }; + use_span(get_temp_vector()); + } + + { #ifdef CONFIRM_COMPILATION_ERRORS - auto get_temp_string = []() -> std::string { return {}; }; - auto use_span = [](span<char> s) { (void) s; }; + auto get_temp_string = []() -> std::string { return{}; }; + auto use_span = [](span<char> s) { static_cast<void>(s); }; use_span(get_temp_string()); #endif } { + auto get_temp_string = []() -> std::string { return {}; }; + auto use_span = [](span<const char> s) { static_cast<void>(s); }; + use_span(get_temp_string()); + } + + { #ifdef CONFIRM_COMPILATION_ERRORS auto get_temp_vector = []() -> const std::vector<int> { return {}; }; - auto use_span = [](span<const char> s) { (void) s; }; + auto use_span = [](span<const char> s) { static_cast<void>(s); }; use_span(get_temp_vector()); #endif } @@ -614,7 +553,7 @@ SUITE(span_tests) { #ifdef CONFIRM_COMPILATION_ERRORS auto get_temp_string = []() -> const std::string { return {}; }; - auto use_span = [](span<const char> s) { (void) s; }; + auto use_span = [](span<const char> s) { static_cast<void>(s); }; use_span(get_temp_string()); #endif } @@ -629,29 +568,39 @@ SUITE(span_tests) TEST(from_convertible_span_constructor) { -#ifdef CONFIRM_COMPILATION_ERRORS - span<int, 7, 4, 2> av1(nullptr, b1); + { + span<DerivedClass> avd; + span<const DerivedClass> avcd = avd; + static_cast<void>(avcd); + } - auto f = [&]() { span<int, 7, 4, 2> av1(nullptr); }; - CHECK_THROW(f(), fail_fast); + { +#ifdef CONFIRM_COMPILATION_ERRORS + span<DerivedClass> avd; + span<BaseClass> avb = avd; + static_cast<void>(avb); #endif + } -#ifdef CONFIRM_COMPILATION_ERRORS - static_bounds<size_t, 7, dynamic_range, 2> b12(b11); - b12 = b11; - b11 = b12; + { + span<int> s; + span<unsigned int> s2 = s; + static_cast<void>(s2); + } - span<int, dynamic_range> av1 = nullptr; - span<int, 7, dynamic_range, 2> av2(av1); - span<int, 7, 4, 2> av2(av1); -#endif + { + span<int> s; + span<const unsigned int> s2 = s; + static_cast<void>(s2); + } - span<DerivedClass> avd; + { #ifdef CONFIRM_COMPILATION_ERRORS - span<BaseClass> avb = avd; + span<int> s; + span<short> s2 = s; + static_cast<void>(s2); #endif - span<const DerivedClass> avcd = avd; - (void) avcd; + } } TEST(copy_move_and_assignment) @@ -675,55 +624,24 @@ SUITE(span_tests) CHECK(s1.length() == 2 && s1.data() == &arr[1]); } - template <class Bounds> - void fn(const Bounds&) - { - static_assert(Bounds::static_size == 60, "static bounds is wrong size"); - } - TEST(as_span_reshape) - { - int a[3][4][5]; - auto av = as_span(a); - fn(av.bounds()); - auto av2 = as_span(av, dim<60>()); - auto av3 = as_span(av2, dim<3>(), dim<4>(), dim<5>()); - auto av4 = as_span(av3, dim<4>(), dim<>(3), dim<5>()); - auto av5 = as_span(av4, dim<3>(), dim<4>(), dim<5>()); - auto av6 = as_span(av5, dim<12>(), dim<>(5)); - - fill(av6.begin(), av6.end(), 1); - - auto av7 = as_bytes(av6); - - auto av8 = as_span<int>(av7); - - CHECK(av8.size() == av6.size()); - for (auto i = 0; i < av8.size(); i++) { - CHECK(av8[i] == 1); - } - } - TEST(first) { int arr[5] = {1, 2, 3, 4, 5}; { span<int, 5> av = arr; - CHECK((av.first<2>().bounds() == static_bounds<2>())); CHECK(av.first<2>().length() == 2); CHECK(av.first(2).length() == 2); } { span<int, 5> av = arr; - CHECK((av.first<0>().bounds() == static_bounds<0>())); CHECK(av.first<0>().length() == 0); CHECK(av.first(0).length() == 0); } { span<int, 5> av = arr; - CHECK((av.first<5>().bounds() == static_bounds<5>())); CHECK(av.first<5>().length() == 5); CHECK(av.first(5).length() == 5); } @@ -731,7 +649,6 @@ SUITE(span_tests) { span<int, 5> av = arr; #ifdef CONFIRM_COMPILATION_ERRORS - CHECK(av.first<6>().bounds() == static_bounds<6>()); CHECK(av.first<6>().length() == 6); CHECK(av.first<-1>().length() == -1); #endif @@ -739,8 +656,7 @@ SUITE(span_tests) } { - span<int, dynamic_range> av; - CHECK((av.first<0>().bounds() == static_bounds<0>())); + span<int> av; CHECK(av.first<0>().length() == 0); CHECK(av.first(0).length() == 0); } @@ -752,21 +668,18 @@ SUITE(span_tests) { span<int, 5> av = arr; - CHECK((av.last<2>().bounds() == static_bounds<2>())); CHECK(av.last<2>().length() == 2); CHECK(av.last(2).length() == 2); } { span<int, 5> av = arr; - CHECK((av.last<0>().bounds() == static_bounds<0>())); CHECK(av.last<0>().length() == 0); CHECK(av.last(0).length() == 0); } { span<int, 5> av = arr; - CHECK((av.last<5>().bounds() == static_bounds<5>())); CHECK(av.last<5>().length() == 5); CHECK(av.last(5).length() == 5); } @@ -774,15 +687,13 @@ SUITE(span_tests) { span<int, 5> av = arr; #ifdef CONFIRM_COMPILATION_ERRORS - CHECK((av.last<6>().bounds() == static_bounds<6>())); CHECK(av.last<6>().length() == 6); #endif CHECK_THROW(av.last(6).length(), fail_fast); } { - span<int, dynamic_range> av; - CHECK((av.last<0>().bounds() == static_bounds<0>())); + span<int> av; CHECK(av.last<0>().length() == 0); CHECK(av.last(0).length() == 0); } @@ -794,7 +705,6 @@ SUITE(span_tests) { span<int, 5> av = arr; - CHECK((av.subspan<2, 2>().bounds() == static_bounds<2>())); CHECK((av.subspan<2, 2>().length() == 2)); CHECK(av.subspan(2, 2).length() == 2); CHECK(av.subspan(2, 3).length() == 3); @@ -802,14 +712,12 @@ SUITE(span_tests) { span<int, 5> av = arr; - CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>())); CHECK((av.subspan<0, 0>().length() == 0)); CHECK(av.subspan(0, 0).length() == 0); } { span<int, 5> av = arr; - CHECK((av.subspan<0, 5>().bounds() == static_bounds<5>())); CHECK((av.subspan<0, 5>().length() == 5)); CHECK(av.subspan(0, 5).length() == 5); CHECK_THROW(av.subspan(0, 6).length(), fail_fast); @@ -818,15 +726,14 @@ SUITE(span_tests) { span<int, 5> av = arr; - CHECK((av.subspan<5, 0>().bounds() == static_bounds<0>())); - CHECK((av.subspan<5, 0>().length() == 0)); + CHECK((av.subspan<4, 0>().length() == 0)); + CHECK(av.subspan(4, 0).length() == 0); CHECK(av.subspan(5, 0).length() == 0); CHECK_THROW(av.subspan(6, 0).length(), fail_fast); } { - span<int, dynamic_range> av; - CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>())); + span<int> av; CHECK((av.subspan<0, 0>().length() == 0)); CHECK(av.subspan(0, 0).length() == 0); CHECK_THROW((av.subspan<1, 0>().length()), fail_fast); @@ -861,106 +768,239 @@ SUITE(span_tests) } } - TEST(rank) + TEST(operator_function_call) { - int arr[2] = {1, 2}; + int arr[4] = {1, 2, 3, 4}; { - span<int> s; - CHECK(s.rank() == 1); + span<int> s = arr; + CHECK(s(0) == 1); + CHECK_THROW(s(5), fail_fast); } { - span<int, 2> s = arr; - CHECK(s.rank() == 1); + int arr2d[2] = {1, 6}; + span<int, 2> s = arr2d; + CHECK(s(0) == 1); + CHECK(s(1) == 6); + CHECK_THROW(s(2) ,fail_fast); } + } - int arr2d[1][1] = {}; - { - span<int, 1, 1> s = arr2d; - CHECK(s.rank() == 2); - } + TEST(iterator) + { + span<int>::iterator it1; + span<int>::iterator it2; + CHECK(it1 == it2); } - TEST(extent) + TEST(const_iterator) { - { - span<int> s; - CHECK(s.extent() == 0); - CHECK(s.extent(0) == 0); - CHECK_THROW(s.extent(1), fail_fast); -#ifdef CONFIRM_COMPILATION_ERRORS - CHECK(s.extent<1>() == 0); -#endif - } + span<int>::const_iterator it1; + span<int>::const_iterator it2; + CHECK(it1 == it2); + } + TEST(begin_end) + { { - span<int, 0> s; - CHECK(s.extent() == 0); - CHECK(s.extent(0) == 0); - CHECK_THROW(s.extent(1), fail_fast); + int a[] = { 1, 2, 3, 4 }; + span<int> s = a; + + auto it = s.begin(); + auto first = it; + CHECK(it == first); + CHECK(*it == 1); + + auto beyond = s.end(); + CHECK(it != beyond); + CHECK_THROW(*beyond, fail_fast); + + CHECK(beyond - first == 4); + CHECK(first - first == 0); + CHECK(beyond - beyond == 0); + + ++it; + CHECK(it - first == 1); + CHECK(*it == 2); + *it = 22; + CHECK(*it == 22); + CHECK(beyond - it == 3); + + it = first; + CHECK(it == first); + while (it != s.end()) + { + *it = 5; + ++it; + } + + CHECK(it == beyond); + CHECK(it - beyond == 0); + + for (auto& n : s) + { + CHECK(n == 5); + } } + } + TEST(cbegin_cend) + { { - int arr2d[1][2] = {}; + int a[] = {1, 2, 3, 4}; + span<int> s = a; + + auto it = s.cbegin(); + auto first = it; + CHECK(it == first); + CHECK(*it == 1); + + auto beyond = s.cend(); + CHECK(it != beyond); + CHECK_THROW(*beyond, fail_fast); + + CHECK(beyond - first == 4); + CHECK(first - first == 0); + CHECK(beyond - beyond == 0); + + ++it; + CHECK(it - first == 1); + CHECK(*it == 2); + *it = 22; + CHECK(*it == 22); + CHECK(beyond - it == 3); + + it = first; + CHECK(it == first); + while (it != s.cend()) + { + *it = 5; + ++it; + } + + CHECK(it == beyond); + CHECK(it - beyond == 0); - span<int, 1, 2> s = arr2d; - CHECK(s.extent() == 1); - CHECK(s.extent<0>() == 1); - CHECK(s.extent<1>() == 2); - CHECK(s.extent(0) == 1); - CHECK(s.extent(1) == 2); - CHECK_THROW(s.extent(3), fail_fast); + for (auto& n : s) + { + CHECK(n == 5); + } } + } + TEST(rbegin_rend) + { { - int arr2d[1][2] = {}; + int a[] = {1, 2, 3, 4}; + span<int> s = a; + + auto it = s.rbegin(); + auto first = it; + CHECK(it == first); + CHECK(*it == 4); + + auto beyond = s.rend(); + CHECK(it != beyond); + CHECK_THROW(*beyond, fail_fast); + + CHECK(beyond - first == 4); + CHECK(first - first == 0); + CHECK(beyond - beyond == 0); + + ++it; + CHECK(it - first == 1); + CHECK(*it == 3); + *it = 22; + CHECK(*it == 22); + CHECK(beyond - it == 3); + + it = first; + CHECK(it == first); + while (it != s.rend()) + { + *it = 5; + ++it; + } - span<int, 0, 2> s = arr2d; - CHECK(s.extent() == 0); - CHECK(s.extent<0>() == 0); - CHECK(s.extent<1>() == 2); - CHECK(s.extent(0) == 0); - CHECK(s.extent(1) == 2); - CHECK_THROW(s.extent(3), fail_fast); + CHECK(it == beyond); + CHECK(it - beyond == 0); + + for (auto& n : s) + { + CHECK(n == 5); + } } } - TEST(operator_function_call) + TEST(crbegin_crend) { - int arr[4] = {1, 2, 3, 4}; - { - span<int> s = arr; - CHECK(s(0) == 1); - CHECK_THROW(s(5), fail_fast); - } + int a[] = {1, 2, 3, 4}; + span<int> s = a; + + auto it = s.crbegin(); + auto first = it; + CHECK(it == first); + CHECK(*it == 4); + + auto beyond = s.crend(); + CHECK(it != beyond); + CHECK_THROW(*beyond, fail_fast); + + CHECK(beyond - first == 4); + CHECK(first - first == 0); + CHECK(beyond - beyond == 0); + + ++it; + CHECK(it - first == 1); + CHECK(*it == 3); + *it = 22; + CHECK(*it == 22); + CHECK(beyond - it == 3); + + it = first; + CHECK(it == first); + while (it != s.crend()) + { + *it = 5; + ++it; + } - int arr2d[2][3] = {1, 2, 3, 4, 5, 6}; + CHECK(it == beyond); + CHECK(it - beyond == 0); - { - span<int, 2, 3> s = arr2d; - CHECK(s(0, 0) == 1); - CHECK(s(1, 2) == 6); + for (auto& n : s) + { + CHECK(n == 5); + } } } TEST(comparison_operators) { { - int arr[10][2]; - auto s1 = as_span(arr); - span<const int, dynamic_range, 2> s2 = s1; - + span<int> s1 = nullptr; + span<int> s2 = nullptr; CHECK(s1 == s2); - - span<int, 20> s3 = as_span(s1, dim<>(20)); - CHECK(s3 == s2 && s3 == s1); + CHECK(!(s1 != s2)); + CHECK(!(s1 < s2)); + CHECK(s1 <= s2); + CHECK(!(s1 > s2)); + CHECK(s1 >= s2); + CHECK(s2 == s1); + CHECK(!(s2 != s1)); + CHECK(!(s2 < s1)); + CHECK(s2 <= s1); + CHECK(!(s2 > s1)); + CHECK(s2 >= s1); } { - auto s1 = nullptr; - auto s2 = nullptr; + int arr[] = {2, 1}; + span<int> s1 = arr; + span<int> s2 = arr; + CHECK(s1 == s2); CHECK(!(s1 != s2)); CHECK(!(s1 < s2)); @@ -1057,539 +1097,122 @@ SUITE(span_tests) } } - TEST(basics) - { - auto ptr = as_span(new int[10], 10); - fill(ptr.begin(), ptr.end(), 99); - for (int num : ptr) { - CHECK(num == 99); - } - - delete[] ptr.data(); - } - - TEST(bounds_checks) - { - int arr[10][2]; - auto av = as_span(arr); - - fill(begin(av), end(av), 0); - - av[2][0] = 1; - av[1][1] = 3; - - // out of bounds - CHECK_THROW(av[1][3] = 3, fail_fast); - CHECK_THROW((av[{1, 3}] = 3), fail_fast); - - CHECK_THROW(av[10][2], fail_fast); - CHECK_THROW((av[{10, 2}]), fail_fast); - } - - void overloaded_func(span<const int, dynamic_range, 3, 5> exp, int expected_value) - { - for (auto val : exp) { - CHECK(val == expected_value); - } - } - - void overloaded_func(span<const char, dynamic_range, 3, 5> exp, char expected_value) - { - for (auto val : exp) { - CHECK(val == expected_value); - } - } - - void fixed_func(span<int, 3, 3, 5> exp, int expected_value) - { - for (auto val : exp) { - CHECK(val == expected_value); - } - } - - TEST(span_parameter_test) - { - auto data = new int[4][3][5]; - - auto av = as_span(data, 4); - - CHECK(av.size() == 60); - - fill(av.begin(), av.end(), 34); - - int count = 0; - for_each(av.rbegin(), av.rend(), [&](int val) { count += val; }); - CHECK(count == 34 * 60); - overloaded_func(av, 34); - - overloaded_func(as_span(av, dim<>(4), dim<>(3), dim<>(5)), 34); - - // fixed_func(av, 34); - delete[] data; - } - - TEST(md_access) - { - auto width = 5, height = 20; - - auto imgSize = width * height; - auto image_ptr = new int[imgSize][3]; - - // size check will be done - auto image_view = - as_span(as_span(image_ptr, imgSize), dim<>(height), dim<>(width), dim<3>()); - - iota(image_view.begin(), image_view.end(), 1); - - int expected = 0; - for (auto i = 0; i < height; i++) { - for (auto j = 0; j < width; j++) { - CHECK(expected + 1 == image_view[i][j][0]); - CHECK(expected + 2 == image_view[i][j][1]); - CHECK(expected + 3 == image_view[i][j][2]); - - auto val = image_view[{i, j, 0}]; - CHECK(expected + 1 == val); - val = image_view[{i, j, 1}]; - CHECK(expected + 2 == val); - val = image_view[{i, j, 2}]; - CHECK(expected + 3 == val); - - expected += 3; - } - } - } - - TEST(as_span) + TEST(as_bytes) { - { - int* arr = new int[150]; - - auto av = as_span(arr, dim<10>(), dim<>(3), dim<5>()); - - fill(av.begin(), av.end(), 24); - overloaded_func(av, 24); - - delete[] arr; - - array<int, 15> stdarr{0}; - auto av2 = as_span(stdarr); - overloaded_func(as_span(av2, dim<>(1), dim<3>(), dim<5>()), 0); - - string str = "ttttttttttttttt"; // size = 15 - auto t = str.data(); - (void) t; - auto av3 = as_span(str); - overloaded_func(as_span(av3, dim<>(1), dim<3>(), dim<5>()), 't'); - } - - { - string str; - span<char> strspan = as_span(str); - (void) strspan; - const string cstr; - span<const char> cstrspan = as_span(cstr); - (void) cstrspan; - } + int a[] = {1, 2, 3, 4}; { - int a[3][4][5]; - auto av = as_span(a); - const int(*b)[4][5]; - b = a; - auto bv = as_span(b, 3); - - CHECK(av == bv); - - const std::array<double, 3> arr = {0.0, 0.0, 0.0}; - auto cv = as_span(arr); - (void) cv; - - vector<float> vec(3); - auto dv = as_span(vec); - (void) dv; - -#ifdef CONFIRM_COMPILATION_ERRORS - auto dv2 = as_span(std::move(vec)); -#endif + span<const int> s = a; + CHECK(s.length() == 4); + span<const byte> bs = as_bytes(s); + CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data())); + CHECK(bs.length() == s.length_bytes()); } - } - TEST(empty_spans) - { { - span<int, 0> empty_av(nullptr); - - CHECK(empty_av.bounds().index_bounds() == index<1>{0}); - CHECK_THROW(empty_av[0], fail_fast); - CHECK_THROW(empty_av.begin()[0], fail_fast); - CHECK_THROW(empty_av.cbegin()[0], fail_fast); - for (auto& v : empty_av) { - (void) v; - CHECK(false); - } + span<int> s; + auto bs = as_bytes(s); + CHECK(bs.length() == s.length()); + CHECK(bs.length() == 0); + CHECK(bs.size_bytes() == 0); + CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data())); + CHECK(bs.data() == nullptr); } { - span<int> empty_av = {}; - CHECK(empty_av.bounds().index_bounds() == index<1>{0}); - CHECK_THROW(empty_av[0], fail_fast); - CHECK_THROW(empty_av.begin()[0], fail_fast); - CHECK_THROW(empty_av.cbegin()[0], fail_fast); - for (auto& v : empty_av) { - (void) v; - CHECK(false); - } + span<int> s = a; + auto bs = as_bytes(s); + CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data())); + CHECK(bs.length() == s.length_bytes()); } } - TEST(index_constructor) - { - auto arr = new int[8]; - for (int i = 0; i < 4; ++i) { - arr[2 * i] = 4 + i; - arr[2 * i + 1] = i; - } - - span<int, dynamic_range> av(arr, 8); - - ptrdiff_t a[1] = {0}; - index<1> i = a; - - CHECK(av[i] == 4); - - auto av2 = as_span(av, dim<4>(), dim<>(2)); - ptrdiff_t a2[2] = {0, 1}; - index<2> i2 = a2; - - CHECK(av2[i2] == 0); - CHECK(av2[0][i] == 4); - - delete[] arr; - } - - TEST(index_constructors) + TEST(as_writeable_bytes) { - { - // components of the same type - index<3> i1(0, 1, 2); - CHECK(i1[0] == 0); - - // components of different types - size_t c0 = 0; - size_t c1 = 1; - index<3> i2(c0, c1, 2); - CHECK(i2[0] == 0); - - // from array - index<3> i3 = {0, 1, 2}; - CHECK(i3[0] == 0); - - // from other index of the same size type - index<3> i4 = i3; - CHECK(i4[0] == 0); - - // default - index<3> i7; - CHECK(i7[0] == 0); - - // default - index<3> i9 = {}; - CHECK(i9[0] == 0); - } + int a[] = {1, 2, 3, 4}; { - // components of the same type - index<1> i1(0); - CHECK(i1[0] == 0); - - // components of different types - size_t c0 = 0; - index<1> i2(c0); - CHECK(i2[0] == 0); - - // from array - index<1> i3 = {0}; - CHECK(i3[0] == 0); - - // from int - index<1> i4 = 0; - CHECK(i4[0] == 0); - - // from other index of the same size type - index<1> i5 = i3; - CHECK(i5[0] == 0); - - // default - index<1> i8; - CHECK(i8[0] == 0); - - // default - index<1> i9 = {}; - CHECK(i9[0] == 0); - } - #ifdef CONFIRM_COMPILATION_ERRORS - { - index<3> i1(0, 1); - index<3> i2(0, 1, 2, 3); - index<3> i3 = {0}; - index<3> i4 = {0, 1, 2, 3}; - index<1> i5 = {0, 1}; - } + // you should not be able to get writeable bytes for const objects + span<const int> s = a; + CHECK(s.length() == 4); + span<const byte> bs = as_writeable_bytes(s); + CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data())); + CHECK(bs.length() == s.length_bytes()); #endif - } - - TEST(index_operations) - { - ptrdiff_t a[3] = {0, 1, 2}; - ptrdiff_t b[3] = {3, 4, 5}; - index<3> i = a; - index<3> j = b; - - CHECK(i[0] == 0); - CHECK(i[1] == 1); - CHECK(i[2] == 2); - - { - index<3> k = i + j; - - CHECK(i[0] == 0); - CHECK(i[1] == 1); - CHECK(i[2] == 2); - CHECK(k[0] == 3); - CHECK(k[1] == 5); - CHECK(k[2] == 7); - } - - { - index<3> k = i * 3; - - CHECK(i[0] == 0); - CHECK(i[1] == 1); - CHECK(i[2] == 2); - CHECK(k[0] == 0); - CHECK(k[1] == 3); - CHECK(k[2] == 6); - } - - { - index<3> k = 3 * i; - - CHECK(i[0] == 0); - CHECK(i[1] == 1); - CHECK(i[2] == 2); - CHECK(k[0] == 0); - CHECK(k[1] == 3); - CHECK(k[2] == 6); } { - index<2> k = details::shift_left(i); - - CHECK(i[0] == 0); - CHECK(i[1] == 1); - CHECK(i[2] == 2); - CHECK(k[0] == 1); - CHECK(k[1] == 2); - } - } - - void iterate_second_column(span<int, dynamic_range, dynamic_range> av) - { - auto length = av.size() / 2; - - // view to the second column - auto section = av.section({0, 1}, {length, 1}); - - CHECK(section.size() == length); - for (auto i = 0; i < section.size(); ++i) { - CHECK(section[i][0] == av[i][1]); - } - - for (auto i = 0; i < section.size(); ++i) { - auto idx = index<2>{i, 0}; // avoid braces inside the CHECK macro - CHECK(section[idx] == av[i][1]); - } - - CHECK(section.bounds().index_bounds()[0] == length); - CHECK(section.bounds().index_bounds()[1] == 1); - for (auto i = 0; i < section.bounds().index_bounds()[0]; ++i) { - for (auto j = 0; j < section.bounds().index_bounds()[1]; ++j) { - auto idx = index<2>{i, j}; // avoid braces inside the CHECK macro - CHECK(section[idx] == av[i][1]); - } - } - - size_t check_sum = 0; - for (auto i = 0; i < length; ++i) { - check_sum += av[i][1]; - } - - { - auto idx = 0; - size_t sum = 0; - for (auto num : section) { - CHECK(num == av[idx][1]); - sum += num; - idx++; - } - - CHECK(sum == check_sum); - } - { - size_t idx = length - 1; - size_t sum = 0; - for (auto iter = section.rbegin(); iter != section.rend(); ++iter) { - CHECK(*iter == av[idx][1]); - sum += *iter; - idx--; - } - - CHECK(sum == check_sum); + span<int> s; + auto bs = as_writeable_bytes(s); + CHECK(bs.length() == s.length()); + CHECK(bs.length() == 0); + CHECK(bs.size_bytes() == 0); + CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data())); + CHECK(bs.data() == nullptr); } - } - - TEST(span_section_iteration) - { - int arr[4][2] = {{4, 0}, {5, 1}, {6, 2}, {7, 3}}; - // static bounds - { - span<int, 4, 2> av = arr; - iterate_second_column(av); - } - // first bound is dynamic - { - span<int, dynamic_range, 2> av = arr; - iterate_second_column(av); - } - // second bound is dynamic - { - span<int, 4, dynamic_range> av = arr; - iterate_second_column(av); - } - // both bounds are dynamic { - span<int, dynamic_range, dynamic_range> av = arr; - iterate_second_column(av); + span<int> s = a; + auto bs = as_writeable_bytes(s); + CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data())); + CHECK(bs.length() == s.length_bytes()); } } - TEST(dynamic_span_section_iteration) - { - auto height = 4, width = 2; - auto size = height * width; - - auto arr = new int[size]; - for (auto i = 0; i < size; ++i) { - arr[i] = i; - } - - auto av = as_span(arr, size); - - // first bound is dynamic - { - span<int, dynamic_range, 2> av2 = as_span(av, dim<>(height), dim<>(width)); - iterate_second_column(av2); - } - // second bound is dynamic - { - span<int, 4, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width)); - iterate_second_column(av2); - } - // both bounds are dynamic - { - span<int, dynamic_range, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width)); - iterate_second_column(av2); - } - - delete[] arr; - } - - TEST(span_structure_size) - { - double(*arr)[3][4] = new double[100][3][4]; - span<double, dynamic_range, 3, 4> av1(arr, 10); - - struct EffectiveStructure - { - double* v1; - ptrdiff_t v2; - }; - CHECK(sizeof(av1) == sizeof(EffectiveStructure)); - - CHECK_THROW(av1[10][3][4], fail_fast); - - span<const double, dynamic_range, 6, 4> av2 = as_span(av1, dim<>(5), dim<6>(), dim<4>()); - (void) av2; - } - TEST(fixed_size_conversions) { int arr[] = {1, 2, 3, 4}; // converting to an span from an equal size array is ok - span<int, 4> av4 = arr; - CHECK(av4.length() == 4); + span<int, 4> s4 = arr; + CHECK(s4.length() == 4); - // converting to dynamic_range a_v is always ok + // converting to dynamic_range is always ok { - span<int, dynamic_range> av = av4; - (void) av; - } - { - span<int, dynamic_range> av = arr; - (void) av; + span<int> s = s4; + CHECK(s.length() == s4.length()); + static_cast<void>(s); } // initialization or assignment to static span that REDUCES size is NOT ok #ifdef CONFIRM_COMPILATION_ERRORS { - span<int, 2> av2 = arr; - } - { - span<int, 2> av2 = av4; - } -#endif - - { - span<int, dynamic_range> av = arr; - span<int, 2> av2 = av; - (void) av2; + span<int, 2> s = arr; } - -#ifdef CONFIRM_COMPILATION_ERRORS { - span<int, dynamic_range> av = arr; - span<int, 2, 1> av2 = av.as_span(dim<2>(), dim<2>()); + span<int, 2> s2 = s4; + static_cast<void>(s2); } #endif + // even when done dynamically { - span<int, dynamic_range> av = arr; - span<int, 2, 1> av2 = as_span(av, dim<>(2), dim<>(2)); - auto workaround_macro = [&]() { return av2[{1, 0}] == 2; }; - CHECK(workaround_macro()); + span<int> s = arr; + auto f = [&]() { + span<int, 2> s2 = s; + static_cast<void>(s2); + }; + CHECK_THROW(f(), fail_fast); } // but doing so explicitly is ok // you can convert statically { - span<int, 2> av2 = {arr, 2}; - (void) av2; + span<int, 2> s2 = {arr, 2}; + static_cast<void>(s2); } { - span<int, 1> av2 = av4.first<1>(); - (void) av2; + span<int, 1> s1 = s4.first<1>(); + static_cast<void>(s1); } // ...or dynamically { - // NB: implicit conversion to span<int,2> from span<int,dynamic_range> - span<int, 1> av2 = av4.first(1); - (void) av2; + // NB: implicit conversion to span<int,1> from span<int> + span<int, 1> s1 = s4.first(1); + static_cast<void>(s1); } // initialization or assignment to static span that requires size INCREASE is not ok. @@ -1597,83 +1220,29 @@ SUITE(span_tests) #ifdef CONFIRM_COMPILATION_ERRORS { - span<int, 4> av4 = arr2; + span<int, 4> s3 = arr2; } { - span<int, 2> av2 = arr2; - span<int, 4> av4 = av2; + span<int, 2> s2 = arr2; + span<int, 4> s4a = s2; } #endif { auto f = [&]() { - span<int, 4> av9 = {arr2, 2}; - (void) av9; - }; + span<int, 4> s4 = {arr2, 2}; + static_cast<void>(s4); + }; CHECK_THROW(f(), fail_fast); } - // this should fail - we are trying to assign a small dynamic a_v to a fixed_size larger one - span<int, dynamic_range> av = arr2; + // this should fail - we are trying to assign a small dynamic span to a fixed_size larger one + span<int> av = arr2; auto f = [&]() { - span<int, 4> av2 = av; - (void) av2; + span<int, 4> s4 = av; + static_cast<void>(s4); }; CHECK_THROW(f(), fail_fast); } - - TEST(as_writeable_bytes) - { - int a[] = {1, 2, 3, 4}; - - { -#ifdef CONFIRM_COMPILATION_ERRORS - // you should not be able to get writeable bytes for const objects - span<const int, dynamic_range> av = a; - auto wav = av.as_writeable_bytes(); -#endif - } - - { - span<int, dynamic_range> av; - auto wav = as_writeable_bytes(av); - CHECK(wav.length() == av.length()); - CHECK(wav.length() == 0); - CHECK(wav.size_bytes() == 0); - } - - { - span<int, dynamic_range> av = a; - auto wav = as_writeable_bytes(av); - CHECK(wav.data() == (byte*) &a[0]); - CHECK(wav.length() == sizeof(a)); - } - } - - TEST(iterator) - { - int a[] = {1, 2, 3, 4}; - - { - span<int, dynamic_range> av = a; - auto wav = as_writeable_bytes(av); - for (auto& b : wav) { - b = byte(0); - } - for (size_t i = 0; i < 4; ++i) { - CHECK(a[i] == 0); - } - } - - { - span<int, dynamic_range> av = a; - for (auto& n : av) { - n = 1; - } - for (size_t i = 0; i < 4; ++i) { - CHECK(a[i] == 1); - } - } - } } int main(int, const char* []) { return UnitTest::RunAllTests(); } diff --git a/tests/strided_span_tests.cpp b/tests/strided_span_tests.cpp index 0fbf1d7..19056b1 100644 --- a/tests/strided_span_tests.cpp +++ b/tests/strided_span_tests.cpp @@ -15,7 +15,7 @@ /////////////////////////////////////////////////////////////////////////////// #include <UnitTest++/UnitTest++.h> -#include <span.h> +#include <multi_span.h> #include <string> #include <vector> @@ -39,7 +39,7 @@ SUITE(strided_span_tests) { int a[30][4][5]; - auto av = as_span(a); + auto av = as_multi_span(a); auto sub = av.section({15, 0, 0}, gsl::index<3>{2, 2, 2}); auto subsub = sub.section({1, 0, 0}, gsl::index<3>{1, 1, 1}); (void)subsub; @@ -49,7 +49,7 @@ SUITE(strided_span_tests) { std::vector<int> data(5 * 10); std::iota(begin(data), end(data), 0); - const span<int, 5, 10> av = as_span(span<int>{data}, dim<5>(), dim<10>()); + const multi_span<int, 5, 10> av = as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>()); strided_span<int, 2> av_section_1 = av.section({ 1, 2 }, { 3, 4 }); CHECK((av_section_1[{0, 0}] == 12)); @@ -87,13 +87,13 @@ SUITE(strided_span_tests) CHECK((sav3[{0, 0}] == 1 && sav3[{0, 1}] == 3 && sav3[{1, 0}] == 7)); } - // Check span constructor + // Check multi_span constructor { int arr[] = { 1, 2 }; // From non-cv-qualified source { - const span<int> src = arr; + const multi_span<int> src = arr; strided_span<int, 1> sav{ src, {2, 1} }; CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); @@ -102,9 +102,9 @@ SUITE(strided_span_tests) #if _MSC_VER > 1800 //strided_span<const int, 1> sav_c{ {src}, {2, 1} }; - strided_span<const int, 1> sav_c{ span<const int>{src}, strided_bounds<1>{2, 1} }; + strided_span<const int, 1> sav_c{ multi_span<const int>{src}, strided_bounds<1>{2, 1} }; #else - strided_span<const int, 1> sav_c{ span<const int>{src}, strided_bounds<1>{2, 1} }; + strided_span<const int, 1> sav_c{ multi_span<const int>{src}, strided_bounds<1>{2, 1} }; #endif CHECK(sav_c.bounds().index_bounds() == index<1>{ 2 }); CHECK(sav_c.bounds().strides() == index<1>{ 1 }); @@ -113,7 +113,7 @@ SUITE(strided_span_tests) #if _MSC_VER > 1800 strided_span<volatile int, 1> sav_v{ src, {2, 1} }; #else - strided_span<volatile int, 1> sav_v{ span<volatile int>{src}, strided_bounds<1>{2, 1} }; + strided_span<volatile int, 1> sav_v{ multi_span<volatile int>{src}, strided_bounds<1>{2, 1} }; #endif CHECK(sav_v.bounds().index_bounds() == index<1>{ 2 }); CHECK(sav_v.bounds().strides() == index<1>{ 1 }); @@ -122,7 +122,7 @@ SUITE(strided_span_tests) #if _MSC_VER > 1800 strided_span<const volatile int, 1> sav_cv{ src, {2, 1} }; #else - strided_span<const volatile int, 1> sav_cv{ span<const volatile int>{src}, strided_bounds<1>{2, 1} }; + strided_span<const volatile int, 1> sav_cv{ multi_span<const volatile int>{src}, strided_bounds<1>{2, 1} }; #endif CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); @@ -131,7 +131,7 @@ SUITE(strided_span_tests) // From const-qualified source { - const span<const int> src{ arr }; + const multi_span<const int> src{ arr }; strided_span<const int, 1> sav_c{ src, {2, 1} }; CHECK(sav_c.bounds().index_bounds() == index<1>{ 2 }); @@ -141,7 +141,7 @@ SUITE(strided_span_tests) #if _MSC_VER > 1800 strided_span<const volatile int, 1> sav_cv{ src, {2, 1} }; #else - strided_span<const volatile int, 1> sav_cv{ span<const volatile int>{src}, strided_bounds<1>{2, 1} }; + strided_span<const volatile int, 1> sav_cv{ multi_span<const volatile int>{src}, strided_bounds<1>{2, 1} }; #endif CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); @@ -151,7 +151,7 @@ SUITE(strided_span_tests) // From volatile-qualified source { - const span<volatile int> src{ arr }; + const multi_span<volatile int> src{ arr }; strided_span<volatile int, 1> sav_v{ src, {2, 1} }; CHECK(sav_v.bounds().index_bounds() == index<1>{ 2 }); @@ -161,7 +161,7 @@ SUITE(strided_span_tests) #if _MSC_VER > 1800 strided_span<const volatile int, 1> sav_cv{ src, {2, 1} }; #else - strided_span<const volatile int, 1> sav_cv{ span<const volatile int>{src}, strided_bounds<1>{2, 1} }; + strided_span<const volatile int, 1> sav_cv{ multi_span<const volatile int>{src}, strided_bounds<1>{2, 1} }; #endif CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); @@ -170,7 +170,7 @@ SUITE(strided_span_tests) // From cv-qualified source { - const span<const volatile int> src{ arr }; + const multi_span<const volatile int> src{ arr }; strided_span<const volatile int, 1> sav_cv{ src, {2, 1} }; CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); @@ -183,11 +183,11 @@ SUITE(strided_span_tests) { int arr[2] = { 4, 5 }; - const span<int, 2> av(arr, 2); - span<const int, 2> av2{ av }; + const multi_span<int, 2> av(arr, 2); + multi_span<const int, 2> av2{ av }; CHECK(av2[1] == 5); - static_assert(std::is_convertible<const span<int, 2>, span<const int, 2>>::value, "ctor is not implicit!"); + static_assert(std::is_convertible<const multi_span<int, 2>, multi_span<const int, 2>>::value, "ctor is not implicit!"); const strided_span<int, 1> src{ arr, {2, 1} }; strided_span<const int, 1> sav{ src }; @@ -258,13 +258,13 @@ SUITE(strided_span_tests) { std::vector<int> data(5 * 10); std::iota(begin(data), end(data), 0); - const span<int, 5, 10> src = as_span(span<int>{data}, dim<5>(), dim<10>()); + const multi_span<int, 5, 10> src = as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>()); const strided_span<int, 2> sav{ src, {{5, 10}, {10, 1}} }; #ifdef CONFIRM_COMPILATION_ERRORS const strided_span<const int, 2> csav{ {src},{ { 5, 10 },{ 10, 1 } } }; #endif - const strided_span<const int, 2> csav{ span<const int, 5, 10>{ src }, { { 5, 10 },{ 10, 1 } } }; + const strided_span<const int, 2> csav{ multi_span<const int, 5, 10>{ src }, { { 5, 10 },{ 10, 1 } } }; strided_span<int, 1> sav_sl = sav[2]; CHECK(sav_sl[0] == 20); @@ -317,7 +317,7 @@ SUITE(strided_span_tests) TEST(strided_span_bounds) { int arr[] = { 0, 1, 2, 3 }; - span<int> av(arr); + multi_span<int> av(arr); { // incorrect sections @@ -413,18 +413,18 @@ SUITE(strided_span_tests) strided_span<int, 1> sav2{ arr, { 1,1,1 } }; strided_span<int, 1> sav3{ av, { 1 } }; strided_span<int, 1> sav4{ av, { 1,1,1 } }; - strided_span<int, 2> sav5{ av.as_span(dim<2>(), dim<2>()), { 1 } }; - strided_span<int, 2> sav6{ av.as_span(dim<2>(), dim<2>()), { 1,1,1 } }; - strided_span<int, 2> sav7{ av.as_span(dim<2>(), dim<2>()), { { 1,1 },{ 1,1 },{ 1,1 } } }; + strided_span<int, 2> sav5{ av.as_multi_span(dim<2>(), dim<2>()), { 1 } }; + strided_span<int, 2> sav6{ av.as_multi_span(dim<2>(), dim<2>()), { 1,1,1 } }; + strided_span<int, 2> sav7{ av.as_multi_span(dim<2>(), dim<2>()), { { 1,1 },{ 1,1 },{ 1,1 } } }; index<1> index{ 0, 1 }; strided_span<int, 1> sav8{ arr,{ 1,{ 1,1 } } }; strided_span<int, 1> sav9{ arr,{ { 1,1 },{ 1,1 } } }; strided_span<int, 1> sav10{ av,{ 1,{ 1,1 } } }; strided_span<int, 1> sav11{ av,{ { 1,1 },{ 1,1 } } }; - strided_span<int, 2> sav12{ av.as_span(dim<2>(), dim<2>()),{ { 1 },{ 1 } } }; - strided_span<int, 2> sav13{ av.as_span(dim<2>(), dim<2>()),{ { 1 },{ 1,1,1 } } }; - strided_span<int, 2> sav14{ av.as_span(dim<2>(), dim<2>()),{ { 1,1,1 },{ 1 } } }; + strided_span<int, 2> sav12{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1 },{ 1 } } }; + strided_span<int, 2> sav13{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1 },{ 1,1,1 } } }; + strided_span<int, 2> sav14{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1,1,1 },{ 1 } } }; } #endif } @@ -432,7 +432,7 @@ SUITE(strided_span_tests) TEST(strided_span_type_conversion) { int arr[] = { 0, 1, 2, 3 }; - span<int> av(arr); + multi_span<int> av(arr); { strided_span<int, 1> sav{ av.data(), av.size(), { av.size() / 2, 2 } }; @@ -447,7 +447,7 @@ SUITE(strided_span_tests) #endif } - span<const byte, dynamic_range> bytes = as_bytes(av); + multi_span<const byte, dynamic_range> bytes = as_bytes(av); // retype strided array with regular strides - from raw data { @@ -460,10 +460,10 @@ SUITE(strided_span_tests) CHECK_THROW(sav3[0][1], fail_fast); } - // retype strided array with regular strides - from span + // retype strided array with regular strides - from multi_span { strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } }; - span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); strided_span<const byte, 2> sav2{ bytes2, bounds }; strided_span<int, 2> sav3 = sav2.as_strided_span<int>(); CHECK(sav3[0][0] == 0); @@ -475,7 +475,7 @@ SUITE(strided_span_tests) // retype strided array with not enough elements - last dimension of the array is too small { strided_bounds<2> bounds{ { 4,2 },{ 4, 1 } }; - span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); strided_span<const byte, 2> sav2{ bytes2, bounds }; CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); } @@ -483,7 +483,7 @@ SUITE(strided_span_tests) // retype strided array with not enough elements - strides are too small { strided_bounds<2> bounds{ { 4,2 },{ 2, 1 } }; - span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); strided_span<const byte, 2> sav2{ bytes2, bounds }; CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); } @@ -491,7 +491,7 @@ SUITE(strided_span_tests) // retype strided array with not enough elements - last dimension does not divide by the new typesize { strided_bounds<2> bounds{ { 2,6 },{ 4, 1 } }; - span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); strided_span<const byte, 2> sav2{ bytes2, bounds }; CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); } @@ -499,7 +499,7 @@ SUITE(strided_span_tests) // retype strided array with not enough elements - strides does not divide by the new typesize { strided_bounds<2> bounds{ { 2, 1 },{ 6, 1 } }; - span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); strided_span<const byte, 2> sav2{ bytes2, bounds }; CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); } @@ -511,7 +511,7 @@ SUITE(strided_span_tests) CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); } - // retype strided array with irregular strides - from span + // retype strided array with irregular strides - from multi_span { strided_bounds<1> bounds{ bytes.size() / 2, 2 }; strided_span<const byte, 1> sav2{ bytes, bounds }; @@ -522,7 +522,7 @@ SUITE(strided_span_tests) TEST(empty_strided_spans) { { - span<int, 0> empty_av(nullptr); + multi_span<int, 0> empty_av(nullptr); strided_span<int, 1> empty_sav{ empty_av, { 0, 1 } }; CHECK(empty_sav.bounds().index_bounds() == index<1>{ 0 }); @@ -553,7 +553,7 @@ SUITE(strided_span_tests) } } - void iterate_every_other_element(span<int, dynamic_range> av) + void iterate_every_other_element(multi_span<int, dynamic_range> av) { // pick every other element @@ -586,13 +586,13 @@ SUITE(strided_span_tests) // static bounds { - span<int, 8> av(arr, 8); + multi_span<int, 8> av(arr, 8); iterate_every_other_element(av); } // dynamic bounds { - span<int, dynamic_range> av(arr, 8); + multi_span<int, dynamic_range> av(arr, 8); iterate_every_other_element(av); } } @@ -606,13 +606,13 @@ SUITE(strided_span_tests) arr[2 * i + 1] = i; } - auto av = as_span(arr, 8); + auto av = as_multi_span(arr, 8); iterate_every_other_element(av); delete[] arr; } - void iterate_second_slice(span<int, dynamic_range, dynamic_range, dynamic_range> av) + void iterate_second_slice(multi_span<int, dynamic_range, dynamic_range, dynamic_range> av) { int expected[6] = {2,3,10,11,18,19}; auto section = av.section({0,1,0}, {3,1,2}); @@ -653,7 +653,7 @@ SUITE(strided_span_tests) } { - span<int, 3, 4, 2> av = arr; + multi_span<int, 3, 4, 2> av = arr; iterate_second_slice(av); } } @@ -670,22 +670,22 @@ SUITE(strided_span_tests) } { - auto av = as_span(as_span(arr, 24), dim<3>(), dim<4>(), dim<2>()); + auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim<2>()); iterate_second_slice(av); } { - auto av = as_span(as_span(arr, 24), dim<>(3), dim<4>(), dim<2>()); + auto av = as_multi_span(as_multi_span(arr, 24), dim<>(3), dim<4>(), dim<2>()); iterate_second_slice(av); } { - auto av = as_span(as_span(arr, 24), dim<3>(), dim<>(4), dim<2>()); + auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<>(4), dim<2>()); iterate_second_slice(av); } { - auto av = as_span(as_span(arr, 24), dim<3>(), dim<4>(), dim<>(2)); + auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim<>(2)); iterate_second_slice(av); } delete[] arr; @@ -693,7 +693,7 @@ SUITE(strided_span_tests) TEST(strided_span_conversion) { - // get an span of 'c' values from the list of X's + // get an multi_span of 'c' values from the list of X's struct X { int a; int b; int c; }; @@ -704,7 +704,7 @@ SUITE(strided_span_tests) auto d1 = sizeof(int) * 12 / d2; // convert to 4x12 array of bytes - auto av = as_span(as_bytes(as_span(arr, 4)), dim<>(d1), dim<>(d2)); + auto av = as_multi_span(as_bytes(as_multi_span(arr, 4)), dim<>(d1), dim<>(d2)); CHECK(av.bounds().index_bounds()[0] == 4); CHECK(av.bounds().index_bounds()[1] == 12); diff --git a/tests/string_span_tests.cpp b/tests/string_span_tests.cpp index 28d7353..876886a 100644 --- a/tests/string_span_tests.cpp +++ b/tests/string_span_tests.cpp @@ -40,14 +40,14 @@ SUITE(string_span_tests) { std::string s = "Hello there world"; cstring_span<> v = s; - CHECK(v.length() == static_cast<cstring_span<>::size_type>(s.length())); + CHECK(v.length() == static_cast<cstring_span<>::index_type>(s.length())); } TEST(TestConstructFromStdVector) { std::vector<char> vec(5, 'h'); - string_span<> v = vec; - CHECK(v.length() == static_cast<string_span<>::size_type>(vec.size())); + string_span<> v {vec}; + CHECK(v.length() == static_cast<string_span<>::index_type>(vec.size())); } TEST(TestStackArrayConstruction) @@ -109,7 +109,7 @@ SUITE(string_span_tests) char stack_string[] = "Hello"; cstring_span<> v = ensure_z(stack_string); auto s2 = gsl::to_string(v); - CHECK(static_cast<cstring_span<>::size_type>(s2.length()) == v.length()); + CHECK(static_cast<cstring_span<>::index_type>(s2.length()) == v.length()); CHECK(s2.length() == 5); } @@ -746,7 +746,7 @@ SUITE(string_span_tests) T create() { return T{}; } template <class T> - void use(basic_string_span<T, gsl::dynamic_range> s) {} + void use(basic_string_span<T, gsl::dynamic_extent> s) {} TEST(MoveConstructors) { diff --git a/tests/utils_tests.cpp b/tests/utils_tests.cpp index a46d6e4..11582de 100644 --- a/tests/utils_tests.cpp +++ b/tests/utils_tests.cpp @@ -103,7 +103,7 @@ SUITE(utils_tests) CHECK(narrow<uint32_t>(int32_t(0)) == 0); CHECK(narrow<uint32_t>(int32_t(1)) == 1); - CHECK(narrow<uint32_t>(int32_max) == int32_max); + CHECK(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max)); CHECK_THROW(narrow<uint32_t>(int32_t(-1)), narrowing_error); CHECK_THROW(narrow<uint32_t>(int32_min), narrowing_error); |