diff --git a/include/gsl_assert.h b/include/gsl_assert.h index 4a40552..81cfd13 100644 --- a/include/gsl_assert.h +++ b/include/gsl_assert.h @@ -55,9 +55,9 @@ struct fail_fast : public std::runtime_error } #define Expects(cond) if (!(cond)) \ - throw gsl::fail_fast("GSL: Precondition failure at " __FILE__ GSL_STRINGIFY(__LINE__)); + 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__)); + throw gsl::fail_fast("GSL: Postcondition failure at " __FILE__ ": " GSL_STRINGIFY(__LINE__)); #elif defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION) diff --git a/include/gsl_util.h b/include/gsl_util.h index b6f56ce..e38868c 100644 --- a/include/gsl_util.h +++ b/include/gsl_util.h @@ -76,23 +76,23 @@ private: // finally() - convenience function to generate a final_act template -final_act finally(const F &f) +inline final_act finally(const F &f) noexcept { return final_act(f); } template -final_act finally(F &&f) noexcept +inline final_act finally(F &&f) noexcept { return final_act(std::forward(f)); } // narrow_cast(): a searchable way to do narrowing casts of values template -constexpr T narrow_cast(U u) noexcept +inline constexpr T narrow_cast(U u) noexcept { return static_cast(u); } struct narrowing_error : public std::exception {}; // narrow() : a checked version of narrow_cast() that throws if the cast changed the value template -T narrow(U u) +inline T narrow(U u) { T t = narrow_cast(u); if (static_cast(t) != u) throw narrowing_error(); return t; } // diff --git a/include/span.h b/include/span.h index 0c67d22..4f0de0b 100644 --- a/include/span.h +++ b/include/span.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 @@ -19,8 +19,11 @@ #ifndef GSL_SPAN_H #define GSL_SPAN_H +#include "gsl_assert.h" +#include "gsl_util.h" #include #include +#include #include #include #include @@ -31,14 +34,12 @@ #include #include #include -#include -#include "gsl_assert.h" #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 +#pragma warning(disable : 4127) // conditional expression is constant // No MSVC does constexpr fully yet #pragma push_macro("constexpr") @@ -47,19 +48,19 @@ // VS 2013 workarounds #if _MSC_VER <= 1800 -// needed in span.h -#define GSL_MSVC_HAS_VARIADIC_CTOR_BUG +#define GSL_MSVC_HAS_VARIADIC_CTOR_BUG +#define GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT -// noexcept is not understood +// noexcept is not understood #ifndef GSL_THROWS_ON_CONTRACT_VIOLATION #pragma push_macro("noexcept") -#define noexcept /* nothing */ +#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 +#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 @@ -71,12 +72,12 @@ #pragma push_macro("noexcept") #endif -#define noexcept /* nothing */ +#define noexcept /* nothing */ -#endif // GSL_THROW_ON_CONTRACT_VIOLATION +#endif // GSL_THROW_ON_CONTRACT_VIOLATION - -namespace gsl { +namespace gsl +{ /* ** begin definitions of index and bounds @@ -89,12 +90,17 @@ namespace details static const SizeType max_value = std::numeric_limits::max(); }; + template + class are_integral : public std::integral_constant + { + }; - template - class are_integral : public std::integral_constant {}; - - template - class are_integral : public std::integral_constant::value && are_integral::value> {}; + template + class are_integral + : public std::integral_constant::value && are_integral::value> + { + }; } template @@ -112,26 +118,28 @@ public: using reference = std::add_lvalue_reference_t; using const_reference = std::add_lvalue_reference_t>; - constexpr index() noexcept - {} + constexpr index() noexcept {} - constexpr index(const value_type(&values)[Rank]) noexcept + constexpr index(const value_type (&values)[Rank]) noexcept { std::copy(values, values + Rank, elems); } #ifdef GSL_MSVC_HAS_VARIADIC_CTOR_BUG - template::value && - details::are_integral::value>> - constexpr index(T t, Ts... ds) : index({ static_cast(t), static_cast(ds)... }) - {} + template < + typename T, typename... Ts, + typename = std::enable_if_t<((sizeof...(Ts) + 1) == Rank) && std::is_integral::value && + details::are_integral::value>> + constexpr index(T t, Ts... ds) + : index({narrow_cast(t), narrow_cast(ds)...}) + { + } #else - template::value>> - constexpr index(Ts... ds) noexcept : elems{ static_cast(ds)... } - {} + template ::value>> + constexpr index(Ts... ds) noexcept : elems{narrow_cast(ds)...} + { + } #endif constexpr index(const index& other) noexcept = default; @@ -157,15 +165,9 @@ public: return std::equal(elems, elems + rank, rhs.elems); } - constexpr bool operator!=(const index& rhs) const noexcept - { - return !(this == rhs); - } + constexpr bool operator!=(const index& rhs) const noexcept { return !(this == rhs); } - constexpr index operator+() const noexcept - { - return *this; - } + constexpr index operator+() const noexcept { return *this; } constexpr index operator-() const noexcept { @@ -221,13 +223,15 @@ public: constexpr index& operator*=(value_type v) noexcept { - std::transform(elems, elems + rank, elems, [v](value_type x) { return std::multiplies{}(x, v); }); + std::transform(elems, elems + rank, elems, + [v](value_type x) { return std::multiplies{}(x, v); }); return *this; } constexpr index& operator/=(value_type v) noexcept { - std::transform(elems, elems + rank, elems, [v](value_type x) { return std::divides{}(x, v); }); + std::transform(elems, elems + rank, elems, + [v](value_type x) { return std::divides{}(x, v); }); return *this; } @@ -242,31 +246,30 @@ struct static_bounds_dynamic_range_t template ::value>> constexpr operator T() const noexcept { - return static_cast(-1); + return narrow_cast(-1); } template ::value>> - constexpr bool operator ==(T other) const noexcept + constexpr bool operator==(T other) const noexcept { - return static_cast(-1) == other; + return narrow_cast(-1) == other; } template ::value>> - constexpr bool operator !=(T other) const noexcept + constexpr bool operator!=(T other) const noexcept { - return static_cast(-1) != other; + return narrow_cast(-1) != other; } - }; template ::value>> -constexpr bool operator ==(T left, static_bounds_dynamic_range_t right) noexcept +constexpr bool operator==(T left, static_bounds_dynamic_range_t right) noexcept { return right == left; } template ::value>> -constexpr bool operator !=(T left, static_bounds_dynamic_range_t right) noexcept +constexpr bool operator!=(T left, static_bounds_dynamic_range_t right) noexcept { return right != left; } @@ -276,8 +279,12 @@ constexpr static_bounds_dynamic_range_t dynamic_range{}; const std::ptrdiff_t dynamic_range = -1; #endif -struct generalized_mapping_tag {}; -struct contiguous_mapping_tag : generalized_mapping_tag {}; +struct generalized_mapping_tag +{ +}; +struct contiguous_mapping_tag : generalized_mapping_tag +{ +}; namespace details { @@ -289,8 +296,9 @@ namespace details }; template - struct BoundsRanges { - using size_type = std::ptrdiff_t; + 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; @@ -299,54 +307,53 @@ namespace details // TODO : following signature is for work around VS bug template BoundsRanges(const OtherRange&, bool /* firstLevel */) - {} - - BoundsRanges (const BoundsRanges&) = default; - BoundsRanges& operator=(const BoundsRanges&) = default; - BoundsRanges(const std::ptrdiff_t* const) { } - BoundsRanges() = default; + { + } + BoundsRanges(const BoundsRanges&) = default; + BoundsRanges& operator=(const BoundsRanges&) = default; + BoundsRanges(const std::ptrdiff_t* const) {} + BoundsRanges() = default; template void serialize(T&) const - {} + { + } template size_type linearize(const T&) const - { + { return 0; } template bool contains(const T&) const { - return 0; + return false; } - size_type totalSize() const noexcept - { - return TotalSize; - } + size_type elementNum(size_t) const noexcept { return 0; } - bool operator==(const BoundsRanges&) const noexcept - { - return true; - } + size_type totalSize() const noexcept { return TotalSize; } + + bool operator==(const BoundsRanges&) const noexcept { return true; } }; template - struct BoundsRanges : BoundsRanges{ - using Base = BoundsRanges ; - using size_type = std::ptrdiff_t; + struct BoundsRanges : BoundsRanges + { + using Base = BoundsRanges; + 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()) + BoundsRanges(const BoundsRanges&) = default; + + BoundsRanges(const std::ptrdiff_t* const arr) + : Base(arr + 1), m_bound(*arr * this->Base::totalSize()) { Expects(0 <= *arr); } @@ -354,9 +361,12 @@ namespace details BoundsRanges() : m_bound(0) {} template - BoundsRanges(const BoundsRanges& other, bool /* firstLevel */ = true) : - Base(static_cast&>(other), false), m_bound(other.totalSize()) - {} + BoundsRanges(const BoundsRanges& other, + bool /* firstLevel */ = true) + : Base(static_cast&>(other), false) + , m_bound(other.totalSize()) + { + } template void serialize(T& arr) const @@ -367,101 +377,24 @@ namespace details template 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(arr); } - - template - size_type contains(const T & arr) const - { - const ptrdiff_t last = this->Base::template contains(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(*this) == static_cast(rhs); - } - }; - - template - struct BoundsRanges : BoundsRanges - { - using Base = BoundsRanges ; - 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 - BoundsRanges(const BoundsRanges&other, bool firstLevel = true) : Base(static_cast&>(other), false) - { - Expects((firstLevel && totalSize() <= other.totalSize()) || totalSize() == other.totalSize()); - (void)firstLevel; - } - - template - void serialize(T& arr) const - { - arr[Dim] = elementNum(); - this->Base::template serialize(arr); - } - - template - 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(arr); - } template size_type contains(const T& arr) const { - if (arr[Dim] >= CurrentRange) - return -1; - const size_type last = this->Base::template contains(arr); - if (last == -1) - return -1; - return this->Base::totalSize() * arr[Dim] + last; + const ptrdiff_t last = this->Base::template contains(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 CurrentRange * this->Base::totalSize(); - } + size_type totalSize() const noexcept { return m_bound; } - size_type elementNum() const noexcept - { - return CurrentRange; - } + size_type elementNum() const noexcept { return totalSize() / this->Base::totalSize(); } size_type elementNum(size_t dim) const noexcept { @@ -471,72 +404,126 @@ namespace details return elementNum(); } - bool operator== (const BoundsRanges& rhs) const noexcept + bool operator==(const BoundsRanges& rhs) const noexcept { - return static_cast(*this) == static_cast(rhs); + return m_bound == rhs.m_bound && + static_cast(*this) == static_cast(rhs); } }; - template - struct BoundsRangeConvertible2; + template + struct BoundsRanges : BoundsRanges + { + using Base = BoundsRanges; + 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; - template > - auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type) -> Ret; + BoundsRanges(const BoundsRanges&) = default; - template - auto helpBoundsRangeConvertible(SourceType, TargetType, ...) -> std::false_type; - - template - struct BoundsRangeConvertible2 : decltype(helpBoundsRangeConvertible(SourceType(), TargetType(), - std::integral_constant())) - {}; + BoundsRanges(const std::ptrdiff_t* const arr) : Base(arr) {} + BoundsRanges() = default; + + template + BoundsRanges(const BoundsRanges& other, + bool firstLevel = true) + : Base(static_cast&>(other), false) + { + (void) firstLevel; + } + + template + void serialize(T& arr) const + { + arr[Dim] = elementNum(); + this->Base::template serialize(arr); + } + + template + 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(arr); + } + + template + size_type contains(const T& arr) const + { + if (arr[Dim] >= CurrentRange) return -1; + const size_type last = this->Base::template contains(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(*this) == static_cast(rhs); + } + }; template - struct BoundsRangeConvertible2 : std::true_type {}; - - template - struct BoundsRangeConvertible : decltype(helpBoundsRangeConvertible(SourceType(), TargetType(), - std::integral_constant::value || TargetType::CurrentRange == dynamic_range || SourceType::CurrentRange == dynamic_range)>())) - {}; - template - struct BoundsRangeConvertible : std::true_type {}; + struct BoundsRangeConvertible + : public std::integral_constant= TargetType::TotalSize || + TargetType::TotalSize == dynamic_range || + SourceType::TotalSize == dynamic_range || + TargetType::TotalSize == 0)> + { + }; template struct TypeListIndexer { - const TypeChain & obj; - TypeListIndexer(const TypeChain & obj) :obj(obj){} - template - const TypeChain & getObj(std::true_type) - { - return obj; - } - template - auto getObj(std::false_type) -> decltype(TypeListIndexer(static_cast(obj)).template get()) - { - return TypeListIndexer(static_cast(obj)).template get(); - } + const TypeChain& obj_; + TypeListIndexer(const TypeChain& obj) : obj_(obj) {} + template - auto get() -> decltype(getObj(std::integral_constant())) + const TypeChain& getObj(std::true_type) + { + return obj_; + } + + template + auto getObj(std::false_type) + -> decltype(TypeListIndexer(static_cast(obj_)).template get()) + { + return TypeListIndexer(static_cast(obj_)).template get(); + } + + template + auto get() -> decltype(getObj(std::integral_constant())) { return getObj(std::integral_constant()); } }; template - TypeListIndexer createTypeListIndexer(const TypeChain &obj) + TypeListIndexer createTypeListIndexer(const TypeChain& obj) { return TypeListIndexer(obj); } - template 1), typename Ret = std::enable_if_t>> + template 1), + typename Ret = std::enable_if_t>> constexpr Ret shift_left(const index& other) noexcept { Ret ret{}; - for (size_t i = 0; i < Rank - 1; ++i) - { + for (size_t i = 0; i < Rank - 1; ++i) { ret[i] = other[i + 1]; } return ret; @@ -550,19 +537,17 @@ template class static_bounds { public: - static_bounds(const details::BoundsRanges&) { - } + static_bounds(const details::BoundsRanges&) {} }; template class static_bounds { - using MyRanges = details::BoundsRanges; + using MyRanges = details::BoundsRanges; MyRanges m_ranges; - constexpr static_bounds(const MyRanges& range) : m_ranges(range) - {} - + constexpr static_bounds(const MyRanges& range) : m_ranges(range) {} + template friend class static_bounds; @@ -581,94 +566,144 @@ public: using mapping_type = contiguous_mapping_tag; constexpr static_bounds(const static_bounds&) = default; - - template , details::BoundsRanges >::value>> + + template + struct BoundsRangeConvertible2; + + template > + static auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type) -> Ret; + + template + static auto helpBoundsRangeConvertible(SourceType, TargetType, ...) -> std::false_type; + + template + struct BoundsRangeConvertible2 + : decltype(helpBoundsRangeConvertible( + SourceType(), TargetType(), + std::integral_constant())) + { + }; + + template + struct BoundsRangeConvertible2 : std::true_type + { + }; + + template + struct BoundsRangeConvertible + : decltype(helpBoundsRangeConvertible( + SourceType(), TargetType(), + std::integral_constant::value || + TargetType::CurrentRange == dynamic_range || + SourceType::CurrentRange == dynamic_range)>())) + { + }; + + template + struct BoundsRangeConvertible : std::true_type + { + }; + + template , + details::BoundsRanges>::value>> constexpr static_bounds(const static_bounds& other) : m_ranges(other.m_ranges) - {} - - constexpr static_bounds(std::initializer_list il) : m_ranges((const std::ptrdiff_t*)il.begin()) + { + Expects((MyRanges::DynamicNum == 0 && details::BoundsRanges::DynamicNum == 0) || + MyRanges::DynamicNum > 0 || other.m_ranges.totalSize() >= m_ranges.totalSize()); + } + + constexpr static_bounds(std::initializer_list il) + : m_ranges(static_cast(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()); + 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); + 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); + new (&m_ranges) MyRanges(otherBounds.m_ranges); return *this; } constexpr sliced_type slice() const noexcept { - return sliced_type{static_cast &>(m_ranges)}; + return sliced_type{static_cast&>(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 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 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 constexpr size_type extent() const noexcept { - static_assert(Dim < rank, "dimension should be less than rank (dimension count starts from 0)"); + static_assert(Dim < rank, + "dimension should be less than rank (dimension count starts from 0)"); return details::createTypeListIndexer(m_ranges).template get().elementNum(); } - + + template + constexpr size_type extent(IntType dim) const noexcept + { + static_assert(std::is_integral::value, + "Dimension parameter must be supplied as an integral type."); + auto real_dim = narrow_cast(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 }; + return {extents}; } - + template - constexpr bool operator == (const static_bounds& rhs) const noexcept + constexpr bool operator==(const static_bounds& rhs) const noexcept { return this->size() == rhs.size(); } - + template - constexpr bool operator != (const static_bounds& rhs) const noexcept + constexpr bool operator!=(const static_bounds& rhs) const noexcept { return !(*this == rhs); } - - constexpr const_iterator begin() const noexcept - { - return const_iterator(*this, index_type{}); - } - + + 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()); @@ -676,19 +711,19 @@ public: }; template -class strided_bounds +class strided_bounds { template friend class strided_bounds; public: static const size_t rank = Rank; - using value_type = std::ptrdiff_t; - using reference = std::add_lvalue_reference_t; + using value_type = std::ptrdiff_t; + using reference = std::add_lvalue_reference_t; using const_reference = std::add_const_t; - using size_type = value_type; + using size_type = value_type; using difference_type = value_type; - using index_type = index; + using index_type = index; using const_index_type = std::add_const_t; using iterator = bounds_iterator; using const_iterator = bounds_iterator; @@ -697,49 +732,45 @@ public: using sliced_type = std::conditional_t, void>; using mapping_type = generalized_mapping_tag; - constexpr strided_bounds(const strided_bounds &) noexcept = default; + constexpr strided_bounds(const strided_bounds&) noexcept = default; - constexpr strided_bounds & operator=(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) + 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 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) - { + 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) - { + 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; + for (size_t i = 0; i < rank; ++i) { + if (idx[i] < 0 || idx[i] >= m_extents[i]) return false; } return true; } @@ -747,45 +778,33 @@ public: constexpr size_type linearize(const index_type& idx) const noexcept { size_type ret = 0; - for (size_t i = 0; i < rank; i++) - { + 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]; - } - + + constexpr size_type stride() const noexcept { return m_strides[0]; } + template 1), typename Ret = std::enable_if_t> constexpr sliced_type slice() const { - return{ details::shift_left(m_extents), details::shift_left(m_strides) }; + return {details::shift_left(m_extents), details::shift_left(m_strides)}; } - + template constexpr size_type extent() const noexcept { - static_assert(Dim < Rank, "dimension should be less than rank (dimension count starts from 0)"); + 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() }; - } + + 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; @@ -793,17 +812,23 @@ private: }; template -struct is_bounds : std::integral_constant {}; +struct is_bounds : std::integral_constant +{ +}; template -struct is_bounds> : std::integral_constant {}; +struct is_bounds> : std::integral_constant +{ +}; template -struct is_bounds> : std::integral_constant {}; +struct is_bounds> : std::integral_constant +{ +}; template -class bounds_iterator: public std::iterator +class bounds_iterator : public std::iterator { private: - using Base = std::iterator ; + using Base = std::iterator; public: static const size_t rank = IndexType::rank; @@ -815,27 +840,20 @@ public: using index_size_type = typename IndexType::value_type; template explicit bounds_iterator(const Bounds& bnd, value_type curr) noexcept - : boundary(bnd.index_bounds()), curr(std::move(curr)) + : boundary(bnd.index_bounds()), + curr(std::move(curr)) { static_assert(is_bounds::value, "Bounds type must be provided"); } - constexpr reference operator*() const noexcept - { - return curr; - } + constexpr reference operator*() const noexcept { return curr; } - constexpr pointer 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) - { + for (size_t i = rank; i-- > 0;) { + if (curr[i] < boundary[i] - 1) { curr[i]++; return *this; } @@ -855,19 +873,15 @@ public: constexpr bounds_iterator& operator--() noexcept { - if (!less(curr, boundary)) - { + if (!less(curr, boundary)) { // if at the past-the-end, set to last element - for (size_t i = 0; i < rank; ++i) - { + 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) - { + for (size_t i = rank; i-- > 0;) { + if (curr[i] >= 1) { curr[i]--; return *this; } @@ -875,7 +889,7 @@ public: } // If we're here the preconditions were violated // "pre: there exists s such that r == ++s" - Expects(false); + Expects(false); return *this; } @@ -888,7 +902,7 @@ public: constexpr bounds_iterator operator+(difference_type n) const noexcept { - bounds_iterator ret{ *this }; + bounds_iterator ret{*this}; return ret += n; } @@ -897,83 +911,62 @@ public: auto linear_idx = linearize(curr) + n; std::remove_const_t stride = 0; stride[rank - 1] = 1; - for (size_t i = rank - 1; i-- > 0;) - { + for (size_t i = rank - 1; i-- > 0;) { stride[i] = stride[i + 1] * boundary[i + 1]; } - for (size_t i = 0; i < rank; ++i) - { + 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 + // 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 }; + bounds_iterator ret{*this}; return ret -= n; } - constexpr bounds_iterator& operator-=(difference_type n) noexcept - { - return *this += -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 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 !(*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; - } + 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; + for (size_t i = 0; i < rank; ++i) { + if (one[i] < other[i]) return true; } return false; } @@ -984,19 +977,16 @@ private: // Check if past-the-end index_size_type multiplier = 1; index_size_type res = 0; - if (!less(idx, boundary)) - { + if (!less(idx, boundary)) { res = 1; - for (size_t i = rank; i-- > 0;) - { + for (size_t i = rank; i-- > 0;) { res += (idx[i] - 1) * multiplier; multiplier *= boundary[i]; } } else { - for (size_t i = rank; i-- > 0;) - { + for (size_t i = rank; i-- > 0;) { res += idx[i] * multiplier; multiplier *= boundary[i]; } @@ -1009,54 +999,63 @@ private: }; template -bounds_iterator operator+(typename bounds_iterator::difference_type n, const bounds_iterator& rhs) noexcept +bounds_iterator operator+(typename bounds_iterator::difference_type n, + const bounds_iterator& rhs) noexcept { return rhs + n; } -// -// begin definitions of basic_span -// namespace details { template - constexpr std::enable_if_t::value, typename Bounds::index_type> make_stride(const Bounds& bnd) noexcept + constexpr std::enable_if_t< + std::is_same::value, + typename Bounds::index_type> + make_stride(const Bounds& bnd) noexcept { return bnd.strides(); } // Make a stride vector from bounds, assuming contiguous memory. template - constexpr std::enable_if_t::value, typename Bounds::index_type> make_stride(const Bounds& bnd) noexcept + constexpr std::enable_if_t< + std::is_same::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) - { + 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 {stride}; } template - void verifyBoundsReshape(const BoundsSrc &src, const BoundsDest &dest) + void verifyBoundsReshape(const BoundsSrc& src, const BoundsDest& dest) { - static_assert(is_bounds::value && is_bounds::value, "The src type and dest type must be bounds"); - static_assert(std::is_same::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"); + static_assert(is_bounds::value && is_bounds::value, + "The src type and dest type must be bounds"); + static_assert(std::is_same::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 class contiguous_span_iterator; template class general_span_iterator; -enum class byte : std::uint8_t {}; +enum class byte : std::uint8_t +{ +}; template struct dim @@ -1071,7 +1070,8 @@ struct dim dim(std::ptrdiff_t size) : dvalue(size) {} }; -template +template class span; template @@ -1087,14 +1087,15 @@ namespace details }; template - struct SpanTypeTraits::type> + struct SpanTypeTraits::type> { using value_type = typename Traits::span_traits::value_type; using size_type = typename Traits::span_traits::size_type; }; template - struct SpanArrayTraits { + struct SpanArrayTraits + { using type = span; using value_type = T; using bounds_type = static_bounds; @@ -1102,46 +1103,53 @@ namespace details using reference = T&; }; template - struct SpanArrayTraits : SpanArrayTraits {}; + struct SpanArrayTraits : SpanArrayTraits + { + }; template BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::true_type) // dynamic size { - Expects(totalSize <= PTRDIFF_MAX); + Expects(totalSize >= 0 && totalSize <= PTRDIFF_MAX); return BoundsType{totalSize}; } template BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::false_type) // static size { - Expects(BoundsType::static_size == totalSize); + Expects(BoundsType::static_size <= totalSize); return {}; } template BoundsType newBoundsHelper(std::ptrdiff_t totalSize) { static_assert(BoundsType::dynamic_rank <= 1, "dynamic rank must less or equal to 1"); - return newBoundsHelperImpl(totalSize, std::integral_constant()); + return newBoundsHelperImpl( + totalSize, std::integral_constant()); } - - struct Sep{}; - + + struct Sep + { + }; + template T static_as_span_helper(Sep, Args... args) { - return T{static_cast(args)...}; + return T{narrow_cast(args)...}; } template - std::enable_if_t>::value && !std::is_same::value, T> static_as_span_helper(Arg, Args... args) + std::enable_if_t< + !std::is_same>::value && !std::is_same::value, T> + static_as_span_helper(Arg, Args... args) { return static_as_span_helper(args...); } template - T static_as_span_helper(dim val, Args ... args) + T static_as_span_helper(dim val, Args... args) { return static_as_span_helper(args..., val.dvalue); } - template + template struct static_as_span_static_bounds_helper { using type = static_bounds<(Dimensions::value)...>; @@ -1149,32 +1157,36 @@ namespace details template struct is_span_oracle : std::false_type - {}; + { + }; template struct is_span_oracle> : std::true_type - {}; - + { + }; + template struct is_span_oracle> : std::true_type - {}; - + { + }; + template struct is_span : is_span_oracle> - {}; - + { + }; } - template class span { - template + // TODO do we still need this? + template friend class span; public: using bounds_type = static_bounds; - static const size_t rank = bounds_type::rank; + 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; @@ -1186,405 +1198,549 @@ public: using const_iterator = contiguous_span_iterator; using reverse_iterator = std::reverse_iterator; using const_reverse_iterator = std::reverse_iterator; - using sliced_type = std::conditional_t>; + using sliced_type = + std::conditional_t>; private: - pointer m_pdata; - bounds_type m_bounds; + pointer data_; + bounds_type bounds_; friend iterator; friend const_iterator; public: - - constexpr span(pointer data, bounds_type bounds) noexcept - : m_pdata(data), m_bounds(std::move(bounds)) + // default constructor - same as constructing from nullptr_t + constexpr span() noexcept : span(nullptr, bounds_type{}) { - Expects((m_bounds.size() > 0 && data != nullptr) || m_bounds.size() == 0); + static_assert(bounds_type::dynamic_rank != 0 || + (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0), + "Default construction of span only possible " + "for dynamic or fixed, zero-length spans."); } - constexpr span(pointer ptr, size_type size) noexcept - : span(ptr, bounds_type{ size }) - {} - - constexpr span(std::nullptr_t) noexcept - : span(nullptr, bounds_type{}) - {} - - constexpr span(std::nullptr_t, size_type size) noexcept - : span(nullptr, bounds_type{}) + // 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 only possible " + "for dynamic or fixed, zero-length spans."); + } + + // construct from nullptr with size of 0 (helps with template function calls) + template ::value>> + constexpr span(std::nullptr_t, IntType size) 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 only possible " + "for dynamic or fixed, zero-length spans."); Expects(size == 0); } - // default - template > - constexpr span() noexcept - : span(nullptr, bounds_type()) - {} - - // from n-dimensions dynamic array (e.g. new int[m][4]) (precedence will be lower than the 1-dimension pointer) - template , - typename Dummy = std::enable_if_t>::value> - /*typename Dummy = std::enable_if_t::value>*/ - > - constexpr span(T* const& data, size_type size) : span(reinterpret_cast(data), typename Helper::bounds_type{size}) - {} - - // from n-dimensions static array - template , - typename = std::enable_if_t::value> - > - constexpr span (T (&arr)[N]) : span(reinterpret_cast(arr), typename Helper::bounds_type()) - {} - - // from n-dimensions static array with size - template , - typename = std::enable_if_t::value> - > - constexpr span(T(&arr)[N], size_type size) : span(arr, typename Helper::bounds_type{size}) + // construct from a single element + constexpr span(reference data) noexcept : span(&data, bounds_type{1}) { - Expects(size <= 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."); } - // from std array - template , bounds_type>::value> - > - constexpr span (std::array, N> & arr) : span(arr.data(), static_bounds()) - {} + // prevent constructing from temporaries for single-elements + constexpr span(value_type&&) = delete; - template , bounds_type>::value - && std::is_const::value> - > - constexpr span (const std::array, N> & arr) : span(arr.data(), static_bounds()) - {} - - // from begin, end pointers. We don't provide iterator pair since no way to guarantee the contiguity + // 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)) + { + Expects((bounds_.size() > 0 && data != nullptr) || bounds_.size() == 0); + } + + // construct from begin,end pointer pair template ::value - && details::LessThan::value> - > // remove literal 0 case - constexpr span (pointer begin, Ptr end) : span(begin, details::newBoundsHelper(static_cast(end) - begin)) - {} + typename = std::enable_if_t::value && + details::LessThan::value>> + constexpr span(pointer begin, Ptr end) + : span(begin, details::newBoundsHelper(static_cast(end) - begin)) + { + Expects(begin != nullptr && end != nullptr && begin <= static_cast(end)); + } - // from containers. It must has .size() and .data() two function signatures + // construct from n-dimensions static array + template > + constexpr span(T (&arr)[N]) + : span(reinterpret_cast(arr), bounds_type{typename Helper::bounds_type{}}) + { + static_assert( + std::is_convertible::value, + "Cannot convert from source type to target span type."); + static_assert(std::is_convertible::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 > + constexpr span(T* const& data, size_type size) + : span(reinterpret_cast(data), typename Helper::bounds_type{size}) + { + static_assert( + std::is_convertible::value, + "Cannot convert from source type to target span type."); + } + + // construct from std::array + template + constexpr span(std::array& arr) : span(arr.data(), bounds_type{static_bounds{}}) + { + static_assert( + std::is_convertible(*) []>::value, + "Cannot convert from source type to target span type."); + static_assert(std::is_convertible, bounds_type>::value, + "You cannot construct a span from a std::array of smaller size."); + } + + // construct from const std::array + template + constexpr span(const std::array, N>& arr) + : span(arr.data(), static_bounds()) + { + static_assert(std::is_convertible>::value, + "Cannot convert from source type to target span type."); + static_assert(std::is_convertible, bounds_type>::value, + "You cannot construct a span from a std::array of smaller size."); + } + + // prevent constructing from temporary std::array + template + constexpr span(std::array&& 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 ::value - && std::is_convertible::value - && std::is_same().size(), *std::declval().data())>, DataType>::value> - > - constexpr span (Cont& cont) : span(static_cast(cont.data()), details::newBoundsHelper(static_cast(cont.size()))) - {} + typename = std::enable_if_t< + !details::is_span::value && + std::is_convertible::value && + std::is_same().size(), + *std::declval().data())>, + DataType>::value>> + constexpr span(Cont& cont) + : span(static_cast(cont.data()), + details::newBoundsHelper(narrow_cast(cont.size()))) + { + } - constexpr span(const span &) = default; + // prevent constructing from temporary containers + template ::value && + std::is_convertible::value && + std::is_same().size(), + *std::declval().data())>, + DataType>::value>> + explicit constexpr span(Cont&& cont) = delete; - // convertible + // construct from a convertible span template , - typename Dummy = std::enable_if_t::value && std::is_convertible::value> - > - constexpr span(const span& other) noexcept - : m_pdata(other.m_pdata), m_bounds(other.m_bounds) - {} - - // reshape - // DimCount here is a workaround for a bug in MSVC 2015 - template 0), typename Dummy = std::enable_if_t> - constexpr span as_span(Dimensions2... dims) + typename OtherBounds = static_bounds, + typename = std::enable_if_t::value && + std::is_convertible::value>> + constexpr span(span other) noexcept : data_(other.data_), + bounds_(other.bounds_) { - using BoundsType = typename span::bounds_type; - auto tobounds = details::static_as_span_helper(dims..., details::Sep{}); - details::verifyBoundsReshape(this->bounds(), tobounds); - return {this->data(), tobounds}; } - // to bytes array - template >::value> - auto as_bytes() const noexcept -> span - { - static_assert(Enabled, "The value_type of span must be standarded layout"); - return { reinterpret_cast(this->data()), this->bytes() }; - } +// trivial copy and move +#ifndef GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT + constexpr span(span&&) = default; +#endif + constexpr span(const span&) = default; - template >::value> - auto as_writeable_bytes() const noexcept -> span - { - static_assert(Enabled, "The value_type of span must be standarded layout"); - return { reinterpret_cast(this->data()), this->bytes() }; - } +// trivial assignment +#ifndef GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT + constexpr span& operator=(span&&) = default; +#endif + constexpr span& operator=(const span&) = default; - // from bytes array - template::value, typename = std::enable_if_t> - constexpr auto as_span() const noexcept -> span(static_cast(bounds_type::static_size) / sizeof(U)) : dynamic_range)> - { - static_assert(std::is_standard_layout::value && (bounds_type::static_size == dynamic_range || bounds_type::static_size % static_cast(sizeof(U)) == 0), - "Target type must be standard layout and its size must match the byte array size"); - Expects((this->bytes() % sizeof(U)) == 0 && (this->bytes() / sizeof(U)) < PTRDIFF_MAX); - return { reinterpret_cast(this->data()), this->bytes() / static_cast(sizeof(U)) }; - } - - template::value, typename = std::enable_if_t> - constexpr auto as_span() const noexcept -> span(static_cast(bounds_type::static_size) / sizeof(U)) : dynamic_range)> - { - static_assert(std::is_standard_layout::value && (bounds_type::static_size == dynamic_range || bounds_type::static_size % static_cast(sizeof(U)) == 0), - "Target type must be standard layout and its size must match the byte array size"); - Expects((this->bytes() % sizeof(U)) == 0); - return { reinterpret_cast(this->data()), this->bytes() / static_cast(sizeof(U)) }; - } - - // section on linear space - template + // first() - extract the first Count elements into a new span + template constexpr span first() const noexcept { - static_assert(bounds_type::static_size == dynamic_range || Count <= bounds_type::static_size, "Index is out of bound"); - Expects(bounds_type::static_size != dynamic_range || Count <= this->size()); - return { this->data(), Count }; + 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 span constexpr span first(size_type count) const noexcept { - Expects(count <= this->size()); - return { this->data(), count }; + Expects(count >= 0 && count <= this->size()); + return {this->data(), count}; } - template + // last() - extract the last Count elements into a new span + template constexpr span last() const noexcept { - static_assert(bounds_type::static_size == dynamic_range || Count <= bounds_type::static_size, "Index is out of bound"); + 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 }; + return {this->data() + this->size() - Count, Count}; } + // last() - extract the last count elements into a new span constexpr span last(size_type count) const noexcept { - Expects(count <= this->size()); - return { this->data() + this->size() - count, count }; + Expects(count >= 0 && count <= this->size()); + return {this->data() + this->size() - count, count}; } - template - constexpr span sub() const noexcept + // subspan() - create a subview of Count elements starting at Offset + template + constexpr span subspan() const noexcept { - static_assert(bounds_type::static_size == dynamic_range || ((Offset == 0 || Offset <= bounds_type::static_size) && Offset + Count <= bounds_type::static_size), "Index is out of bound"); - Expects(bounds_type::static_size != dynamic_range || ((Offset == 0 || Offset <= this->size()) && Offset + Count <= this->size())); - return { this->data() + Offset, Count }; + 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}; } - constexpr span sub(size_type offset, size_type count = dynamic_range) const noexcept + // subspan() - create a subview of count elements starting at offset + // supplying dynamic_range for count will consume all available elements from offset + constexpr span subspan(size_type offset, + size_type count = dynamic_range) const noexcept { - Expects((offset == 0 || offset <= this->size()) && (count == dynamic_range || (offset + count) <= this->size())); - return { this->data() + offset, count == dynamic_range ? this->length() - offset : count }; + Expects((offset >= 0 && offset <= this->size()) && + (count == dynamic_range || (count <= this->size() - offset))); + return {this->data() + offset, count == dynamic_range ? this->length() - offset : count}; } - // size - constexpr size_type length() const noexcept - { - return this->size(); - } - - constexpr size_type used_length() const noexcept - { - return length(); - } - - constexpr size_type bytes() const noexcept - { - return sizeof(value_type) * this->size(); - } - - constexpr size_type used_bytes() const noexcept - { - return bytes(); - } - - // section - constexpr strided_span section(index_type origin, index_type extents) const noexcept + // section - creates a non-contiguous, strided span from a contiguous one + constexpr strided_span 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 {extents, details::make_stride(bounds())} }; - } - - constexpr reference operator[](const index_type& idx) const noexcept - { - return m_pdata[m_bounds.linearize(idx)]; - } - - template 1), typename Ret = std::enable_if_t> - constexpr Ret operator[](size_type idx) const noexcept - { - Expects(idx < m_bounds.size()); // index is out of bounds of the array - const size_type ridx = idx * m_bounds.stride(); - - // index is out of bounds of the underlying data - Expects(ridx < m_bounds.total_size()); - return Ret{ m_pdata + ridx, m_bounds.slice() }; + return {&this->operator[](origin), size, + strided_bounds{extents, details::make_stride(bounds())}}; } - constexpr bounds_type bounds() const noexcept - { - return m_bounds; - } + // 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; } template constexpr size_type extent() const noexcept { - static_assert(Dim < rank, "dimension should be less than rank (dimension count starts from 0)"); - return m_bounds.template extent(); + static_assert(Dim < Rank, + "Dimension should be less than rank (dimension count starts from 0)."); + return bounds_.template extent(); } - constexpr size_type size() const noexcept + template + constexpr size_type extent(IntType dim) const noexcept { - return m_bounds.size(); + return bounds_.extent(dim); } - constexpr pointer data() const noexcept + constexpr bounds_type bounds() const noexcept { return bounds_; } + + constexpr pointer data() const noexcept { return data_; } + + template + constexpr reference operator()(FirstIndex index) { - return m_pdata; + return this->operator[](narrow_cast(index)); } - constexpr explicit operator bool() const noexcept + template + constexpr reference operator()(FirstIndex index, OtherIndices... indices) { - return m_pdata != nullptr; + index_type idx = {narrow_cast(index), + narrow_cast(indices...)}; + return this->operator[](idx); } - constexpr iterator begin() const noexcept + constexpr reference operator[](const index_type& idx) const noexcept { - return iterator{ this, true }; + return data_[bounds_.linearize(idx)]; } - constexpr iterator end() const noexcept + template 1), typename Ret = std::enable_if_t> + constexpr Ret operator[](size_type idx) const noexcept { - return iterator{ this, false }; + 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(this), true }; + return const_iterator{reinterpret_cast(this), true}; } constexpr const_iterator cend() const noexcept { - return const_iterator{ reinterpret_cast(this), false }; + return const_iterator{reinterpret_cast(this), false}; } - constexpr reverse_iterator rbegin() const noexcept - { - return reverse_iterator{ end() }; - } + constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } - constexpr reverse_iterator rend() const noexcept - { - return reverse_iterator{ begin() }; - } + constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } constexpr const_reverse_iterator crbegin() const noexcept { - return const_reverse_iterator{ cend() }; + return const_reverse_iterator{cend()}; } constexpr const_reverse_iterator crend() const noexcept { - return const_reverse_iterator{ cbegin() }; + return const_reverse_iterator{cbegin()}; } - template , std::remove_cv_t>::value>> - constexpr bool operator== (const span & other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator==(const span& other) const noexcept { - return m_bounds.size() == other.m_bounds.size() && - (m_pdata == other.m_pdata || std::equal(this->begin(), this->end(), other.begin())); + return bounds_.size() == other.bounds_.size() && + (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin())); } - template , std::remove_cv_t>::value>> - constexpr bool operator!= (const span & other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator!=(const span& other) const noexcept { return !(*this == other); } - template , std::remove_cv_t>::value>> - constexpr bool operator< (const span & other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator<(const span& other) const noexcept { return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end()); } - template , std::remove_cv_t>::value>> - constexpr bool operator<= (const span & other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator<=(const span& other) const noexcept { return !(other < *this); } - template , std::remove_cv_t>::value>> - constexpr bool operator> (const span & other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator>(const span& other) const noexcept { return (other < *this); } - template , std::remove_cv_t>::value>> - constexpr bool operator>= (const span & other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator>=(const span& other) const noexcept { return !(*this < other); } }; -template -constexpr auto as_span(T* const& ptr, dim... args) -> span, Dimensions...> +// +// 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 0), typename = std::enable_if_t> +constexpr span as_span(SpanType s, + Dimensions2... dims) { - return {reinterpret_cast*>(ptr), details::static_as_span_helper>(args..., details::Sep{})}; + static_assert(details::is_span::value, + "Variadic as_span() is for reshaping existing spans."); + using BoundsType = + typename span::bounds_type; + auto tobounds = details::static_as_span_helper(dims..., details::Sep{}); + details::verifyBoundsReshape(s.bounds(), tobounds); + return {s.data(), tobounds}; +} + +// convert a span to a span +template +span as_bytes(span s) noexcept +{ + static_assert(std::is_trivial>::value, + "The value_type of span must be a trivial type."); + return {reinterpret_cast(s.data()), s.size_bytes()}; +} + +// convert a span to a span (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 +span as_writeable_bytes(span s) noexcept +{ + static_assert(std::is_trivial>::value, + "The value_type of span must be a trivial type."); + return {reinterpret_cast(s.data()), s.size_bytes()}; +} + +// convert a span to a 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 +constexpr auto as_span(span s) noexcept + -> span( + span::bounds_type::static_size != dynamic_range + ? (static_cast( + span::bounds_type::static_size) / + sizeof(U)) + : dynamic_range)> +{ + using ConstByteSpan = span; + static_assert( + std::is_trivial>::value && + (ConstByteSpan::bounds_type::static_size == dynamic_range || + ConstByteSpan::bounds_type::static_size % narrow_cast(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(s.data()), + s.size_bytes() / narrow_cast(sizeof(U))}; +} + +// convert a span to a 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 +constexpr auto as_span(span s) noexcept -> span< + U, narrow_cast( + span::bounds_type::static_size != dynamic_range + ? static_cast(span::bounds_type::static_size) / + sizeof(U) + : dynamic_range)> +{ + using ByteSpan = span; + static_assert( + std::is_trivial>::value && + (ByteSpan::bounds_type::static_size == dynamic_range || + ByteSpan::bounds_type::static_size % static_cast(sizeof(U)) == 0), + "Target type must be a trivial type and its size must match the byte array size"); + + Expects((s.bytes() % sizeof(U)) == 0); + return {reinterpret_cast(s.data()), + s.size_bytes() / narrow_cast(sizeof(U))}; +} + +template +constexpr auto as_span(T* const& ptr, dim... args) + -> span, Dimensions...> +{ + return {reinterpret_cast*>(ptr), + details::static_as_span_helper>(args..., details::Sep{})}; } template -constexpr auto as_span (T* arr, std::ptrdiff_t len) -> typename details::SpanArrayTraits::type +constexpr auto as_span(T* arr, std::ptrdiff_t len) -> + typename details::SpanArrayTraits::type { return {reinterpret_cast*>(arr), len}; } template -constexpr auto as_span (T (&arr)[N]) -> typename details::SpanArrayTraits::type +constexpr auto as_span(T (&arr)[N]) -> typename details::SpanArrayTraits::type { return {arr}; } template -constexpr span as_span(const std::array &arr) +constexpr span as_span(const std::array& arr) { return {arr}; } template -constexpr span as_span(const std::array &&) = delete; +constexpr span as_span(const std::array&&) = delete; template -constexpr span as_span(std::array &arr) +constexpr span as_span(std::array& arr) { return {arr}; } template -constexpr span as_span(T *begin, T *end) +constexpr span as_span(T* begin, T* end) { return {begin, end}; } template -constexpr auto as_span(Cont &arr) -> std::enable_if_t>::value, +constexpr auto as_span(Cont& arr) -> std::enable_if_t< + !details::is_span>::value, span, dynamic_range>> { Expects(arr.size() < PTRDIFF_MAX); - return {arr.data(), static_cast(arr.size())}; + return {arr.data(), narrow_cast(arr.size())}; } template -constexpr auto as_span(Cont &&arr) -> std::enable_if_t>::value, +constexpr auto as_span(Cont&& arr) -> std::enable_if_t< + !details::is_span>::value, span, dynamic_range>> = delete; // from basic_string which doesn't have nonconst .data() member like other contiguous containers template -constexpr auto as_span(std::basic_string &str) -> span +constexpr auto as_span(std::basic_string& str) + -> span { Expects(str.size() < PTRDIFF_MAX); - return {&str[0], static_cast(str.size())}; + return {&str[0], narrow_cast(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 class strided_span { @@ -1601,11 +1757,12 @@ public: using const_iterator = general_span_iterator; using reverse_iterator = std::reverse_iterator; using const_reverse_iterator = std::reverse_iterator; - using sliced_type = std::conditional_t>; + using sliced_type = + std::conditional_t>; private: - pointer m_pdata; - bounds_type m_bounds; + pointer data_; + bounds_type bounds_; friend iterator; friend const_iterator; @@ -1615,169 +1772,163 @@ private: public: // from raw data constexpr strided_span(pointer ptr, size_type size, bounds_type bounds) - : m_pdata(ptr), m_bounds(std::move(bounds)) + : data_(ptr), bounds_(std::move(bounds)) { - Expects((m_bounds.size() > 0 && ptr != nullptr) || m_bounds.size() == 0); + Expects((bounds_.size() > 0 && ptr != nullptr) || bounds_.size() == 0); // Bounds cross data boundaries Expects(this->bounds().total_size() <= size); - (void)size; + (void) size; } // from static array of size N - template - constexpr strided_span(value_type(&values)[N], bounds_type bounds) : strided_span(values, N, std::move(bounds)) - {} + template + constexpr strided_span(value_type (&values)[N], bounds_type bounds) + : strided_span(values, N, std::move(bounds)) + { + } // from array view template ::value, - typename Dummy = std::enable_if_t - > - constexpr strided_span(span av, bounds_type bounds) : strided_span(av.data(), av.bounds().total_size(), std::move(bounds)) - {} - + bool Enabled1 = (sizeof...(Dimensions) == Rank), + bool Enabled2 = std::is_convertible::value, + typename Dummy = std::enable_if_t> + constexpr strided_span(span av, bounds_type bounds) + : strided_span(av.data(), av.bounds().total_size(), std::move(bounds)) + { + } + // convertible - template ::value> - > + template ::value>> constexpr strided_span(const strided_span& other) - : m_pdata(other.m_pdata), m_bounds(other.m_bounds) - {} + : data_(other.data_), bounds_(other.bounds_) + { + } // convert from bytes template - constexpr strided_span::value, OtherValueType>::type, Rank> as_strided_span() const + constexpr strided_span< + typename std::enable_if::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 = static_cast(sizeof(OtherValueType) / sizeof(value_type)); + 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(sizeof(OtherValueType) / sizeof(value_type)); size_type size = this->bounds().total_size() / d; - return{ (OtherValueType*)this->data(), size, bounds_type{ resize_extent(this->bounds().index_bounds(), d), resize_stride(this->bounds().strides(), d)} }; + return {(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())}}; + return {&this->operator[](origin), size, + bounds_type{extents, details::make_stride(bounds())}}; } constexpr reference operator[](const index_type& idx) const { - return m_pdata[m_bounds.linearize(idx)]; + return data_[bounds_.linearize(idx)]; } template 1), typename Ret = std::enable_if_t> constexpr Ret operator[](size_type idx) const { - Expects(idx < m_bounds.size()); // index is out of bounds of the array - const size_type ridx = idx * m_bounds.stride(); + 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 < m_bounds.total_size()); - return{ m_pdata + ridx, m_bounds.slice().total_size(), m_bounds.slice() }; + Expects(ridx < bounds_.total_size()); + return {data_ + ridx, bounds_.slice().total_size(), bounds_.slice()}; } - constexpr bounds_type bounds() const noexcept - { - return m_bounds; - } + constexpr bounds_type bounds() const noexcept { return bounds_; } template constexpr size_type extent() const noexcept { - static_assert(Dim < Rank, "dimension should be less than Rank (dimension count starts from 0)"); - return m_bounds.template extent(); + static_assert(Dim < Rank, + "dimension should be less than Rank (dimension count starts from 0)"); + return bounds_.template extent(); } - constexpr size_type size() const noexcept - { - return m_bounds.size(); - } + constexpr size_type size() const noexcept { return bounds_.size(); } - constexpr pointer data() const noexcept - { - return m_pdata; - } + constexpr pointer data() const noexcept { return data_; } - constexpr explicit operator bool() const noexcept - { - return m_pdata != nullptr; - } + constexpr explicit operator bool() const noexcept { return data_ != nullptr; } - constexpr iterator begin() const - { - return iterator{ this, true }; - } + constexpr iterator begin() const { return iterator{this, true}; } - constexpr iterator end() const - { - return iterator{ this, false }; - } + constexpr iterator end() const { return iterator{this, false}; } constexpr const_iterator cbegin() const { - return const_iterator{ reinterpret_cast(this), true }; + return const_iterator{reinterpret_cast(this), true}; } constexpr const_iterator cend() const { - return const_iterator{ reinterpret_cast(this), false }; + return const_iterator{reinterpret_cast(this), false}; } - constexpr reverse_iterator rbegin() const + 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 , std::remove_cv_t>::value>> + constexpr bool operator==(const strided_span& other) const noexcept { - return reverse_iterator{ end() }; + return bounds_.size() == other.bounds_.size() && + (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin())); } - 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 , std::remove_cv_t>::value>> - constexpr bool operator== (const strided_span& other) const noexcept - { - return m_bounds.size() == other.m_bounds.size() && - (m_pdata == other.m_pdata || std::equal(this->begin(), this->end(), other.begin())); - } - - template , std::remove_cv_t>::value>> - constexpr bool operator!= (const strided_span& other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator!=(const strided_span& other) const noexcept { return !(*this == other); } - template , std::remove_cv_t>::value>> - constexpr bool operator< (const strided_span& other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator<(const strided_span& other) const noexcept { return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end()); } - template , std::remove_cv_t>::value>> - constexpr bool operator<= (const strided_span& other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator<=(const strided_span& other) const noexcept { return !(other < *this); } - template , std::remove_cv_t>::value>> - constexpr bool operator> (const strided_span& other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator>(const strided_span& other) const noexcept { return (other < *this); } - template , std::remove_cv_t>::value>> - constexpr bool operator>= (const strided_span& other) const noexcept + template , std::remove_cv_t>::value>> + constexpr bool operator>=(const strided_span& other) const noexcept { return !(*this < other); } @@ -1795,7 +1946,7 @@ private: } template > - static index_type resize_stride(const index_type& strides, std::ptrdiff_t , void * = 0) + 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); @@ -1812,8 +1963,7 @@ private: // 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) - { + 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)); } @@ -1826,9 +1976,11 @@ private: }; template -class contiguous_span_iterator : public std::iterator +class contiguous_span_iterator + : public std::iterator { using Base = std::iterator; + public: using typename Base::reference; using typename Base::pointer; @@ -1838,33 +1990,36 @@ private: template friend class span; - pointer m_pdata; + pointer data_; const Span* m_validator; void validateThis() const { // iterator is out of range of the array - Expects(m_pdata >= m_validator->m_pdata && - m_pdata < m_validator->m_pdata + m_validator->size()); + Expects(data_ >= m_validator->data_ && data_ < m_validator->data_ + m_validator->size()); } - contiguous_span_iterator (const Span* container, bool isbegin) : - m_pdata(isbegin ? container->m_pdata : container->m_pdata + container->size()), m_validator(container) {} + 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 *m_pdata; + return *data_; } pointer operator->() const noexcept { validateThis(); - return m_pdata; + return data_; } contiguous_span_iterator& operator++() noexcept { - ++m_pdata; + ++data_; return *this; } - contiguous_span_iterator operator++(int)noexcept + contiguous_span_iterator operator++(int) noexcept { auto ret = *this; ++(*this); @@ -1872,10 +2027,10 @@ public: } contiguous_span_iterator& operator--() noexcept { - --m_pdata; + --data_; return *this; } - contiguous_span_iterator operator--(int)noexcept + contiguous_span_iterator operator--(int) noexcept { auto ret = *this; --(*this); @@ -1883,104 +2038,87 @@ public: } contiguous_span_iterator operator+(difference_type n) const noexcept { - contiguous_span_iterator ret{ *this }; + contiguous_span_iterator ret{*this}; return ret += n; } contiguous_span_iterator& operator+=(difference_type n) noexcept { - m_pdata += n; + data_ += n; return *this; } contiguous_span_iterator operator-(difference_type n) const noexcept { - contiguous_span_iterator ret{ *this }; + contiguous_span_iterator ret{*this}; return ret -= n; } - contiguous_span_iterator& operator-=(difference_type n) noexcept - { - return *this += -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 m_pdata - rhs.m_pdata; - } - reference operator[](difference_type n) const noexcept - { - return *(*this + n); + 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 m_pdata == rhs.m_pdata; - } - bool operator!=(const contiguous_span_iterator& rhs) const noexcept - { - return !(*this == rhs); + 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 m_pdata < rhs.m_pdata; - } - 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); + 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(m_pdata, rhs.m_pdata); + std::swap(data_, rhs.data_); std::swap(m_validator, rhs.m_validator); } }; template -contiguous_span_iterator operator+(typename contiguous_span_iterator::difference_type n, const contiguous_span_iterator& rhs) noexcept +contiguous_span_iterator operator+(typename contiguous_span_iterator::difference_type n, + const contiguous_span_iterator& rhs) noexcept { return rhs + n; } template -class general_span_iterator : public std::iterator +class general_span_iterator + : public std::iterator { using Base = std::iterator; + public: using typename Base::reference; using typename Base::pointer; using typename Base::difference_type; using typename Base::value_type; + private: template 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()) - {} + 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]; - } + 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 + general_span_iterator operator++(int) noexcept { auto ret = *this; ++(*this); @@ -1991,7 +2129,7 @@ public: --m_itr; return *this; } - general_span_iterator operator--(int)noexcept + general_span_iterator operator--(int) noexcept { auto ret = *this; --(*this); @@ -1999,7 +2137,7 @@ public: } general_span_iterator operator+(difference_type n) const noexcept { - general_span_iterator ret{ *this }; + general_span_iterator ret{*this}; return ret += n; } general_span_iterator& operator+=(difference_type n) noexcept @@ -2009,13 +2147,10 @@ public: } general_span_iterator operator-(difference_type n) const noexcept { - general_span_iterator ret{ *this }; + general_span_iterator ret{*this}; return ret -= n; } - general_span_iterator& operator-=(difference_type n) noexcept - { - return *this += -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); @@ -2023,34 +2158,23 @@ public: } value_type operator[](difference_type n) const noexcept { - return (*m_container)[m_itr[n]];; + 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 { 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); - } + 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); @@ -2059,14 +2183,14 @@ public: }; template -general_span_iterator operator+(typename general_span_iterator::difference_type n, const general_span_iterator& rhs) noexcept +general_span_iterator operator+(typename general_span_iterator::difference_type n, + const general_span_iterator& rhs) noexcept { return rhs + n; } } // namespace gsl - #ifdef _MSC_VER #undef constexpr @@ -2080,13 +2204,13 @@ general_span_iterator operator+(typename general_span_iterator::diff #pragma pop_macro("noexcept") #endif // GSL_THROW_ON_CONTRACT_VIOLATION -#undef GSL_MSVC_HAS_VARIADIC_CTOR_BUG +#undef GSL_MSVC_HAS_VARIADIC_CTOR_BUG #endif // _MSC_VER <= 1800 #endif // _MSC_VER -#if defined(GSL_THROW_ON_CONTRACT_VIOLATION) +#if defined(GSL_THROW_ON_CONTRACT_VIOLATION) #undef noexcept @@ -2095,7 +2219,6 @@ general_span_iterator operator+(typename general_span_iterator::diff #pragma pop_macro("noexcept") #endif -#endif // GSL_THROW_ON_CONTRACT_VIOLATION - +#endif // GSL_THROW_ON_CONTRACT_VIOLATION #endif // GSL_SPAN_H diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index a524d01..7990ec3 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -45,6 +45,7 @@ function(add_gsl_test name) endfunction() add_gsl_test(span_tests) +add_gsl_test(strided_span_tests) add_gsl_test(string_span_tests) add_gsl_test(at_tests) add_gsl_test(bounds_tests) diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp index e5078af..8737db9 100644 --- a/tests/span_tests.cpp +++ b/tests/span_tests.cpp @@ -1,1827 +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. -// +/////////////////////////////////////////////////////////////////////////////// +// +// 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 +#include #include +#include +#include +#include +#include #include #include -#include -#include using namespace std; using namespace gsl; -namespace +namespace { - struct BaseClass {}; - struct DerivedClass : BaseClass {}; +struct BaseClass +{ +}; +struct DerivedClass : BaseClass +{ +}; } 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(default_constructor) + { + { + span s; + CHECK(s.length() == 0 && s.data() == nullptr); + span cs; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } - static_bounds<4, dynamic_range, 2> bounds{ 3 }; - + { + span s; + CHECK(s.length() == 0 && s.data() == nullptr); + + span cs; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { #ifdef CONFIRM_COMPILATION_ERRORS - span av(nullptr, bounds); - av.extent(); - av.extent<2>(); - av[8][4][3]; + span s; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile #endif - } + } - TEST (span_convertible) - { + { + span s{}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span cs{}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_nullptr_constructor) + { + { + span s = nullptr; + CHECK(s.length() == 0 && s.data() == nullptr); + + span cs = nullptr; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + span s = nullptr; + CHECK(s.length() == 0 && s.data() == nullptr); + + span cs = nullptr; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { #ifdef CONFIRM_COMPILATION_ERRORS - span av1(nullptr, b1); + span s = nullptr; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile +#endif + } + + { + span s{nullptr}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span cs{nullptr}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + span s{nullptr}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span cs{nullptr}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_nullptr_length_constructor) + { + { + span s{nullptr, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span cs{nullptr, 0}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + span s{nullptr, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span cs{nullptr, 0}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s{nullptr, 0}; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile +#endif + } + + { + auto workaround_macro = []() { span s{nullptr, 1}; }; + CHECK_THROW(workaround_macro(), fail_fast); + + auto const_workaround_macro = []() { span cs{nullptr, 1}; }; + CHECK_THROW(const_workaround_macro(), fail_fast); + } + + { + auto workaround_macro = []() { span s{nullptr, 1}; }; + CHECK_THROW(workaround_macro(), fail_fast); + + auto const_workaround_macro = []() { span s{nullptr, 1}; }; + CHECK_THROW(const_workaround_macro(), fail_fast); + } + + { + span s{nullptr, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span cs{nullptr, 0}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_element_constructor) + { + int i = 5; + + { + span s = i; + CHECK(s.length() == 1 && s.data() == &i); + CHECK(s[0] == 5); + + span cs = i; + CHECK(cs.length() == 1 && cs.data() == &i); + CHECK(cs[0] == 5); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + const j = 1; + span s = j; +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s = i; + CHECK(s.length() == 0 && s.data() == &i); +#endif + } + + { + span s = i; + CHECK(s.length() == 1 && s.data() == &i); + CHECK(s[0] == 5); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span 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 s) { (void) s; }; + use_a_span(get_a_temp()); +#endif + } + } + + TEST(from_pointer_length_constructor) + { + int arr[4] = {1, 2, 3, 4}; + + { + span s{&arr[0], 2}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + span s{&arr[0], 2}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + int* p = nullptr; + span s{p, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + } + + { + int* p = nullptr; + auto workaround_macro = [=]() { span s{p, 2}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + } + + TEST(from_pointer_pointer_constructor) + { + int arr[4] = {1, 2, 3, 4}; + + { + span s{&arr[0], &arr[2]}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + span s{&arr[0], &arr[2]}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + span s{&arr[0], &arr[0]}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + { + span s{&arr[0], &arr[0]}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + { + auto workaround_macro = [&]() { span s{&arr[1], &arr[0]}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + { + int* p = nullptr; + auto workaround_macro = [&]() { span s{&arr[0], p}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + { + int* p = nullptr; + auto workaround_macro = [&]() { span s{p, p}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + { + int* p = nullptr; + auto workaround_macro = [&]() { span s{&arr[0], p}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + } + + TEST(from_array_constructor) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + span s{arr}; + CHECK(s.length() == 5 && s.data() == &arr[0]); + } + + { + span s{arr}; + CHECK(s.length() == 5 && s.data() == &arr[0]); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s{arr}; +#endif + } + + { + span s{arr}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + int arr2d[2][3] = {1, 2, 3, 4, 5, 6}; + + { + span s{arr2d}; + CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } + + { + span s{arr2d}; + CHECK(s.length() == 0 && s.data() == &arr2d[0][0]); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s{arr2d}; +#endif + } + + { + span s{arr2d}; + CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s{arr2d}; +#endif + } + + { + span s{arr2d[0]}; + CHECK(s.length() == 1 && s.data() == &arr2d[0]); + } + + { + span 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 s{arr2d}; +#endif + } + + int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; + + { + span s{arr3d}; + CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); + CHECK(s[0] == 1 && s[11] == 12); + } + + { + span s{arr3d}; + CHECK(s.length() == 0 && s.data() == &arr3d[0][0][0]); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s{arr3d}; +#endif + } + + { + span s{arr3d}; + CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s{arr3d}; +#endif + } + + { + span s{arr3d[0]}; + CHECK(s.length() == 1 && s.data() == &arr3d[0]); + } + + { + span 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 s{arr3d}; +#endif + } + } + + TEST(from_dynamic_array_constructor) + { + double(*arr)[3][4] = new double[100][3][4]; + + { + span s(arr, 10); + CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); + CHECK_THROW(s[10][3][4], fail_fast); + } + + { + span s(arr, 10); + CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); + } + + { + span s(arr, 10); + CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); + } + + { + span s(arr, 0); + CHECK(s.length() == 0 && s.data() == &arr[0][0][0]); + } + + delete[] arr; + } + + TEST(from_std_array_constructor) + { + std::array arr = {1, 2, 3, 4}; + + { + span s{arr}; + CHECK(s.size() == narrow_cast(arr.size()) && s.data() == arr.data()); + + span cs{arr}; + CHECK(cs.size() == narrow_cast(arr.size()) && cs.data() == arr.data()); + } + + { + span s{arr}; + CHECK(s.size() == narrow_cast(arr.size()) && s.data() == arr.data()); + + span cs{arr}; + CHECK(cs.size() == narrow_cast(arr.size()) && cs.data() == arr.data()); + } + + { + span s{arr}; + CHECK(s.size() == 2 && s.data() == arr.data()); + + span cs{arr}; + CHECK(cs.size() == 2 && cs.data() == arr.data()); + } + + { + span s{arr}; + CHECK(s.size() == 0 && s.data() == arr.data()); + + span 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 + //{ + // span s{arr}; + // CHECK(s.size() == narrow_cast(arr.size()) && s.data() == arr.data()); + //} + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s{arr}; +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_an_array = []() { return std::array{1, 2, 3, 4}; }; + auto take_a_span = [](span 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 arr = {1, 2, 3, 4}; + + { + span s{arr}; + CHECK(s.size() == narrow_cast(arr.size()) && s.data() == arr.data()); + } + + { + span s{arr}; + CHECK(s.size() == narrow_cast(arr.size()) && s.data() == arr.data()); + } + + { + span s{arr}; + CHECK(s.size() == 2 && s.data() == arr.data()); + } + + { + span 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 + //{ + // span s{arr}; + // CHECK(s.size() == narrow_cast(arr.size()) && s.data() == arr.data()); + //} + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s{arr}; +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_an_array = []() -> const std::array { return {1, 2, 3, 4}; }; + auto take_a_span = [](span s) { (void) s; }; + // try to take a temporary std::array + take_a_span(get_an_array()); +#endif + } + } + + TEST(from_container_constructor) + { + std::vector v = {1, 2, 3}; + const std::vector cv = v; + + { + span s{v}; + CHECK(s.size() == narrow_cast(v.size()) && s.data() == v.data()); + + span cs{v}; + CHECK(cs.size() == narrow_cast(v.size()) && cs.data() == v.data()); + } + + std::string str = "hello"; + const std::string cstr = "hello"; + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s{str}; + CHECK(s.size() == narrow_cast(str.size()) && s.data() == str.data()); +#endif + span cs{str}; + CHECK(cs.size() == narrow_cast(str.size()) && cs.data() == str.data()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span s{cstr}; +#endif + span cs{cstr}; + CHECK(cs.size() == narrow_cast(cstr.size()) && + cs.data() == cstr.data()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_vector = []() -> std::vector { return {}; }; + auto use_span = [](span s) { (void) s; }; + use_span(get_temp_vector()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_string = []() -> std::string { return {}; }; + auto use_span = [](span s) { (void) s; }; + use_span(get_temp_string()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_vector = []() -> const std::vector { return {}; }; + auto use_span = [](span s) { (void) s; }; + use_span(get_temp_vector()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_string = []() -> const std::string { return {}; }; + auto use_span = [](span s) { (void) s; }; + use_span(get_temp_string()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + std::map m; + span s{m}; +#endif + } + } + + TEST(from_convertible_span_constructor) + { +#ifdef CONFIRM_COMPILATION_ERRORS + span av1(nullptr, b1); + + auto f = [&]() { span av1(nullptr); }; + CHECK_THROW(f(), fail_fast); #endif - - auto f = [&]() { span av1(nullptr); }; - CHECK_THROW(f(), fail_fast); - - span av1(nullptr); #ifdef CONFIRM_COMPILATION_ERRORS - static_bounds b12(b11); - b12 = b11; - b11 = b12; - - span av1 = nullptr; - span av2(av1); - span av2(av1); + static_bounds b12(b11); + b12 = b11; + b11 = b12; + + span av1 = nullptr; + span av2(av1); + span av2(av1); #endif - span avd; + span avd; #ifdef CONFIRM_COMPILATION_ERRORS - span avb = avd; + span avb = avd; #endif - span avcd = avd; - (void)avcd; - } + span avcd = avd; + (void) avcd; + } - TEST(boundary_checks) - { - int arr[10][2]; - auto av = as_span(arr); + TEST(copy_move_and_assignment) + { + span s1; + CHECK(s1.empty()); - fill(begin(av), end(av), 0); + int arr[] = {3, 4, 5}; - av[2][0] = 1; - av[1][1] = 3; + span s2 = arr; + CHECK(s2.length() == 3 && s2.data() == &arr[0]); - // out of bounds - CHECK_THROW(av[1][3] = 3, fail_fast); - CHECK_THROW((av[{1, 3}] = 3), fail_fast); + s2 = s1; + CHECK(s2.empty()); - CHECK_THROW(av[10][2], fail_fast); - CHECK_THROW((av[{10,2}]), fail_fast); - } + auto get_temp_span = [&]() -> span { return {&arr[1], 2}; }; + auto use_span = [&](span s) { CHECK(s.length() == 2 && s.data() == &arr[1]); }; + use_span(get_temp_span()); - void overloaded_func(span exp, int expected_value) { - for (auto val : exp) - { - CHECK(val == expected_value); - } - } + s1 = get_temp_span(); + CHECK(s1.length() == 2 && s1.data() == &arr[1]); + } - void overloaded_func(span exp, char expected_value) { - for (auto val : exp) - { - CHECK(val == expected_value); - } - } + template + 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)); - void fixed_func(span exp, int expected_value) { - for (auto val : exp) - { - CHECK(val == expected_value); - } - } + fill(av6.begin(), av6.end(), 1); - TEST(span_parameter_test) - { - auto data = new int[4][3][5]; + auto av7 = as_bytes(av6); - auto av = as_span(data, 4); + auto av8 = as_span(av7); - CHECK(av.size() == 60); + CHECK(av8.size() == av6.size()); + for (auto i = 0; i < av8.size(); i++) { + CHECK(av8[i] == 1); + } + } - 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); + TEST(first) + { + int arr[5] = {1, 2, 3, 4, 5}; - overloaded_func(av.as_span(dim<>(4), dim<>(3), dim<>(5)), 34); + { + span av = arr; + CHECK((av.first<2>().bounds() == static_bounds<2>())); + CHECK(av.first<2>().length() == 2); + CHECK(av.first(2).length() == 2); + } - //fixed_func(av, 34); - delete[] data; - } + { + span av = arr; + CHECK((av.first<0>().bounds() == static_bounds<0>())); + CHECK(av.first<0>().length() == 0); + CHECK(av.first(0).length() == 0); + } + { + span av = arr; + CHECK((av.first<5>().bounds() == static_bounds<5>())); + CHECK(av.first<5>().length() == 5); + CHECK(av.first(5).length() == 5); + } - 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(image_ptr, imgSize).as_span(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(span_factory_test) - { - { - 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 stdarr{ 0 }; - auto av2 = as_span(stdarr); - overloaded_func(av2.as_span(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(av3.as_span(dim<>(1), dim<3>(), dim<5>()), 't'); - } - - { - string str; - span strspan = as_span(str); - (void)strspan; - const string cstr; - span cstrspan = as_span(cstr); - (void)cstrspan; - } - - { - 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 arr = {0.0, 0.0, 0.0}; - auto cv = as_span(arr); - (void)cv; - - vector vec(3); - auto dv = as_span(vec); - (void)dv; - + { + span av = arr; #ifdef CONFIRM_COMPILATION_ERRORS - auto dv2 = as_span(std::move(vec)); + CHECK(av.first<6>().bounds() == static_bounds<6>()); + CHECK(av.first<6>().length() == 6); + CHECK(av.first<-1>().length() == -1); #endif - } - } - - template void fn(const Bounds&) { static_assert(Bounds::static_size == 60, "static bounds is wrong size"); } - TEST (span_reshape_test) - { - int a[3][4][5]; - auto av = as_span(a); - fn(av.bounds()); - auto av2 = av.as_span(dim<60>()); - auto av3 = av2.as_span(dim<3>(), dim<4>(), dim<5>()); - auto av4 = av3.as_span(dim<4>(), dim<>(3), dim<5>()); - auto av5 = av4.as_span(dim<3>(), dim<4>(), dim<5>()); - auto av6 = av5.as_span(dim<12>(), dim<>(5)); - - fill(av6.begin(), av6.end(), 1); - - auto av7 = av6.as_bytes(); - - auto av8 = av7.as_span(); + CHECK_THROW(av.first(6).length(), fail_fast); + } - CHECK(av8.size() == av6.size()); - for (auto i = 0; i < av8.size(); i++) - { - CHECK(av8[i] == 1); - } + { + span 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}; + + { + span av = arr; + CHECK((av.last<2>().bounds() == static_bounds<2>())); + CHECK(av.last<2>().length() == 2); + CHECK(av.last(2).length() == 2); + } + + { + span av = arr; + CHECK((av.last<0>().bounds() == static_bounds<0>())); + CHECK(av.last<0>().length() == 0); + CHECK(av.last(0).length() == 0); + } + + { + span av = arr; + CHECK((av.last<5>().bounds() == static_bounds<5>())); + CHECK(av.last<5>().length() == 5); + CHECK(av.last(5).length() == 5); + } + + { + span av = arr; #ifdef CONFIRM_COMPILATION_ERRORS - struct Foo {char c[11];}; - auto av9 = av7.as_span(); + CHECK((av.last<6>().bounds() == static_bounds<6>())); + CHECK(av.last<6>().length() == 6); #endif - } - - - TEST (span_section_test) - { - int a[30][4][5]; - - auto av = as_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; - } - - TEST(span_section) - { - std::vector data(5 * 10); - std::iota(begin(data), end(data), 0); - const span av = as_span(data).as_span(dim<5>(), dim<10>()); - - strided_span av_section_1 = av.section({ 1, 2 }, { 3, 4 }); - CHECK((av_section_1[{0, 0}] == 12)); - CHECK((av_section_1[{0, 1}] == 13)); - CHECK((av_section_1[{1, 0}] == 22)); - CHECK((av_section_1[{2, 3}] == 35)); - - strided_span av_section_2 = av_section_1.section({ 1, 2 }, { 2,2 }); - CHECK((av_section_2[{0, 0}] == 24)); - CHECK((av_section_2[{0, 1}] == 25)); - CHECK((av_section_2[{1, 0}] == 34)); - } - - TEST(strided_span_constructors) - { - // Check stride constructor - { - int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - const int carr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - - strided_span sav1{ arr, {{9}, {1}} }; // T -> T - CHECK(sav1.bounds().index_bounds() == index<1>{ 9 }); - CHECK(sav1.bounds().stride() == 1); - CHECK(sav1[0] == 1 && sav1[8] == 9); - - - strided_span sav2{ carr, {{ 4 }, { 2 }} }; // const T -> const T - CHECK(sav2.bounds().index_bounds() == index<1>{ 4 }); - CHECK(sav2.bounds().strides() == index<1>{2}); - CHECK(sav2[0] == 1 && sav2[3] == 7); - - strided_span sav3{ arr, {{ 2, 2 },{ 6, 2 }} }; // T -> const T - CHECK((sav3.bounds().index_bounds() == index<2>{ 2, 2 })); - CHECK((sav3.bounds().strides() == index<2>{ 6, 2 })); - CHECK((sav3[{0, 0}] == 1 && sav3[{0, 1}] == 3 && sav3[{1, 0}] == 7)); - } - - // Check span constructor - { - int arr[] = { 1, 2 }; - - // From non-cv-qualified source - { - const span src = arr; - - strided_span sav{ src, {2, 1} }; - CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav.bounds().strides() == index<1>{ 1 }); - CHECK(sav[1] == 2); - -#if _MSC_VER > 1800 - //strided_span sav_c{ {src}, {2, 1} }; - strided_span sav_c{ span{src}, strided_bounds<1>{2, 1} }; -#else - strided_span sav_c{ span{src}, strided_bounds<1>{2, 1} }; -#endif - CHECK(sav_c.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav_c.bounds().strides() == index<1>{ 1 }); - CHECK(sav_c[1] == 2); - -#if _MSC_VER > 1800 - strided_span sav_v{ src, {2, 1} }; -#else - strided_span sav_v{ span{src}, strided_bounds<1>{2, 1} }; -#endif - CHECK(sav_v.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav_v.bounds().strides() == index<1>{ 1 }); - CHECK(sav_v[1] == 2); - -#if _MSC_VER > 1800 - strided_span sav_cv{ src, {2, 1} }; -#else - strided_span sav_cv{ span{src}, strided_bounds<1>{2, 1} }; -#endif - CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); - CHECK(sav_cv[1] == 2); - } - - // From const-qualified source - { - const span src{ arr }; - - strided_span sav_c{ src, {2, 1} }; - CHECK(sav_c.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav_c.bounds().strides() == index<1>{ 1 }); - CHECK(sav_c[1] == 2); - -#if _MSC_VER > 1800 - strided_span sav_cv{ src, {2, 1} }; -#else - strided_span sav_cv{ span{src}, strided_bounds<1>{2, 1} }; -#endif - - CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); - CHECK(sav_cv[1] == 2); - } - - // From volatile-qualified source - { - const span src{ arr }; - - strided_span sav_v{ src, {2, 1} }; - CHECK(sav_v.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav_v.bounds().strides() == index<1>{ 1 }); - CHECK(sav_v[1] == 2); - -#if _MSC_VER > 1800 - strided_span sav_cv{ src, {2, 1} }; -#else - strided_span sav_cv{ span{src}, strided_bounds<1>{2, 1} }; -#endif - CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); - CHECK(sav_cv[1] == 2); - } - - // From cv-qualified source - { - const span src{ arr }; - - strided_span sav_cv{ src, {2, 1} }; - CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); - CHECK(sav_cv[1] == 2); - } - } - - // Check const-casting constructor - { - int arr[2] = { 4, 5 }; - - const span av(arr, 2); - span av2{ av }; - CHECK(av2[1] == 5); - - static_assert(std::is_convertible, span>::value, "ctor is not implicit!"); - - const strided_span src{ arr, {2, 1} }; - strided_span sav{ src }; - CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav.bounds().stride() == 1); - CHECK(sav[1] == 5); - - static_assert(std::is_convertible, strided_span>::value, "ctor is not implicit!"); - } - - // Check copy constructor - { - int arr1[2] = { 3, 4 }; - const strided_span src1{ arr1, {2, 1} }; - strided_span sav1{ src1 }; - - CHECK(sav1.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav1.bounds().stride() == 1); - CHECK(sav1[0] == 3); - - int arr2[6] = { 1, 2, 3, 4, 5, 6 }; - const strided_span src2{ arr2, {{ 3, 2 }, { 2, 1 }} }; - strided_span sav2{ src2 }; - CHECK((sav2.bounds().index_bounds() == index<2>{ 3, 2 })); - CHECK((sav2.bounds().strides() == index<2>{ 2, 1 })); - CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5)); - } - - // Check const-casting assignment operator - { - int arr1[2] = { 1, 2 }; - int arr2[6] = { 3, 4, 5, 6, 7, 8 }; - - const strided_span src{ arr1, {{2}, {1}} }; - strided_span sav{ arr2, {{3}, {2}} }; - strided_span& sav_ref = (sav = src); - CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav.bounds().strides() == index<1>{ 1 }); - CHECK(sav[0] == 1); - CHECK(&sav_ref == &sav); - } - - // Check copy assignment operator - { - int arr1[2] = { 3, 4 }; - int arr1b[1] = { 0 }; - const strided_span src1{ arr1, {2, 1} }; - strided_span sav1{ arr1b, {1, 1} }; - strided_span& sav1_ref = (sav1 = src1); - CHECK(sav1.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav1.bounds().strides() == index<1>{ 1 }); - CHECK(sav1[0] == 3); - CHECK(&sav1_ref == &sav1); - - const int arr2[6] = { 1, 2, 3, 4, 5, 6 }; - const int arr2b[1] = { 0 }; - const strided_span src2{ arr2, {{ 3, 2 },{ 2, 1 }} }; - strided_span sav2{ arr2b, {{ 1, 1 },{ 1, 1 }} }; - strided_span& sav2_ref = (sav2 = src2); - CHECK((sav2.bounds().index_bounds() == index<2>{ 3, 2 })); - CHECK((sav2.bounds().strides() == index<2>{ 2, 1 })); - CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5)); - CHECK(&sav2_ref == &sav2); - } - } - - TEST(strided_span_slice) - { - std::vector data(5 * 10); - std::iota(begin(data), end(data), 0); - const span src = as_span(data).as_span(dim<5>(), dim<10>()); - - const strided_span sav{ src, {{5, 10}, {10, 1}} }; -#ifdef CONFIRM_COMPILATION_ERRORS - const strided_span csav{ {src},{ { 5, 10 },{ 10, 1 } } }; -#endif - const strided_span csav{ span{ src }, { { 5, 10 },{ 10, 1 } } }; - - strided_span sav_sl = sav[2]; - CHECK(sav_sl[0] == 20); - CHECK(sav_sl[9] == 29); - - strided_span csav_sl = sav[3]; - CHECK(csav_sl[0] == 30); - CHECK(csav_sl[9] == 39); - - CHECK(sav[4][0] == 40); - CHECK(sav[4][9] == 49); - } - - TEST(strided_span_column_major) - { - // strided_span may be used to accomodate more peculiar - // use cases, such as column-major multidimensional array - // (aka. "FORTRAN" layout). - - int cm_array[3 * 5] = { - 1, 4, 7, 10, 13, - 2, 5, 8, 11, 14, - 3, 6, 9, 12, 15 - }; - strided_span cm_sav{ cm_array, {{ 5, 3 },{ 1, 5 }} }; - - // Accessing elements - CHECK((cm_sav[{0, 0}] == 1)); - CHECK((cm_sav[{0, 1}] == 2)); - CHECK((cm_sav[{1, 0}] == 4)); - CHECK((cm_sav[{4, 2}] == 15)); - - // Slice - strided_span cm_sl = cm_sav[3]; - - CHECK(cm_sl[0] == 10); - CHECK(cm_sl[1] == 11); - CHECK(cm_sl[2] == 12); - - // Section - strided_span cm_sec = cm_sav.section( { 2, 1 }, { 3, 2 }); - - CHECK((cm_sec.bounds().index_bounds() == index<2>{3, 2})); - CHECK((cm_sec[{0, 0}] == 8)); - CHECK((cm_sec[{0, 1}] == 9)); - CHECK((cm_sec[{1, 0}] == 11)); - CHECK((cm_sec[{2, 1}] == 15)); - } - - TEST(strided_span_bounds) - { - int arr[] = { 0, 1, 2, 3 }; - span av(arr); - - { - // incorrect sections - - CHECK_THROW(av.section(0, 0)[0], fail_fast); - CHECK_THROW(av.section(1, 0)[0], fail_fast); - CHECK_THROW(av.section(1, 1)[1], fail_fast); - - CHECK_THROW(av.section(2, 5), fail_fast); - CHECK_THROW(av.section(5, 2), fail_fast); - CHECK_THROW(av.section(5, 0), fail_fast); - CHECK_THROW(av.section(0, 5), fail_fast); - CHECK_THROW(av.section(5, 5), fail_fast); - } - - { - // zero stride - strided_span sav{ av,{ { 4 },{} } }; - CHECK(sav[0] == 0); - CHECK(sav[3] == 0); - CHECK_THROW(sav[4], fail_fast); - } - - { - // zero extent - strided_span sav{ av,{ {},{ 1 } } }; - CHECK_THROW(sav[0], fail_fast); - } - - { - // zero extent and stride - strided_span sav{ av,{ {},{} } }; - CHECK_THROW(sav[0], fail_fast); - } - - { - // strided array ctor with matching strided bounds - strided_span sav{ arr,{ 4, 1 } }; - CHECK(sav.bounds().index_bounds() == index<1>{ 4 }); - CHECK(sav[3] == 3); - CHECK_THROW(sav[4], fail_fast); - } - - { - // strided array ctor with smaller strided bounds - strided_span sav{ arr,{ 2, 1 } }; - CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav[1] == 1); - CHECK_THROW(sav[2], fail_fast); - } - - { - // strided array ctor with fitting irregular bounds - strided_span sav{ arr,{ 2, 3 } }; - CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); - CHECK(sav[0] == 0); - CHECK(sav[1] == 3); - CHECK_THROW(sav[2], fail_fast); - } - - { - // bounds cross data boundaries - from static arrays - CHECK_THROW((strided_span { arr, { 3, 2 } }), fail_fast); - CHECK_THROW((strided_span { arr, { 3, 3 } }), fail_fast); - CHECK_THROW((strided_span { arr, { 4, 5 } }), fail_fast); - CHECK_THROW((strided_span { arr, { 5, 1 } }), fail_fast); - CHECK_THROW((strided_span { arr, { 5, 5 } }), fail_fast); - } - - { - // bounds cross data boundaries - from array view - CHECK_THROW((strided_span { av, { 3, 2 } }), fail_fast); - CHECK_THROW((strided_span { av, { 3, 3 } }), fail_fast); - CHECK_THROW((strided_span { av, { 4, 5 } }), fail_fast); - CHECK_THROW((strided_span { av, { 5, 1 } }), fail_fast); - CHECK_THROW((strided_span { av, { 5, 5 } }), fail_fast); - } - - { - // bounds cross data boundaries - from dynamic arrays - CHECK_THROW((strided_span { av.data(), 4, { 3, 2 } }), fail_fast); - CHECK_THROW((strided_span { av.data(), 4, { 3, 3 } }), fail_fast); - CHECK_THROW((strided_span { av.data(), 4, { 4, 5 } }), fail_fast); - CHECK_THROW((strided_span { av.data(), 4, { 5, 1 } }), fail_fast); - CHECK_THROW((strided_span { av.data(), 4, { 5, 5 } }), fail_fast); - CHECK_THROW((strided_span { av.data(), 2, { 2, 2 } }), fail_fast); - } - -#ifdef CONFIRM_COMPILATION_ERRORS - { - strided_span sav0{ av.data(), { 3, 2 } }; - strided_span sav1{ arr, { 1 } }; - strided_span sav2{ arr, { 1,1,1 } }; - strided_span sav3{ av, { 1 } }; - strided_span sav4{ av, { 1,1,1 } }; - strided_span sav5{ av.as_span(dim<2>(), dim<2>()), { 1 } }; - strided_span sav6{ av.as_span(dim<2>(), dim<2>()), { 1,1,1 } }; - strided_span sav7{ av.as_span(dim<2>(), dim<2>()), { { 1,1 },{ 1,1 },{ 1,1 } } }; - - index<1> index{ 0, 1 }; - strided_span sav8{ arr,{ 1,{ 1,1 } } }; - strided_span sav9{ arr,{ { 1,1 },{ 1,1 } } }; - strided_span sav10{ av,{ 1,{ 1,1 } } }; - strided_span sav11{ av,{ { 1,1 },{ 1,1 } } }; - strided_span sav12{ av.as_span(dim<2>(), dim<2>()),{ { 1 },{ 1 } } }; - strided_span sav13{ av.as_span(dim<2>(), dim<2>()),{ { 1 },{ 1,1,1 } } }; - strided_span sav14{ av.as_span(dim<2>(), dim<2>()),{ { 1,1,1 },{ 1 } } }; - } -#endif - } - - TEST(strided_span_type_conversion) - { - int arr[] = { 0, 1, 2, 3 }; - span av(arr); - - { - strided_span sav{ av.data(), av.size(), { av.size() / 2, 2 } }; -#ifdef CONFIRM_COMPILATION_ERRORS - strided_span lsav1 = sav.as_strided_span(); -#endif - } - { - strided_span sav{ av, { av.size() / 2, 2 } }; -#ifdef CONFIRM_COMPILATION_ERRORS - strided_span lsav1 = sav.as_strided_span(); -#endif - } - - span bytes = av.as_bytes(); - - // retype strided array with regular strides - from raw data - { - strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } }; - strided_span sav2{ bytes.data(), bytes.size(), bounds }; - strided_span sav3 = sav2.as_strided_span(); - CHECK(sav3[0][0] == 0); - CHECK(sav3[1][0] == 2); - CHECK_THROW(sav3[1][1], fail_fast); - CHECK_THROW(sav3[0][1], fail_fast); - } - - // retype strided array with regular strides - from span - { - strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } }; - span bytes2 = bytes.as_span(dim<2>(), dim<>(bytes.size() / 2)); - strided_span sav2{ bytes2, bounds }; - strided_span sav3 = sav2.as_strided_span(); - CHECK(sav3[0][0] == 0); - CHECK(sav3[1][0] == 2); - CHECK_THROW(sav3[1][1], fail_fast); - CHECK_THROW(sav3[0][1], fail_fast); - } - - // retype strided array with not enough elements - last dimension of the array is too small - { - strided_bounds<2> bounds{ { 4,2 },{ 4, 1 } }; - span bytes2 = bytes.as_span(dim<2>(), dim<>(bytes.size() / 2)); - strided_span sav2{ bytes2, bounds }; - CHECK_THROW(sav2.as_strided_span(), fail_fast); - } - - // retype strided array with not enough elements - strides are too small - { - strided_bounds<2> bounds{ { 4,2 },{ 2, 1 } }; - span bytes2 = bytes.as_span(dim<2>(), dim<>(bytes.size() / 2)); - strided_span sav2{ bytes2, bounds }; - CHECK_THROW(sav2.as_strided_span(), fail_fast); - } - - // 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 bytes2 = bytes.as_span(dim<2>(), dim<>(bytes.size() / 2)); - strided_span sav2{ bytes2, bounds }; - CHECK_THROW(sav2.as_strided_span(), fail_fast); - } - - // retype strided array with not enough elements - strides does not divide by the new typesize - { - strided_bounds<2> bounds{ { 2, 1 },{ 6, 1 } }; - span bytes2 = bytes.as_span(dim<2>(), dim<>(bytes.size() / 2)); - strided_span sav2{ bytes2, bounds }; - CHECK_THROW(sav2.as_strided_span(), fail_fast); - } - - // retype strided array with irregular strides - from raw data - { - strided_bounds<1> bounds{ bytes.size() / 2, 2 }; - strided_span sav2{ bytes.data(), bytes.size(), bounds }; - CHECK_THROW(sav2.as_strided_span(), fail_fast); - } - - // retype strided array with irregular strides - from span - { - strided_bounds<1> bounds{ bytes.size() / 2, 2 }; - strided_span sav2{ bytes, bounds }; - CHECK_THROW(sav2.as_strided_span(), fail_fast); - } - } - - TEST(empty_arrays) - { -#ifdef CONFIRM_COMPILATION_ERRORS - { - span empty; - strided_span empty2; - strided_span empty3{ nullptr,{ 0, 1 } }; - } -#endif - - { - span 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 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 empty_av(nullptr); - strided_span empty_sav{ empty_av, { 0, 1 } }; - - CHECK(empty_sav.bounds().index_bounds() == index<1>{ 0 }); - CHECK_THROW(empty_sav[0], fail_fast); - CHECK_THROW(empty_sav.begin()[0], fail_fast); - CHECK_THROW(empty_sav.cbegin()[0], fail_fast); - - for (auto& v : empty_sav) - { - (void)v; - CHECK(false); - } - } - - { - strided_span empty_sav{ nullptr, 0, { 0, 1 } }; - - CHECK(empty_sav.bounds().index_bounds() == index<1>{ 0 }); - CHECK_THROW(empty_sav[0], fail_fast); - CHECK_THROW(empty_sav.begin()[0], fail_fast); - CHECK_THROW(empty_sav.cbegin()[0], fail_fast); - - for (auto& v : empty_sav) - { - (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; - } - - span av(arr, 8); - - ptrdiff_t a[1] = { 0 }; - index<1> i = a; - - CHECK(av[i] == 4); - - auto av2 = av.as_span(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(span 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 - { - span av = arr; - iterate_second_column(av); - } - // first bound is dynamic - { - span av = arr; - iterate_second_column(av); - } - // second bound is dynamic - { - span av = arr; - iterate_second_column(av); - } - // both bounds are dynamic - { - span 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_span(arr, size); - - // first bound is dynamic - { - span av2 = av.as_span(dim<>(height), dim<>(width)); - iterate_second_column(av2); - } - // second bound is dynamic - { - span av2 = av.as_span(dim<>(height), dim<>(width)); - iterate_second_column(av2); - } - // both bounds are dynamic - { - span av2 = av.as_span(dim<>(height), dim<>(width)); - iterate_second_column(av2); - } - - delete[] arr; - } - - void iterate_every_other_element(span av) - { - // pick every other element - - auto length = av.size() / 2; -#if _MSC_VER > 1800 - auto bounds = strided_bounds<1>({ length }, { 2 }); -#else - auto bounds = strided_bounds<1>(index<1>{ length }, index<1>{ 2 }); -#endif - strided_span strided(&av.data()[1], av.size() - 1, bounds); - - CHECK(strided.size() == length); - CHECK(strided.bounds().index_bounds()[0] == length); - for (auto i = 0; i < strided.size(); ++i) - { - CHECK(strided[i] == av[2 * i + 1]); - } - - int idx = 0; - for (auto num : strided) - { - CHECK(num == av[2 * idx + 1]); - idx++; - } - } - - TEST(strided_span_section_iteration) - { - int arr[8] = {4,0,5,1,6,2,7,3}; - - // static bounds - { - span av(arr, 8); - iterate_every_other_element(av); - } - - // dynamic bounds - { - span av(arr, 8); - iterate_every_other_element(av); - } - } - - TEST(dynamic_strided_span_section_iteration) - { - auto arr = new int[8]; - for (int i = 0; i < 4; ++i) - { - arr[2 * i] = 4 + i; - arr[2 * i + 1] = i; - } - - auto av = as_span(arr, 8); - iterate_every_other_element(av); - - delete[] arr; - } - - void iterate_second_slice(span av) - { - int expected[6] = { 2,3,10,11,18,19 }; - auto section = av.section({ 0,1,0 }, { 3,1,2 }); - - for (auto i = 0; i < section.extent<0>(); ++i) - { - for (auto j = 0; j < section.extent<1>(); ++j) - for (auto k = 0; k < section.extent<2>(); ++k) - { - auto idx = index<3>{ i,j,k }; // avoid braces in the CHECK macro - CHECK(section[idx] == expected[2 * i + 2 * j + k]); - } - } - - for (auto i = 0; i < section.extent<0>(); ++i) - { - for (auto j = 0; j < section.extent<1>(); ++j) - for (auto k = 0; k < section.extent<2>(); ++k) - CHECK(section[i][j][k] == expected[2 * i + 2 * j + k]); - } - - int i = 0; - for (auto num : section) - { - CHECK(num == expected[i]); - i++; - } - } - - TEST(strided_span_section_iteration_3d) - { - int arr[3][4][2]; - for (auto i = 0; i < 3; ++i) - { - for (auto j = 0; j < 4; ++j) - for (auto k = 0; k < 2; ++k) - arr[i][j][k] = 8 * i + 2 * j + k; - } - - { - span av = arr; - iterate_second_slice(av); - } - } - - TEST(dynamic_strided_span_section_iteration_3d) - { - auto height = 12, 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, 24).as_span(dim<3>(),dim<4>(),dim<2>()); - iterate_second_slice(av); - } - - { - auto av = as_span(arr, 24).as_span(dim<>(3), dim<4>(), dim<2>()); - iterate_second_slice(av); - } - - { - auto av = as_span(arr, 24).as_span(dim<3>(), dim<>(4), dim<2>()); - iterate_second_slice(av); - } - - { - auto av = as_span(arr, 24).as_span(dim<3>(), dim<4>(), dim<>(2)); - iterate_second_slice(av); - } - delete[] arr; - } - - TEST(strided_span_conversion) - { - // get an span of 'c' values from the list of X's - - struct X { int a; int b; int c; }; - - X arr[4] = { { 0,1,2 },{ 3,4,5 },{ 6,7,8 },{ 9,10,11 } }; - - int s = sizeof(int) / sizeof(byte); - auto d2 = 3 * s; - auto d1 = sizeof(int) * 12 / d2; - - // convert to 4x12 array of bytes - auto av = as_span(arr, 4).as_bytes().as_span(dim<>(d1), dim<>(d2)); - - CHECK(av.bounds().index_bounds()[0] == 4); - CHECK(av.bounds().index_bounds()[1] == 12); - - // get the last 4 columns - auto section = av.section({ 0, 2 * s }, { 4, s }); // { { arr[0].c[0], arr[0].c[1], arr[0].c[2], arr[0].c[3] } , { arr[1].c[0], ... } , ... } - - // convert to array 4x1 array of integers - auto cs = section.as_strided_span(); // { { arr[0].c }, {arr[1].c } , ... } - - CHECK(cs.bounds().index_bounds()[0] == 4); - CHECK(cs.bounds().index_bounds()[1] == 1); - - // transpose to 1x4 array - strided_bounds<2> reverse_bounds{ - { cs.bounds().index_bounds()[1] , cs.bounds().index_bounds()[0] }, - { cs.bounds().strides()[1], cs.bounds().strides()[0] } - }; - - strided_span transposed{ cs.data(), cs.bounds().total_size(), reverse_bounds }; - - // slice to get a one-dimensional array of c's - strided_span result = transposed[0]; - - CHECK(result.bounds().index_bounds()[0] == 4); - CHECK_THROW(result.bounds().index_bounds()[1], fail_fast); - - int i = 0; - for (auto& num : result) - { - CHECK(num == arr[i].c); - i++; - } - - } - - TEST(constructors) - { - span av(nullptr); - CHECK(av.length() == 0); - - span av2; - CHECK(av2.length() == 0); - - span av3(nullptr, 0); - CHECK(av3.length() == 0); - - // Constructing from a nullptr + length is specifically disallowed - auto f = [&]() {span av4(nullptr, 2);}; - CHECK_THROW(f(), fail_fast); - - int arr1[2][3]; - span av5(arr1); - - array arr2; - span av6(arr2); - - vector vec1(19); - span av7(vec1); - CHECK(av7.length() == 19); - - - span av8; - CHECK(av8.length() == 0); - span av9(arr2); - CHECK(av9.length() == 15); - - -#ifdef CONFIRM_COMPILATION_ERRORS - span av10; - DerivedClass *p = nullptr; - span av11(p, 0); -#endif - } - - TEST(copyandassignment) - { - span av1; - - int arr[] = {3, 4, 5}; - av1 = arr; - span av2; - av2 = av1; - } - - TEST(span_first) - { - int arr[5] = { 1, 2, 3, 4, 5 }; - - { - span av = arr; - CHECK((av.first<2>().bounds() == static_bounds<2>())); - CHECK(av.first<2>().length() == 2); - CHECK(av.first(2).length() == 2); - } - - { - span av = arr; - CHECK((av.first<0>().bounds() == static_bounds<0>())); - CHECK(av.first<0>().length() == 0); - CHECK(av.first(0).length() == 0); - } - - { - span av = arr; - CHECK((av.first<5>().bounds() == static_bounds<5>())); - CHECK(av.first<5>().length() == 5); - CHECK(av.first(5).length() == 5); - } - - { - span av = arr; -#ifdef CONFIRM_COMPILATION_ERRORS - CHECK(av.first<6>().bounds() == static_bounds<6>()); - CHECK(av.first<6>().length() == 6); -#endif - CHECK_THROW(av.first(6).length(), fail_fast); - } - - { - span av; - CHECK((av.first<0>().bounds() == static_bounds<0>())); - CHECK(av.first<0>().length() == 0); - CHECK(av.first(0).length() == 0); - } - } - - TEST(span_last) - { - int arr[5] = { 1, 2, 3, 4, 5 }; - - { - span av = arr; - CHECK((av.last<2>().bounds() == static_bounds<2>())); - CHECK(av.last<2>().length() == 2); - CHECK(av.last(2).length() == 2); - } - - { - span av = arr; - CHECK((av.last<0>().bounds() == static_bounds<0>())); - CHECK(av.last<0>().length() == 0); - CHECK(av.last(0).length() == 0); - } - - { - span av = arr; - CHECK((av.last<5>().bounds() == static_bounds<5>())); - CHECK(av.last<5>().length() == 5); - CHECK(av.last(5).length() == 5); - } - - - { - span 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 av; - CHECK((av.last<0>().bounds() == static_bounds<0>())); - CHECK(av.last<0>().length() == 0); - CHECK(av.last(0).length() == 0); - } - } - - TEST(customized_span_size) - { - double (*arr)[3][4] = new double[100][3][4]; - span av1(arr, 10); - - struct EffectiveStructure - { - double* v1; - ptrdiff_t v2; - }; - CHECK(sizeof(av1) == sizeof(EffectiveStructure)); - - CHECK_THROW(av1[10][3][4], fail_fast); - - span av2 = av1.as_span(dim<>(5), dim<6>(), dim<4>()); - (void)av2; - } - - TEST(span_sub) - { - int arr[5] = { 1, 2, 3, 4, 5 }; - - { - span av = arr; - CHECK((av.sub<2,2>().bounds() == static_bounds<2>())); - CHECK((av.sub<2,2>().length() == 2)); - CHECK(av.sub(2,2).length() == 2); - CHECK(av.sub(2,3).length() == 3); - } - - - { - span av = arr; - CHECK((av.sub<0,0>().bounds() == static_bounds<0>())); - CHECK((av.sub<0,0>().length() == 0)); - CHECK(av.sub(0,0).length() == 0); - } - - { - span av = arr; - CHECK((av.sub<0,5>().bounds() == static_bounds<5>())); - CHECK((av.sub<0,5>().length() == 5)); - CHECK(av.sub(0,5).length() == 5); - CHECK_THROW(av.sub(0,6).length(), fail_fast); - CHECK_THROW(av.sub(1,5).length(), fail_fast); - } - - { - span av = arr; - CHECK((av.sub<5,0>().bounds() == static_bounds<0>())); - CHECK((av.sub<5, 0>().length() == 0)); - CHECK(av.sub(5,0).length() == 0); - CHECK_THROW(av.sub(6,0).length(), fail_fast); - } - - { - span av; - CHECK((av.sub<0,0>().bounds() == static_bounds<0>())); - CHECK((av.sub<0,0>().length() == 0)); - CHECK(av.sub(0,0).length() == 0); - CHECK_THROW((av.sub<1,0>().length()), fail_fast); - } + CHECK_THROW(av.last(6).length(), fail_fast); + } + + { + span 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}; + + { + span 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); + } + + { + span 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 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); + } + + { + span 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); + } + + { + span 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); + } { span av; - CHECK(av.sub(0).length() == 0); - CHECK_THROW(av.sub(1).length(), fail_fast); + CHECK(av.subspan(0).length() == 0); + CHECK_THROW(av.subspan(1).length(), fail_fast); } { span av = arr; - CHECK(av.sub(0).length() == 5); - CHECK(av.sub(1).length() == 4); - CHECK(av.sub(4).length() == 1); - CHECK(av.sub(5).length() == 0); - CHECK_THROW(av.sub(6).length(), fail_fast); - auto av2 = av.sub(1); - for (int i = 0; i < 4; ++i) - CHECK(av2[i] == i+2); + 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); } - + { - span av = arr; - CHECK(av.sub(0).length() == 5); - CHECK(av.sub(1).length() == 4); - CHECK(av.sub(4).length() == 1); - CHECK(av.sub(5).length() == 0); - CHECK_THROW(av.sub(6).length(), fail_fast); - auto av2 = av.sub(1); - for (int i = 0; i < 4; ++i) - CHECK(av2[i] == i+2); + span 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); } } - void AssertNullEmptyProperties(span& av) - { - CHECK(av.length() == 0); - CHECK(av.data() == nullptr); - CHECK(!av); - } + TEST(rank) + { + int arr[2] = {1, 2}; - template - void AssertContentsMatch(T a1, U a2) - { - CHECK(a1.length() == a2.length()); - for (auto i = 0; i < a1.length(); ++i) - CHECK(a1[i] == a2[i]); - } + { + span s; + CHECK(s.rank() == 1); + } - TEST(TestNullConstruction) - { - span av; - AssertNullEmptyProperties(av); + { + span s = arr; + CHECK(s.rank() == 1); + } - span av2(nullptr); - AssertNullEmptyProperties(av2); - } + int arr2d[1][1] = {}; + { + span s = arr2d; + CHECK(s.rank() == 2); + } + } - TEST(ArrayConstruction) - { - int a[] = { 1, 2, 3, 4 }; + TEST(extent) + { + { + span 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 av = { &a[1], 3 }; - CHECK(av.length() == 3); + { + span s; + CHECK(s.extent() == 0); + CHECK(s.extent(0) == 0); + CHECK_THROW(s.extent(1), fail_fast); + } - span av3 = { a, 2 }; - CHECK(av3.length() == 2); + { + int arr2d[1][2] = {}; - span av2 = a; - CHECK(av2.length() == 4); - } + span 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); + } - TEST(NonConstConstConversions) - { - int a[] = { 1, 2, 3, 4 }; + { + int arr2d[1][2] = {}; + + span 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}; + + { + span s = arr; + CHECK(s(0) == 1); + CHECK_THROW(s(5), fail_fast); + } + + int arr2d[2][3] = {1, 2, 3, 4, 5, 6}; + + { + span s = arr2d; + CHECK(s(0, 0) == 1); + CHECK(s(1, 2) == 6); + } + } + + TEST(comparison_operators) + { + { + int arr[10][2]; + auto s1 = as_span(arr); + span s2 = s1; + + CHECK(s1 == s2); + + span s3 = as_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 + + span s1 = nullptr; + span 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}; + span s1 = arr1; + span 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}; + + span s1 = {&arr[0], 2}; // shorter + span 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 + + span s1 = arr1; + span 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_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 exp, int expected_value) + { + for (auto val : exp) { + CHECK(val == expected_value); + } + } + + void overloaded_func(span exp, char expected_value) + { + for (auto val : exp) { + CHECK(val == expected_value); + } + } + + void fixed_func(span 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) + { + { + 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 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 strspan = as_span(str); + (void) strspan; + const string cstr; + span cstrspan = as_span(cstr); + (void) cstrspan; + } + + { + 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 arr = {0.0, 0.0, 0.0}; + auto cv = as_span(arr); + (void) cv; + + vector vec(3); + auto dv = as_span(vec); + (void) dv; #ifdef CONFIRM_COMPILATION_ERRORS - span cav = a; - span av = cav; -#else - span av = a; - span cav = av; + auto dv2 = as_span(std::move(vec)); #endif - AssertContentsMatch(av, cav); - } + } + } - TEST(FixedSizeConversions) - { - int arr[] = { 1, 2, 3, 4 }; - - // converting to an span from an equal size array is ok - span av4 = arr; - CHECK(av4.length() == 4); + TEST(empty_spans) + { + { + span empty_av(nullptr); - // converting to dynamic_range a_v is always ok - { - span av = av4; - (void)av; - } - { - span av = arr; - (void)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); + } + } - // initialization or assignment to static span that REDUCES size is NOT ok -#ifdef CONFIRM_COMPILATION_ERRORS - { - span av2 = arr; - } - { - span av2 = av4; - } -#endif + { + span 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 av = arr; - span av2 = av; - (void)av2; - } + 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 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) + { + { + // 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 - { - span av = arr; - span av2 = av.as_span(dim<2>(), dim<2>()); - } + { + 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(span 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 + { + span av = arr; + iterate_second_column(av); + } + // first bound is dynamic + { + span av = arr; + iterate_second_column(av); + } + // second bound is dynamic + { + span av = arr; + iterate_second_column(av); + } + // both bounds are dynamic + { + span 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_span(arr, size); + + // first bound is dynamic + { + span av2 = as_span(av, dim<>(height), dim<>(width)); + iterate_second_column(av2); + } + // second bound is dynamic + { + span av2 = as_span(av, dim<>(height), dim<>(width)); + iterate_second_column(av2); + } + // both bounds are dynamic + { + span 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 av1(arr, 10); + + struct EffectiveStructure + { + double* v1; + ptrdiff_t v2; + }; + CHECK(sizeof(av1) == sizeof(EffectiveStructure)); + + CHECK_THROW(av1[10][3][4], fail_fast); + + span 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 av4 = arr; + CHECK(av4.length() == 4); + + // converting to dynamic_range a_v is always ok + { + span av = av4; + (void) av; + } + { + span av = arr; + (void) av; + } + +// initialization or assignment to static span that REDUCES size is NOT ok +#ifdef CONFIRM_COMPILATION_ERRORS + { + span av2 = arr; + } + { + span av2 = av4; + } #endif - { - span av = arr; - auto f = [&]() {span av2 = av.as_span(dim<>(2), dim<>(2)); (void)av2; }; - CHECK_THROW(f(), fail_fast); - } - - // but doing so explicitly is ok - - // you can convert statically - { - span av2 = {arr, 2}; - (void)av2; - } - { - span av2 = av4.first<1>(); - (void)av2; - } - - // ...or dynamically - { - // NB: implicit conversion to span from span - span av2 = av4.first(1); - (void)av2; - } - - // initialization or assignment to static span that requires size INCREASE is not ok. - int arr2[2] = { 1, 2 }; + { + span av = arr; + span av2 = av; + (void) av2; + } #ifdef CONFIRM_COMPILATION_ERRORS - { - span av4 = arr2; - } - { - span av2 = arr2; - span av4 = av2; - } + { + span av = arr; + span av2 = av.as_span(dim<2>(), dim<2>()); + } #endif - { - auto f = [&]() {span av4 = {arr2, 2}; (void)av4; }; - 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 av = arr2; - auto f = [&](){ span av2 = av; (void)av2; }; - CHECK_THROW(f(), fail_fast); - } + { + span av = arr; + span av2 = as_span(av, dim<>(2), dim<>(2)); + auto workaround_macro = [&]() { return av2[{1, 0}] == 2; }; + CHECK(workaround_macro()); + } - TEST(AsWriteableBytes) - { - int a[] = { 1, 2, 3, 4 }; + // but doing so explicitly is ok + + // you can convert statically + { + span av2 = {arr, 2}; + (void) av2; + } + { + span av2 = av4.first<1>(); + (void) av2; + } + + // ...or dynamically + { + // NB: implicit conversion to span from span + span av2 = av4.first(1); + (void) av2; + } + + // initialization or assignment to static span that requires size INCREASE is not ok. + int arr2[2] = {1, 2}; - { #ifdef CONFIRM_COMPILATION_ERRORS - // you should not be able to get writeable bytes for const objects - span av = a; - auto wav = av.as_writeable_bytes(); + { + span av4 = arr2; + } + { + span av2 = arr2; + span av4 = av2; + } #endif - } + { + auto f = [&]() { + span av4 = {arr2, 2}; + (void) av4; + }; + CHECK_THROW(f(), fail_fast); + } - { - span av; - auto wav = av.as_writeable_bytes(); - CHECK(wav.length() == av.length()); - CHECK(wav.length() == 0); - CHECK(wav.bytes() == 0); - } + // this should fail - we are trying to assign a small dynamic a_v to a fixed_size larger one + span av = arr2; + auto f = [&]() { + span av2 = av; + (void) av2; + }; + CHECK_THROW(f(), fail_fast); + } - { - span av = a; - auto wav = av.as_writeable_bytes(); - CHECK(wav.data() == (byte*)&a[0]); - CHECK(wav.length() == sizeof(a)); - } - } + TEST(as_writeable_bytes) + { + int a[] = {1, 2, 3, 4}; - TEST(NonConstIterator) - { - int a[] = { 1, 2, 3, 4 }; + { +#ifdef CONFIRM_COMPILATION_ERRORS + // you should not be able to get writeable bytes for const objects + span av = a; + auto wav = av.as_writeable_bytes(); +#endif + } - { - span av = a; - auto wav = av.as_writeable_bytes(); - for (auto& b : wav) - { - b = byte(0); - } - for (size_t i = 0; i < 4; ++i) - { - CHECK(a[i] == 0); - } - } + { + span av; + auto wav = as_writeable_bytes(av); + CHECK(wav.length() == av.length()); + CHECK(wav.length() == 0); + CHECK(wav.size_bytes() == 0); + } - { - span av = a; - for (auto& n : av) - { - n = 1; - } - for (size_t i = 0; i < 4; ++i) - { - CHECK(a[i] == 1); - } - } - } + { + span av = a; + auto wav = as_writeable_bytes(av); + CHECK(wav.data() == (byte*) &a[0]); + CHECK(wav.length() == sizeof(a)); + } + } - TEST(ArrayViewComparison) - { - { - int arr[10][2]; - auto av1 = as_span(arr); - span av2 = av1; + TEST(iterator) + { + int a[] = {1, 2, 3, 4}; - CHECK(av1 == av2); + { + span 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 av3 = av1.as_span(dim<>(20)); - CHECK(av3 == av2 && av3 == av1); - } - - { - auto av1 = nullptr; - auto av2 = nullptr; - CHECK(av1 == av2); - CHECK(!(av1 != av2)); - CHECK(!(av1 < av2)); - CHECK(av1 <= av2); - CHECK(!(av1 > av2)); - CHECK(av1 >= av2); - CHECK(av2 == av1); - CHECK(!(av2 != av1)); - CHECK(!(av2 < av1)); - CHECK(av2 <= av1); - CHECK(!(av2 > av1)); - CHECK(av2 >= av1); - } - - { - int arr[] = { 2, 1 }; // bigger - - span av1 = nullptr; - span av2 = arr; - - CHECK(av1 != av2); - CHECK(av2 != av1); - CHECK(!(av1 == av2)); - CHECK(!(av2 == av1)); - CHECK(av1 < av2); - CHECK(!(av2 < av1)); - CHECK(av1 <= av2); - CHECK(!(av2 <= av1)); - CHECK(av2 > av1); - CHECK(!(av1 > av2)); - CHECK(av2 >= av1); - CHECK(!(av1 >= av2)); - } - - { - int arr1[] = { 1, 2 }; - int arr2[] = { 1, 2 }; - span av1 = arr1; - span av2 = arr2; - - CHECK(av1 == av2); - CHECK(!(av1 != av2)); - CHECK(!(av1 < av2)); - CHECK(av1 <= av2); - CHECK(!(av1 > av2)); - CHECK(av1 >= av2); - CHECK(av2 == av1); - CHECK(!(av2 != av1)); - CHECK(!(av2 < av1)); - CHECK(av2 <= av1); - CHECK(!(av2 > av1)); - CHECK(av2 >= av1); - } - - { - int arr[] = { 1, 2, 3 }; - - span av1 = { &arr[0], 2 }; // shorter - span av2 = arr; // longer - - CHECK(av1 != av2); - CHECK(av2 != av1); - CHECK(!(av1 == av2)); - CHECK(!(av2 == av1)); - CHECK(av1 < av2); - CHECK(!(av2 < av1)); - CHECK(av1 <= av2); - CHECK(!(av2 <= av1)); - CHECK(av2 > av1); - CHECK(!(av1 > av2)); - CHECK(av2 >= av1); - CHECK(!(av1 >= av2)); - } - - { - int arr1[] = { 1, 2 }; // smaller - int arr2[] = { 2, 1 }; // bigger - - span av1 = arr1; - span av2 = arr2; - - CHECK(av1 != av2); - CHECK(av2 != av1); - CHECK(!(av1 == av2)); - CHECK(!(av2 == av1)); - CHECK(av1 < av2); - CHECK(!(av2 < av1)); - CHECK(av1 <= av2); - CHECK(!(av2 <= av1)); - CHECK(av2 > av1); - CHECK(!(av1 > av2)); - CHECK(av2 >= av1); - CHECK(!(av1 >= av2)); - } - } + { + span 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(); -} +int main(int, const char* []) { return UnitTest::RunAllTests(); } diff --git a/tests/strided_span_tests.cpp b/tests/strided_span_tests.cpp new file mode 100644 index 0000000..0fbf1d7 --- /dev/null +++ b/tests/strided_span_tests.cpp @@ -0,0 +1,748 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// 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 +#include + +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace gsl; + +namespace +{ + struct BaseClass {}; + struct DerivedClass : BaseClass {}; +} + +SUITE(strided_span_tests) +{ + TEST (span_section_test) + { + int a[30][4][5]; + + auto av = as_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; + } + + TEST(span_section) + { + std::vector data(5 * 10); + std::iota(begin(data), end(data), 0); + const span av = as_span(span{data}, dim<5>(), dim<10>()); + + strided_span av_section_1 = av.section({ 1, 2 }, { 3, 4 }); + CHECK((av_section_1[{0, 0}] == 12)); + CHECK((av_section_1[{0, 1}] == 13)); + CHECK((av_section_1[{1, 0}] == 22)); + CHECK((av_section_1[{2, 3}] == 35)); + + strided_span av_section_2 = av_section_1.section({ 1, 2 }, { 2,2 }); + CHECK((av_section_2[{0, 0}] == 24)); + CHECK((av_section_2[{0, 1}] == 25)); + CHECK((av_section_2[{1, 0}] == 34)); + } + + TEST(strided_span_constructors) + { + // Check stride constructor + { + int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + const int carr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + strided_span sav1{ arr, {{9}, {1}} }; // T -> T + CHECK(sav1.bounds().index_bounds() == index<1>{ 9 }); + CHECK(sav1.bounds().stride() == 1); + CHECK(sav1[0] == 1 && sav1[8] == 9); + + + strided_span sav2{ carr, {{ 4 }, { 2 }} }; // const T -> const T + CHECK(sav2.bounds().index_bounds() == index<1>{ 4 }); + CHECK(sav2.bounds().strides() == index<1>{2}); + CHECK(sav2[0] == 1 && sav2[3] == 7); + + strided_span sav3{ arr, {{ 2, 2 },{ 6, 2 }} }; // T -> const T + CHECK((sav3.bounds().index_bounds() == index<2>{ 2, 2 })); + CHECK((sav3.bounds().strides() == index<2>{ 6, 2 })); + CHECK((sav3[{0, 0}] == 1 && sav3[{0, 1}] == 3 && sav3[{1, 0}] == 7)); + } + + // Check span constructor + { + int arr[] = { 1, 2 }; + + // From non-cv-qualified source + { + const span src = arr; + + strided_span sav{ src, {2, 1} }; + CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav.bounds().strides() == index<1>{ 1 }); + CHECK(sav[1] == 2); + +#if _MSC_VER > 1800 + //strided_span sav_c{ {src}, {2, 1} }; + strided_span sav_c{ span{src}, strided_bounds<1>{2, 1} }; +#else + strided_span sav_c{ span{src}, strided_bounds<1>{2, 1} }; +#endif + CHECK(sav_c.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_c.bounds().strides() == index<1>{ 1 }); + CHECK(sav_c[1] == 2); + +#if _MSC_VER > 1800 + strided_span sav_v{ src, {2, 1} }; +#else + strided_span sav_v{ span{src}, strided_bounds<1>{2, 1} }; +#endif + CHECK(sav_v.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_v.bounds().strides() == index<1>{ 1 }); + CHECK(sav_v[1] == 2); + +#if _MSC_VER > 1800 + strided_span sav_cv{ src, {2, 1} }; +#else + strided_span sav_cv{ span{src}, strided_bounds<1>{2, 1} }; +#endif + CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); + CHECK(sav_cv[1] == 2); + } + + // From const-qualified source + { + const span src{ arr }; + + strided_span sav_c{ src, {2, 1} }; + CHECK(sav_c.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_c.bounds().strides() == index<1>{ 1 }); + CHECK(sav_c[1] == 2); + +#if _MSC_VER > 1800 + strided_span sav_cv{ src, {2, 1} }; +#else + strided_span sav_cv{ span{src}, strided_bounds<1>{2, 1} }; +#endif + + CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); + CHECK(sav_cv[1] == 2); + } + + // From volatile-qualified source + { + const span src{ arr }; + + strided_span sav_v{ src, {2, 1} }; + CHECK(sav_v.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_v.bounds().strides() == index<1>{ 1 }); + CHECK(sav_v[1] == 2); + +#if _MSC_VER > 1800 + strided_span sav_cv{ src, {2, 1} }; +#else + strided_span sav_cv{ span{src}, strided_bounds<1>{2, 1} }; +#endif + CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); + CHECK(sav_cv[1] == 2); + } + + // From cv-qualified source + { + const span src{ arr }; + + strided_span sav_cv{ src, {2, 1} }; + CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); + CHECK(sav_cv[1] == 2); + } + } + + // Check const-casting constructor + { + int arr[2] = { 4, 5 }; + + const span av(arr, 2); + span av2{ av }; + CHECK(av2[1] == 5); + + static_assert(std::is_convertible, span>::value, "ctor is not implicit!"); + + const strided_span src{ arr, {2, 1} }; + strided_span sav{ src }; + CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav.bounds().stride() == 1); + CHECK(sav[1] == 5); + + static_assert(std::is_convertible, strided_span>::value, "ctor is not implicit!"); + } + + // Check copy constructor + { + int arr1[2] = { 3, 4 }; + const strided_span src1{ arr1, {2, 1} }; + strided_span sav1{ src1 }; + + CHECK(sav1.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav1.bounds().stride() == 1); + CHECK(sav1[0] == 3); + + int arr2[6] = { 1, 2, 3, 4, 5, 6 }; + const strided_span src2{ arr2, {{ 3, 2 }, { 2, 1 }} }; + strided_span sav2{ src2 }; + CHECK((sav2.bounds().index_bounds() == index<2>{ 3, 2 })); + CHECK((sav2.bounds().strides() == index<2>{ 2, 1 })); + CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5)); + } + + // Check const-casting assignment operator + { + int arr1[2] = { 1, 2 }; + int arr2[6] = { 3, 4, 5, 6, 7, 8 }; + + const strided_span src{ arr1, {{2}, {1}} }; + strided_span sav{ arr2, {{3}, {2}} }; + strided_span& sav_ref = (sav = src); + CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav.bounds().strides() == index<1>{ 1 }); + CHECK(sav[0] == 1); + CHECK(&sav_ref == &sav); + } + + // Check copy assignment operator + { + int arr1[2] = { 3, 4 }; + int arr1b[1] = { 0 }; + const strided_span src1{ arr1, {2, 1} }; + strided_span sav1{ arr1b, {1, 1} }; + strided_span& sav1_ref = (sav1 = src1); + CHECK(sav1.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav1.bounds().strides() == index<1>{ 1 }); + CHECK(sav1[0] == 3); + CHECK(&sav1_ref == &sav1); + + const int arr2[6] = { 1, 2, 3, 4, 5, 6 }; + const int arr2b[1] = { 0 }; + const strided_span src2{ arr2, {{ 3, 2 },{ 2, 1 }} }; + strided_span sav2{ arr2b, {{ 1, 1 },{ 1, 1 }} }; + strided_span& sav2_ref = (sav2 = src2); + CHECK((sav2.bounds().index_bounds() == index<2>{ 3, 2 })); + CHECK((sav2.bounds().strides() == index<2>{ 2, 1 })); + CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5)); + CHECK(&sav2_ref == &sav2); + } + } + + TEST(strided_span_slice) + { + std::vector data(5 * 10); + std::iota(begin(data), end(data), 0); + const span src = as_span(span{data}, dim<5>(), dim<10>()); + + const strided_span sav{ src, {{5, 10}, {10, 1}} }; +#ifdef CONFIRM_COMPILATION_ERRORS + const strided_span csav{ {src},{ { 5, 10 },{ 10, 1 } } }; +#endif + const strided_span csav{ span{ src }, { { 5, 10 },{ 10, 1 } } }; + + strided_span sav_sl = sav[2]; + CHECK(sav_sl[0] == 20); + CHECK(sav_sl[9] == 29); + + strided_span csav_sl = sav[3]; + CHECK(csav_sl[0] == 30); + CHECK(csav_sl[9] == 39); + + CHECK(sav[4][0] == 40); + CHECK(sav[4][9] == 49); + } + + TEST(strided_span_column_major) + { + // strided_span may be used to accomodate more peculiar + // use cases, such as column-major multidimensional array + // (aka. "FORTRAN" layout). + + int cm_array[3 * 5] = { + 1, 4, 7, 10, 13, + 2, 5, 8, 11, 14, + 3, 6, 9, 12, 15 + }; + strided_span cm_sav{ cm_array, {{ 5, 3 },{ 1, 5 }} }; + + // Accessing elements + CHECK((cm_sav[{0, 0}] == 1)); + CHECK((cm_sav[{0, 1}] == 2)); + CHECK((cm_sav[{1, 0}] == 4)); + CHECK((cm_sav[{4, 2}] == 15)); + + // Slice + strided_span cm_sl = cm_sav[3]; + + CHECK(cm_sl[0] == 10); + CHECK(cm_sl[1] == 11); + CHECK(cm_sl[2] == 12); + + // Section + strided_span cm_sec = cm_sav.section( { 2, 1 }, { 3, 2 }); + + CHECK((cm_sec.bounds().index_bounds() == index<2>{3, 2})); + CHECK((cm_sec[{0, 0}] == 8)); + CHECK((cm_sec[{0, 1}] == 9)); + CHECK((cm_sec[{1, 0}] == 11)); + CHECK((cm_sec[{2, 1}] == 15)); + } + + TEST(strided_span_bounds) + { + int arr[] = { 0, 1, 2, 3 }; + span av(arr); + + { + // incorrect sections + + CHECK_THROW(av.section(0, 0)[0], fail_fast); + CHECK_THROW(av.section(1, 0)[0], fail_fast); + CHECK_THROW(av.section(1, 1)[1], fail_fast); + + CHECK_THROW(av.section(2, 5), fail_fast); + CHECK_THROW(av.section(5, 2), fail_fast); + CHECK_THROW(av.section(5, 0), fail_fast); + CHECK_THROW(av.section(0, 5), fail_fast); + CHECK_THROW(av.section(5, 5), fail_fast); + } + + { + // zero stride + strided_span sav{ av,{ { 4 },{} } }; + CHECK(sav[0] == 0); + CHECK(sav[3] == 0); + CHECK_THROW(sav[4], fail_fast); + } + + { + // zero extent + strided_span sav{ av,{ {},{ 1 } } }; + CHECK_THROW(sav[0], fail_fast); + } + + { + // zero extent and stride + strided_span sav{ av,{ {},{} } }; + CHECK_THROW(sav[0], fail_fast); + } + + { + // strided array ctor with matching strided bounds + strided_span sav{ arr,{ 4, 1 } }; + CHECK(sav.bounds().index_bounds() == index<1>{ 4 }); + CHECK(sav[3] == 3); + CHECK_THROW(sav[4], fail_fast); + } + + { + // strided array ctor with smaller strided bounds + strided_span sav{ arr,{ 2, 1 } }; + CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav[1] == 1); + CHECK_THROW(sav[2], fail_fast); + } + + { + // strided array ctor with fitting irregular bounds + strided_span sav{ arr,{ 2, 3 } }; + CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav[0] == 0); + CHECK(sav[1] == 3); + CHECK_THROW(sav[2], fail_fast); + } + + { + // bounds cross data boundaries - from static arrays + CHECK_THROW((strided_span { arr, { 3, 2 } }), fail_fast); + CHECK_THROW((strided_span { arr, { 3, 3 } }), fail_fast); + CHECK_THROW((strided_span { arr, { 4, 5 } }), fail_fast); + CHECK_THROW((strided_span { arr, { 5, 1 } }), fail_fast); + CHECK_THROW((strided_span { arr, { 5, 5 } }), fail_fast); + } + + { + // bounds cross data boundaries - from array view + CHECK_THROW((strided_span { av, { 3, 2 } }), fail_fast); + CHECK_THROW((strided_span { av, { 3, 3 } }), fail_fast); + CHECK_THROW((strided_span { av, { 4, 5 } }), fail_fast); + CHECK_THROW((strided_span { av, { 5, 1 } }), fail_fast); + CHECK_THROW((strided_span { av, { 5, 5 } }), fail_fast); + } + + { + // bounds cross data boundaries - from dynamic arrays + CHECK_THROW((strided_span { av.data(), 4, { 3, 2 } }), fail_fast); + CHECK_THROW((strided_span { av.data(), 4, { 3, 3 } }), fail_fast); + CHECK_THROW((strided_span { av.data(), 4, { 4, 5 } }), fail_fast); + CHECK_THROW((strided_span { av.data(), 4, { 5, 1 } }), fail_fast); + CHECK_THROW((strided_span { av.data(), 4, { 5, 5 } }), fail_fast); + CHECK_THROW((strided_span { av.data(), 2, { 2, 2 } }), fail_fast); + } + +#ifdef CONFIRM_COMPILATION_ERRORS + { + strided_span sav0{ av.data(), { 3, 2 } }; + strided_span sav1{ arr, { 1 } }; + strided_span sav2{ arr, { 1,1,1 } }; + strided_span sav3{ av, { 1 } }; + strided_span sav4{ av, { 1,1,1 } }; + strided_span sav5{ av.as_span(dim<2>(), dim<2>()), { 1 } }; + strided_span sav6{ av.as_span(dim<2>(), dim<2>()), { 1,1,1 } }; + strided_span sav7{ av.as_span(dim<2>(), dim<2>()), { { 1,1 },{ 1,1 },{ 1,1 } } }; + + index<1> index{ 0, 1 }; + strided_span sav8{ arr,{ 1,{ 1,1 } } }; + strided_span sav9{ arr,{ { 1,1 },{ 1,1 } } }; + strided_span sav10{ av,{ 1,{ 1,1 } } }; + strided_span sav11{ av,{ { 1,1 },{ 1,1 } } }; + strided_span sav12{ av.as_span(dim<2>(), dim<2>()),{ { 1 },{ 1 } } }; + strided_span sav13{ av.as_span(dim<2>(), dim<2>()),{ { 1 },{ 1,1,1 } } }; + strided_span sav14{ av.as_span(dim<2>(), dim<2>()),{ { 1,1,1 },{ 1 } } }; + } +#endif + } + + TEST(strided_span_type_conversion) + { + int arr[] = { 0, 1, 2, 3 }; + span av(arr); + + { + strided_span sav{ av.data(), av.size(), { av.size() / 2, 2 } }; +#ifdef CONFIRM_COMPILATION_ERRORS + strided_span lsav1 = sav.as_strided_span(); +#endif + } + { + strided_span sav{ av, { av.size() / 2, 2 } }; +#ifdef CONFIRM_COMPILATION_ERRORS + strided_span lsav1 = sav.as_strided_span(); +#endif + } + + span bytes = as_bytes(av); + + // retype strided array with regular strides - from raw data + { + strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } }; + strided_span sav2{ bytes.data(), bytes.size(), bounds }; + strided_span sav3 = sav2.as_strided_span(); + CHECK(sav3[0][0] == 0); + CHECK(sav3[1][0] == 2); + CHECK_THROW(sav3[1][1], fail_fast); + CHECK_THROW(sav3[0][1], fail_fast); + } + + // retype strided array with regular strides - from span + { + strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } }; + span bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + strided_span sav2{ bytes2, bounds }; + strided_span sav3 = sav2.as_strided_span(); + CHECK(sav3[0][0] == 0); + CHECK(sav3[1][0] == 2); + CHECK_THROW(sav3[1][1], fail_fast); + CHECK_THROW(sav3[0][1], fail_fast); + } + + // retype strided array with not enough elements - last dimension of the array is too small + { + strided_bounds<2> bounds{ { 4,2 },{ 4, 1 } }; + span bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + strided_span sav2{ bytes2, bounds }; + CHECK_THROW(sav2.as_strided_span(), fail_fast); + } + + // retype strided array with not enough elements - strides are too small + { + strided_bounds<2> bounds{ { 4,2 },{ 2, 1 } }; + span bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + strided_span sav2{ bytes2, bounds }; + CHECK_THROW(sav2.as_strided_span(), fail_fast); + } + + // 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 bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + strided_span sav2{ bytes2, bounds }; + CHECK_THROW(sav2.as_strided_span(), fail_fast); + } + + // retype strided array with not enough elements - strides does not divide by the new typesize + { + strided_bounds<2> bounds{ { 2, 1 },{ 6, 1 } }; + span bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + strided_span sav2{ bytes2, bounds }; + CHECK_THROW(sav2.as_strided_span(), fail_fast); + } + + // retype strided array with irregular strides - from raw data + { + strided_bounds<1> bounds{ bytes.size() / 2, 2 }; + strided_span sav2{ bytes.data(), bytes.size(), bounds }; + CHECK_THROW(sav2.as_strided_span(), fail_fast); + } + + // retype strided array with irregular strides - from span + { + strided_bounds<1> bounds{ bytes.size() / 2, 2 }; + strided_span sav2{ bytes, bounds }; + CHECK_THROW(sav2.as_strided_span(), fail_fast); + } + } + + TEST(empty_strided_spans) + { + { + span empty_av(nullptr); + strided_span empty_sav{ empty_av, { 0, 1 } }; + + CHECK(empty_sav.bounds().index_bounds() == index<1>{ 0 }); + CHECK_THROW(empty_sav[0], fail_fast); + CHECK_THROW(empty_sav.begin()[0], fail_fast); + CHECK_THROW(empty_sav.cbegin()[0], fail_fast); + + for (auto& v : empty_sav) + { + (void)v; + CHECK(false); + } + } + + { + strided_span empty_sav{ nullptr, 0, { 0, 1 } }; + + CHECK(empty_sav.bounds().index_bounds() == index<1>{ 0 }); + CHECK_THROW(empty_sav[0], fail_fast); + CHECK_THROW(empty_sav.begin()[0], fail_fast); + CHECK_THROW(empty_sav.cbegin()[0], fail_fast); + + for (auto& v : empty_sav) + { + (void)v; + CHECK(false); + } + } + } + + void iterate_every_other_element(span av) + { + // pick every other element + + auto length = av.size() / 2; +#if _MSC_VER > 1800 + auto bounds = strided_bounds<1>({length}, {2}); +#else + auto bounds = strided_bounds<1>(index<1>{ length }, index<1>{ 2 }); +#endif + strided_span strided(&av.data()[1], av.size() - 1, bounds); + + CHECK(strided.size() == length); + CHECK(strided.bounds().index_bounds()[0] == length); + for (auto i = 0; i < strided.size(); ++i) + { + CHECK(strided[i] == av[2 * i + 1]); + } + + int idx = 0; + for (auto num : strided) + { + CHECK(num == av[2 * idx + 1]); + idx++; + } + } + + TEST(strided_span_section_iteration) + { + int arr[8] = {4,0,5,1,6,2,7,3}; + + // static bounds + { + span av(arr, 8); + iterate_every_other_element(av); + } + + // dynamic bounds + { + span av(arr, 8); + iterate_every_other_element(av); + } + } + + TEST(dynamic_strided_span_section_iteration) + { + auto arr = new int[8]; + for (int i = 0; i < 4; ++i) + { + arr[2 * i] = 4 + i; + arr[2 * i + 1] = i; + } + + auto av = as_span(arr, 8); + iterate_every_other_element(av); + + delete[] arr; + } + + void iterate_second_slice(span av) + { + int expected[6] = {2,3,10,11,18,19}; + auto section = av.section({0,1,0}, {3,1,2}); + + for (auto i = 0; i < section.extent<0>(); ++i) + { + for (auto j = 0; j < section.extent<1>(); ++j) + for (auto k = 0; k < section.extent<2>(); ++k) + { + auto idx = index<3>{i,j,k}; // avoid braces in the CHECK macro + CHECK(section[idx] == expected[2 * i + 2 * j + k]); + } + } + + for (auto i = 0; i < section.extent<0>(); ++i) + { + for (auto j = 0; j < section.extent<1>(); ++j) + for (auto k = 0; k < section.extent<2>(); ++k) + CHECK(section[i][j][k] == expected[2 * i + 2 * j + k]); + } + + int i = 0; + for (auto num : section) + { + CHECK(num == expected[i]); + i++; + } + } + + TEST(strided_span_section_iteration_3d) + { + int arr[3][4][2]; + for (auto i = 0; i < 3; ++i) + { + for (auto j = 0; j < 4; ++j) + for (auto k = 0; k < 2; ++k) + arr[i][j][k] = 8 * i + 2 * j + k; + } + + { + span av = arr; + iterate_second_slice(av); + } + } + + TEST(dynamic_strided_span_section_iteration_3d) + { + auto height = 12, 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(as_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>()); + iterate_second_slice(av); + } + + { + auto av = as_span(as_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)); + iterate_second_slice(av); + } + delete[] arr; + } + + TEST(strided_span_conversion) + { + // get an span of 'c' values from the list of X's + + struct X { int a; int b; int c; }; + + X arr[4] = {{0,1,2},{3,4,5},{6,7,8},{9,10,11}}; + + int s = sizeof(int) / sizeof(byte); + auto d2 = 3 * s; + 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)); + + CHECK(av.bounds().index_bounds()[0] == 4); + CHECK(av.bounds().index_bounds()[1] == 12); + + // get the last 4 columns + auto section = av.section({0, 2 * s}, {4, s}); // { { arr[0].c[0], arr[0].c[1], arr[0].c[2], arr[0].c[3] } , { arr[1].c[0], ... } , ... } + + // convert to array 4x1 array of integers + auto cs = section.as_strided_span(); // { { arr[0].c }, {arr[1].c } , ... } + + CHECK(cs.bounds().index_bounds()[0] == 4); + CHECK(cs.bounds().index_bounds()[1] == 1); + + // transpose to 1x4 array + strided_bounds<2> reverse_bounds{ + {cs.bounds().index_bounds()[1] , cs.bounds().index_bounds()[0]}, + {cs.bounds().strides()[1], cs.bounds().strides()[0]} + }; + + strided_span transposed{cs.data(), cs.bounds().total_size(), reverse_bounds}; + + // slice to get a one-dimensional array of c's + strided_span result = transposed[0]; + + CHECK(result.bounds().index_bounds()[0] == 4); + CHECK_THROW(result.bounds().index_bounds()[1], fail_fast); + + int i = 0; + for (auto& num : result) + { + CHECK(num == arr[i].c); + i++; + } + + } +} + +int main(int, const char *[]) +{ + return UnitTest::RunAllTests(); +} diff --git a/tests/string_span_tests.cpp b/tests/string_span_tests.cpp index efdf0ff..f14df93 100644 --- a/tests/string_span_tests.cpp +++ b/tests/string_span_tests.cpp @@ -58,25 +58,21 @@ SUITE(string_span_tests) { cwstring_span<> v = ensure_z(stack_string); CHECK(v.length() == 5); - CHECK(v.used_length() == v.length()); } { cwstring_span<> v = stack_string; CHECK(v.length() == 6); - CHECK(v.used_length() == v.length()); } { wstring_span<> v = ensure_z(stack_string); CHECK(v.length() == 5); - CHECK(v.used_length() == v.length()); } { wstring_span<> v = stack_string; CHECK(v.length() == 6); - CHECK(v.used_length() == v.length()); } } @@ -85,7 +81,6 @@ SUITE(string_span_tests) const char* s = "Hello"; cstring_span<> v = ensure_z(s); CHECK(v.length() == 5); - CHECK(v.used_length() == v.length()); } TEST(TestConversionToConst)