From 68064d63fefc27caa5ff2036599bf2baba23736d Mon Sep 17 00:00:00 2001 From: Neil MacIntosh Date: Tue, 3 Nov 2015 19:17:11 -0800 Subject: [PATCH] Converted all tabs to spaces in array_view.h. --- include/array_view.h | 2855 +++++++++++++++++++++--------------------- 1 file changed, 1428 insertions(+), 1427 deletions(-) diff --git a/include/array_view.h b/include/array_view.h index bca973a..cbc33be 100644 --- a/include/array_view.h +++ b/include/array_view.h @@ -73,192 +73,192 @@ namespace gsl { */ namespace details { - template - struct SizeTypeTraits - { - static const SizeType max_value = std::numeric_limits::max(); - }; + template + struct SizeTypeTraits + { + 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 class index final { - static_assert(Rank > 0, "Rank must be greater than 0!"); + static_assert(Rank > 0, "Rank must be greater than 0!"); - template - friend class index; + template + friend class index; public: - static const size_t rank = Rank; - using value_type = std::ptrdiff_t; + static const size_t rank = Rank; + using value_type = std::ptrdiff_t; using size_type = value_type; - using reference = std::add_lvalue_reference_t; - using const_reference = std::add_lvalue_reference_t>; + 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 - { - std::copy(values, values + Rank, elems); - } + 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)... }) {} #else - template::value>> - constexpr index(Ts... ds) noexcept : elems{ static_cast(ds)... } + constexpr index(Ts... ds) noexcept : elems{ static_cast(ds)... } {} #endif - constexpr index(const index& other) noexcept = default; + constexpr index(const index& other) noexcept = default; - constexpr index& operator=(const index& rhs) noexcept = default; + constexpr index& operator=(const index& rhs) noexcept = default; - // Preconditions: component_idx < rank - constexpr reference operator[](size_t component_idx) - { - fail_fast_assert(component_idx < Rank, "Component index must be less than rank"); - return elems[component_idx]; - } + // Preconditions: component_idx < rank + constexpr reference operator[](size_t component_idx) + { + fail_fast_assert(component_idx < Rank, "Component index must be less than rank"); + return elems[component_idx]; + } - // Preconditions: component_idx < rank - constexpr const_reference operator[](size_t component_idx) const noexcept - { - fail_fast_assert(component_idx < Rank, "Component index must be less than rank"); - return elems[component_idx]; - } + // Preconditions: component_idx < rank + constexpr const_reference operator[](size_t component_idx) const noexcept + { + fail_fast_assert(component_idx < Rank, "Component index must be less than rank"); + return elems[component_idx]; + } - constexpr bool operator==(const index& rhs) const noexcept - { - return std::equal(elems, elems + rank, rhs.elems); - } + constexpr bool operator==(const index& rhs) const noexcept + { + return 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 - { - index ret = *this; - std::transform(ret, ret + rank, ret, std::negate{}); - return ret; - } + constexpr index operator-() const noexcept + { + index ret = *this; + std::transform(ret, ret + rank, ret, std::negate{}); + return ret; + } - constexpr index operator+(const index& rhs) const noexcept - { - index ret = *this; - ret += rhs; - return ret; - } + constexpr index operator+(const index& rhs) const noexcept + { + index ret = *this; + ret += rhs; + return ret; + } - constexpr index operator-(const index& rhs) const noexcept - { - index ret = *this; - ret -= rhs; - return ret; - } + constexpr index operator-(const index& rhs) const noexcept + { + index ret = *this; + ret -= rhs; + return ret; + } - constexpr index& operator+=(const index& rhs) noexcept - { - std::transform(elems, elems + rank, rhs.elems, elems, std::plus{}); - return *this; - } + constexpr index& operator+=(const index& rhs) noexcept + { + std::transform(elems, elems + rank, rhs.elems, elems, std::plus{}); + return *this; + } - constexpr index& operator-=(const index& rhs) noexcept - { - std::transform(elems, elems + rank, rhs.elems, elems, std::minus{}); - return *this; - } + constexpr index& operator-=(const index& rhs) noexcept + { + std::transform(elems, elems + rank, rhs.elems, elems, std::minus{}); + return *this; + } - constexpr index operator*(value_type v) const noexcept - { - index ret = *this; - ret *= v; - return ret; - } + constexpr index operator*(value_type v) const noexcept + { + index ret = *this; + ret *= v; + return ret; + } - constexpr index operator/(value_type v) const noexcept - { - index ret = *this; - ret /= v; - return ret; - } + constexpr index operator/(value_type v) const noexcept + { + index ret = *this; + ret /= v; + return ret; + } - friend constexpr index operator*(value_type v, const index& rhs) noexcept - { - return rhs * v; - } + friend constexpr index operator*(value_type v, const index& rhs) noexcept + { + return rhs * v; + } - constexpr index& operator*=(value_type v) noexcept - { - std::transform(elems, elems + rank, elems, [v](value_type x) { return std::multiplies{}(x, v); }); - return *this; - } + constexpr index& operator*=(value_type v) noexcept + { + 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); }); - return *this; - } + constexpr index& operator/=(value_type v) noexcept + { + std::transform(elems, elems + rank, elems, [v](value_type x) { return std::divides{}(x, v); }); + return *this; + } private: - value_type elems[Rank] = {}; + value_type elems[Rank] = {}; }; #ifndef _MSC_VER struct static_bounds_dynamic_range_t { - template ::value>> - constexpr operator T() const noexcept - { - return static_cast(-1); - } + template ::value>> + constexpr operator T() const noexcept + { + return static_cast(-1); + } - template ::value>> - constexpr bool operator ==(T other) const noexcept - { - return static_cast(-1) == other; - } + template ::value>> + constexpr bool operator ==(T other) const noexcept + { + return static_cast(-1) == other; + } - template ::value>> - constexpr bool operator !=(T other) const noexcept - { - return static_cast(-1) != other; - } + template ::value>> + constexpr bool operator !=(T other) const noexcept + { + return static_cast(-1) != other; + } }; template ::value>> constexpr bool operator ==(T left, static_bounds_dynamic_range_t right) noexcept { - return right == left; + return right == left; } template ::value>> constexpr bool operator !=(T left, static_bounds_dynamic_range_t right) noexcept { - return right != left; + return right != left; } constexpr static_bounds_dynamic_range_t dynamic_range{}; @@ -272,263 +272,263 @@ struct contiguous_mapping_tag : generalized_mapping_tag {}; namespace details { - template - struct LessThan - { - static const bool value = Left < Right; - }; + template + struct LessThan + { + static const bool value = Left < Right; + }; - template - struct BoundsRanges { - using size_type = std::ptrdiff_t; - static const size_type Depth = 0; - static const size_type DynamicNum = 0; - static const size_type CurrentRange = 1; - static const size_type TotalSize = 1; + template + struct BoundsRanges { + using size_type = std::ptrdiff_t; + static const size_type Depth = 0; + static const size_type DynamicNum = 0; + static const size_type CurrentRange = 1; + static const size_type TotalSize = 1; // TODO : following signature is for work around VS bug template - BoundsRanges(const OtherRange&, bool /* firstLevel */) + BoundsRanges(const OtherRange&, bool /* firstLevel */) {} - - BoundsRanges (const BoundsRanges&) = default; - BoundsRanges(const std::ptrdiff_t* const) { } - BoundsRanges() = default; + + BoundsRanges (const BoundsRanges&) = default; + BoundsRanges(const std::ptrdiff_t* const) { } + BoundsRanges() = default; - template - void serialize(T&) const + template + void serialize(T&) const {} - template - size_type linearize(const T&) const + template + size_type linearize(const T&) const { - return 0; - } + return 0; + } - template - bool contains(const T&) const + template + bool contains(const T&) const { - return 0; - } + return 0; + } - size_type totalSize() const noexcept + size_type totalSize() const noexcept { - return TotalSize; - } + return TotalSize; + } - bool operator==(const BoundsRanges&) const noexcept - { - return true; - } - }; - - 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 + 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()) - { - fail_fast_assert(0 <= *arr); - } - - BoundsRanges() : m_bound(0) {} - - template - BoundsRanges(const BoundsRanges& other, bool /* firstLevel */ = true) : - Base(static_cast&>(other), false), m_bound(other.totalSize()) - {} - - template - void serialize(T& arr) const + bool operator==(const BoundsRanges&) const noexcept { - arr[Dim] = elementNum(); - this->Base::template serialize(arr); - } + return true; + } + }; - template - size_type linearize(const T& arr) const + 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 + 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()) + { + fail_fast_assert(0 <= *arr); + } + + BoundsRanges() : m_bound(0) {} + + template + BoundsRanges(const BoundsRanges& other, bool /* firstLevel */ = true) : + Base(static_cast&>(other), false), m_bound(other.totalSize()) + {} + + template + void serialize(T& arr) const + { + arr[Dim] = elementNum(); + this->Base::template serialize(arr); + } + + template + size_type linearize(const T& arr) const { - const size_type index = this->Base::totalSize() * arr[Dim]; - fail_fast_assert(index < m_bound); - return index + this->Base::template linearize(arr); - } - - template - size_type contains(const T & arr) const + const size_type index = this->Base::totalSize() * arr[Dim]; + fail_fast_assert(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 + 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; - } - + return m_bound; + } + size_type elementNum() const noexcept { - return totalSize() / this->Base::totalSize(); - } - + 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(); - } + 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) - { - fail_fast_assert((firstLevel && totalSize() <= other.totalSize()) || totalSize() == other.totalSize()); - } - - template - void serialize(T& arr) const + bool operator == (const BoundsRanges & rhs) const noexcept { - arr[Dim] = elementNum(); - this->Base::template serialize(arr); - } + return m_bound == rhs.m_bound && static_cast(*this) == static_cast(rhs); + } + }; - template - size_type linearize(const T& arr) const + 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) + { + fail_fast_assert((firstLevel && totalSize() <= other.totalSize()) || totalSize() == other.totalSize()); + } + + template + void serialize(T& arr) const + { + arr[Dim] = elementNum(); + this->Base::template serialize(arr); + } + + template + size_type linearize(const T& arr) const { - fail_fast_assert(arr[Dim] < CurrentRange, "Index is out of range"); - return this->Base::totalSize() * arr[Dim] + this->Base::template linearize(arr); - } + fail_fast_assert(arr[Dim] < CurrentRange, "Index is out of range"); + return this->Base::totalSize() * arr[Dim] + this->Base::template linearize(arr); + } - template + 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; - } + 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 + size_type totalSize() const noexcept { - return CurrentRange * this->Base::totalSize(); - } + return CurrentRange * this->Base::totalSize(); + } size_type elementNum() const noexcept { - return CurrentRange; - } + return CurrentRange; + } - size_type elementNum(size_t dim) const noexcept + size_type elementNum(size_t dim) const noexcept { - if (dim > 0) - return this->Base::elementNum(dim - 1); - else - return elementNum(); - } + 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); - } - }; + bool operator== (const BoundsRanges& rhs) const noexcept + { + return static_cast(*this) == static_cast(rhs); + } + }; - template - struct BoundsRangeConvertible2; + template + struct BoundsRangeConvertible2; - template > - auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type) -> Ret; + template > + auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type) -> Ret; - template - auto helpBoundsRangeConvertible(SourceType, TargetType, ...) -> std::false_type; - - template - struct BoundsRangeConvertible2 : decltype(helpBoundsRangeConvertible(SourceType(), TargetType(), - std::integral_constant())) - {}; + template + 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 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 + 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 - 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(); - } - template - auto get() -> decltype(getObj(std::integral_constant())) - { - return getObj(std::integral_constant()); - } - }; + 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(); + } + template + auto get() -> decltype(getObj(std::integral_constant())) + { + return getObj(std::integral_constant()); + } + }; - template - TypeListIndexer createTypeListIndexer(const TypeChain &obj) - { - return TypeListIndexer(obj); - } + template + TypeListIndexer createTypeListIndexer(const TypeChain &obj) + { + return TypeListIndexer(obj); + } - 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) - { - ret[i] = other[i + 1]; - } - return ret; - } + 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) + { + ret[i] = other[i + 1]; + } + return ret; + } } template @@ -538,242 +538,242 @@ 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) + MyRanges m_ranges; + constexpr static_bounds(const MyRanges& range) : m_ranges(range) {} - - template - friend class static_bounds; + + template + friend class static_bounds; public: - static const size_t rank = MyRanges::Depth; - static const size_t dynamic_rank = MyRanges::DynamicNum; - static const std::ptrdiff_t static_size = MyRanges::TotalSize; + static const size_t rank = MyRanges::Depth; + static const size_t dynamic_rank = MyRanges::DynamicNum; + static const std::ptrdiff_t static_size = MyRanges::TotalSize; - using size_type = std::ptrdiff_t; - using index_type = index; + using size_type = std::ptrdiff_t; + using index_type = index; using const_index_type = std::add_const_t; using iterator = bounds_iterator; using const_iterator = bounds_iterator; using difference_type = std::ptrdiff_t; - using sliced_type = static_bounds; - using mapping_type = contiguous_mapping_tag; + using sliced_type = static_bounds; + using mapping_type = contiguous_mapping_tag; - constexpr static_bounds(const static_bounds&) = default; - - template , details::BoundsRanges >::value>> + constexpr static_bounds(const static_bounds&) = default; + + 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()) - { - fail_fast_assert((MyRanges::DynamicNum == 0 && il.size() == 1 && *il.begin() == static_size) || MyRanges::DynamicNum == il.size(), "Size of the initializer list must match the rank of the array"); - fail_fast_assert(m_ranges.totalSize() <= PTRDIFF_MAX, "Size of the range is larger than the max element of the size type"); - } - - constexpr static_bounds() = default; + constexpr static_bounds(std::initializer_list il) : m_ranges((const std::ptrdiff_t*)il.begin()) + { + fail_fast_assert((MyRanges::DynamicNum == 0 && il.size() == 1 && *il.begin() == static_size) || MyRanges::DynamicNum == il.size(), "Size of the initializer list must match the rank of the array"); + fail_fast_assert(m_ranges.totalSize() <= PTRDIFF_MAX, "Size of the range is larger than the max element of the size type"); + } + + constexpr static_bounds() = default; - constexpr static_bounds& operator=(const static_bounds& otherBounds) - { - new(&m_ranges) MyRanges (otherBounds.m_ranges); - return *this; - } + constexpr static_bounds& operator=(const static_bounds& otherBounds) + { + new(&m_ranges) MyRanges (otherBounds.m_ranges); + return *this; + } - constexpr sliced_type slice() const noexcept - { - return sliced_type{static_cast &>(m_ranges)}; - } + constexpr sliced_type slice() const noexcept + { + 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 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)"); - return details::createTypeListIndexer(m_ranges).template get().elementNum(); - } - - constexpr index_type index_bounds() const noexcept - { - size_type extents[rank] = {}; - m_ranges.serialize(extents); - return{ extents }; - } - - template - constexpr bool operator == (const static_bounds& rhs) const noexcept - { - return this->size() == rhs.size(); - } - - template - 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 end() const noexcept - { - return const_iterator(*this, this->index_bounds()); - } + 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)"); + return details::createTypeListIndexer(m_ranges).template get().elementNum(); + } + + constexpr index_type index_bounds() const noexcept + { + size_type extents[rank] = {}; + m_ranges.serialize(extents); + return{ extents }; + } + + template + constexpr bool operator == (const static_bounds& rhs) const noexcept + { + return this->size() == rhs.size(); + } + + template + 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 end() const noexcept + { + return const_iterator(*this, this->index_bounds()); + } }; template class strided_bounds { - template - friend class strided_bounds; + template + friend class strided_bounds; public: - static const size_t rank = Rank; + static const size_t rank = Rank; 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 difference_type = value_type; - using index_type = index; + using reference = std::add_lvalue_reference_t; + using const_reference = std::add_const_t; + using size_type = value_type; + using difference_type = value_type; + using index_type = index; using const_index_type = std::add_const_t; using iterator = bounds_iterator; using const_iterator = bounds_iterator; static const value_type dynamic_rank = rank; - static const value_type static_size = dynamic_range; - using sliced_type = std::conditional_t, void>; - using mapping_type = generalized_mapping_tag; + static const value_type static_size = dynamic_range; + 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(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 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 index_type strides() const noexcept + { + return m_strides; + } - constexpr size_type total_size() const noexcept - { - size_type ret = 0; - for (size_t i = 0; i < rank; ++i) - { - ret += (m_extents[i] - 1) * m_strides[i]; - } - return ret + 1; - } - + constexpr size_type total_size() const noexcept + { + size_type ret = 0; + for (size_t i = 0; i < rank; ++i) + { + ret += (m_extents[i] - 1) * m_strides[i]; + } + return ret + 1; + } + constexpr size_type size() const noexcept - { - size_type ret = 1; - for (size_t i = 0; i < rank; ++i) - { - ret *= m_extents[i]; - } - return ret; - } - + { + size_type ret = 1; + for (size_t i = 0; i < rank; ++i) + { + ret *= m_extents[i]; + } + return ret; + } + constexpr bool contains(const index_type& idx) const noexcept - { - for (size_t i = 0; i < rank; ++i) - { - if (idx[i] < 0 || idx[i] >= m_extents[i]) - return false; - } - return true; - } + { + for (size_t i = 0; i < rank; ++i) + { + if (idx[i] < 0 || idx[i] >= m_extents[i]) + return false; + } + return true; + } - constexpr size_type linearize(const index_type& idx) const noexcept - { - size_type ret = 0; - for (size_t i = 0; i < rank; i++) - { - fail_fast_assert(idx[i] < m_extents[i], "index is out of bounds of the array"); - ret += idx[i] * m_strides[i]; - } - return ret; - } - + constexpr size_type linearize(const index_type& idx) const noexcept + { + size_type ret = 0; + for (size_t i = 0; i < rank; i++) + { + fail_fast_assert(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]; - } - + { + 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) }; - } - + constexpr sliced_type slice() const + { + 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)"); - return m_extents[Dim]; - } - + constexpr size_type extent() const noexcept + { + static_assert(Dim < Rank, "dimension should be less than rank (dimension count starts from 0)"); + return m_extents[Dim]; + } + constexpr index_type index_bounds() const noexcept - { - return m_extents; - } - constexpr const_iterator begin() const noexcept - { - return const_iterator{ *this, index_type{} }; - } - - constexpr const_iterator end() const noexcept - { - return const_iterator{ *this, index_bounds() }; - } + { + return m_extents; + } + constexpr const_iterator begin() const noexcept + { + return const_iterator{ *this, index_type{} }; + } + + constexpr const_iterator end() const noexcept + { + return const_iterator{ *this, index_bounds() }; + } private: - index_type m_extents; - index_type m_strides; + index_type m_extents; + index_type m_strides; }; template @@ -787,214 +787,214 @@ template class bounds_iterator: public std::iterator { private: - using Base = std::iterator ; + using Base = std::iterator ; public: - static const size_t rank = IndexType::rank; - using typename Base::reference; - using typename Base::pointer; - using typename Base::difference_type; - using typename Base::value_type; - using index_type = value_type; - using index_size_type = typename IndexType::value_type; - template - explicit bounds_iterator(const Bounds& bnd, value_type curr) noexcept - : boundary(bnd.index_bounds()), curr(std::move(curr)) - { - static_assert(is_bounds::value, "Bounds type must be provided"); - } + static const size_t rank = IndexType::rank; + using typename Base::reference; + using typename Base::pointer; + using typename Base::difference_type; + using typename Base::value_type; + using index_type = value_type; + using index_size_type = typename IndexType::value_type; + template + explicit bounds_iterator(const Bounds& bnd, value_type curr) noexcept + : 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) - { - curr[i]++; - return *this; - } - curr[i] = 0; - } - // If we're here we've wrapped over - set to past-the-end. - curr = boundary; - return *this; - } + constexpr bounds_iterator& operator++() noexcept + { + for (size_t i = rank; i-- > 0;) + { + if (curr[i] < boundary[i] - 1) + { + curr[i]++; + return *this; + } + curr[i] = 0; + } + // If we're here we've wrapped over - set to past-the-end. + curr = boundary; + return *this; + } - constexpr bounds_iterator operator++(int) noexcept - { - auto ret = *this; - ++(*this); - return ret; - } + constexpr bounds_iterator operator++(int) noexcept + { + auto ret = *this; + ++(*this); + return ret; + } - constexpr bounds_iterator& operator--() noexcept - { - if (!less(curr, boundary)) - { - // if at the past-the-end, set to last element - for (size_t i = 0; i < rank; ++i) - { - curr[i] = boundary[i] - 1; - } - return *this; - } - for (size_t i = rank; i-- > 0;) - { - if (curr[i] >= 1) - { - curr[i]--; - return *this; - } - curr[i] = boundary[i] - 1; - } - // If we're here the preconditions were violated - // "pre: there exists s such that r == ++s" - fail_fast_assert(false); - return *this; - } + constexpr bounds_iterator& operator--() noexcept + { + if (!less(curr, boundary)) + { + // if at the past-the-end, set to last element + for (size_t i = 0; i < rank; ++i) + { + curr[i] = boundary[i] - 1; + } + return *this; + } + for (size_t i = rank; i-- > 0;) + { + if (curr[i] >= 1) + { + curr[i]--; + return *this; + } + curr[i] = boundary[i] - 1; + } + // If we're here the preconditions were violated + // "pre: there exists s such that r == ++s" + fail_fast_assert(false); + return *this; + } - constexpr bounds_iterator operator--(int) noexcept - { - auto ret = *this; - --(*this); - return ret; - } + constexpr bounds_iterator operator--(int) noexcept + { + auto ret = *this; + --(*this); + return ret; + } - constexpr bounds_iterator operator+(difference_type n) const noexcept - { - bounds_iterator ret{ *this }; - return ret += n; - } + constexpr bounds_iterator operator+(difference_type n) const noexcept + { + bounds_iterator ret{ *this }; + return ret += n; + } - constexpr bounds_iterator& operator+=(difference_type n) noexcept - { - auto linear_idx = linearize(curr) + n; - std::remove_const_t stride = 0; - stride[rank - 1] = 1; - for (size_t i = rank - 1; i-- > 0;) - { - stride[i] = stride[i + 1] * boundary[i + 1]; - } - for (size_t i = 0; i < rank; ++i) - { - curr[i] = linear_idx / stride[i]; - linear_idx = linear_idx % stride[i]; - } - fail_fast_assert(!less(curr, index_type{}) && !less(boundary, curr), "index is out of bounds of the array"); - return *this; - } + constexpr bounds_iterator& operator+=(difference_type n) noexcept + { + auto linear_idx = linearize(curr) + n; + std::remove_const_t stride = 0; + stride[rank - 1] = 1; + for (size_t i = rank - 1; i-- > 0;) + { + stride[i] = stride[i + 1] * boundary[i + 1]; + } + for (size_t i = 0; i < rank; ++i) + { + curr[i] = linear_idx / stride[i]; + linear_idx = linear_idx % stride[i]; + } + fail_fast_assert(!less(curr, index_type{}) && !less(boundary, curr), "index is out of bounds of the array"); + return *this; + } - constexpr bounds_iterator operator-(difference_type n) const noexcept - { - bounds_iterator ret{ *this }; - return ret -= n; - } + constexpr bounds_iterator operator-(difference_type n) const noexcept + { + 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 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 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 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); - } + void swap(bounds_iterator& rhs) noexcept + { + std::swap(boundary, rhs.boundary); + std::swap(curr, rhs.curr); + } private: - constexpr bool less(index_type& one, index_type& other) const noexcept - { - for (size_t i = 0; i < rank; ++i) - { - if (one[i] < other[i]) - return true; - } - return false; - } + constexpr bool less(index_type& one, index_type& other) const noexcept + { + for (size_t i = 0; i < rank; ++i) + { + if (one[i] < other[i]) + return true; + } + return false; + } - constexpr index_size_type linearize(const value_type& idx) const noexcept - { - // TODO: Smarter impl. - // Check if past-the-end - index_size_type multiplier = 1; - index_size_type res = 0; - if (!less(idx, boundary)) - { - res = 1; - for (size_t i = rank; i-- > 0;) - { - res += (idx[i] - 1) * multiplier; - multiplier *= boundary[i]; - } - } - else - { - for (size_t i = rank; i-- > 0;) - { - res += idx[i] * multiplier; - multiplier *= boundary[i]; - } - } - return res; - } + constexpr index_size_type linearize(const value_type& idx) const noexcept + { + // TODO: Smarter impl. + // Check if past-the-end + index_size_type multiplier = 1; + index_size_type res = 0; + if (!less(idx, boundary)) + { + res = 1; + for (size_t i = rank; i-- > 0;) + { + res += (idx[i] - 1) * multiplier; + multiplier *= boundary[i]; + } + } + else + { + for (size_t i = rank; i-- > 0;) + { + res += idx[i] * multiplier; + multiplier *= boundary[i]; + } + } + return res; + } - value_type boundary; - std::remove_const_t curr; + value_type boundary; + std::remove_const_t curr; }; template bounds_iterator operator+(typename bounds_iterator::difference_type n, const bounds_iterator& rhs) noexcept { - return rhs + n; + return rhs + n; } // @@ -1002,35 +1002,35 @@ bounds_iterator operator+(typename bounds_iterator::differ // namespace details { - template - constexpr std::enable_if_t::value, typename Bounds::index_type> make_stride(const Bounds& bnd) noexcept - { - return bnd.strides(); - } + template + constexpr std::enable_if_t::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 - { - auto extents = bnd.index_bounds(); - typename Bounds::size_type stride[Bounds::rank] = {}; + // 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 + { + auto extents = bnd.index_bounds(); + typename Bounds::size_type stride[Bounds::rank] = {}; - stride[Bounds::rank - 1] = 1; - for (size_t i = 1; i < Bounds::rank; ++i) - { - stride[Bounds::rank - i - 1] = stride[Bounds::rank - i] * extents[Bounds::rank - i]; - } - return{ stride }; - } + stride[Bounds::rank - 1] = 1; + for (size_t i = 1; i < Bounds::rank; ++i) + { + stride[Bounds::rank - i - 1] = stride[Bounds::rank - i] * extents[Bounds::rank - i]; + } + return{ stride }; + } - template - 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"); - fail_fast_assert(src.size() == dest.size()); - } + template + 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"); + fail_fast_assert(src.size() == dest.size()); + } } // namespace details @@ -1045,181 +1045,181 @@ template class basic_array_view { public: - static const size_t rank = BoundsType::rank; - using bounds_type = BoundsType; - using size_type = typename bounds_type::size_type; - using index_type = typename bounds_type::index_type; - using value_type = ValueType; - using const_value_type = std::add_const_t; - using pointer = ValueType*; - using reference = ValueType&; - using iterator = std::conditional_t::value, contiguous_array_view_iterator, general_array_view_iterator>; - using const_iterator = std::conditional_t::value, contiguous_array_view_iterator>, general_array_view_iterator>>; - using reverse_iterator = std::reverse_iterator; - using const_reverse_iterator = std::reverse_iterator; - using sliced_type = std::conditional_t>; + static const size_t rank = BoundsType::rank; + using bounds_type = BoundsType; + using size_type = typename bounds_type::size_type; + using index_type = typename bounds_type::index_type; + using value_type = ValueType; + using const_value_type = std::add_const_t; + using pointer = ValueType*; + using reference = ValueType&; + using iterator = std::conditional_t::value, contiguous_array_view_iterator, general_array_view_iterator>; + using const_iterator = std::conditional_t::value, contiguous_array_view_iterator>, general_array_view_iterator>>; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; + using sliced_type = std::conditional_t>; private: - pointer m_pdata; - bounds_type m_bounds; + pointer m_pdata; + bounds_type m_bounds; public: - constexpr bounds_type bounds() const noexcept - { - return m_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(); - } - constexpr size_type size() const noexcept - { - return m_bounds.size(); - } - constexpr reference operator[](const index_type& idx) const - { - return m_pdata[m_bounds.linearize(idx)]; - } - constexpr pointer data() const noexcept - { - return m_pdata; - } - template 1), typename Ret = std::enable_if_t> - constexpr Ret operator[](size_type idx) const - { - fail_fast_assert(idx < m_bounds.size(), "index is out of bounds of the array"); - const size_type ridx = idx * m_bounds.stride(); + constexpr bounds_type bounds() const noexcept + { + return m_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(); + } + constexpr size_type size() const noexcept + { + return m_bounds.size(); + } + constexpr reference operator[](const index_type& idx) const + { + return m_pdata[m_bounds.linearize(idx)]; + } + constexpr pointer data() const noexcept + { + return m_pdata; + } + template 1), typename Ret = std::enable_if_t> + constexpr Ret operator[](size_type idx) const + { + fail_fast_assert(idx < m_bounds.size(), "index is out of bounds of the array"); + const size_type ridx = idx * m_bounds.stride(); - fail_fast_assert(ridx < m_bounds.total_size(), "index is out of bounds of the underlying data"); - return Ret {m_pdata + ridx, m_bounds.slice()}; - } + fail_fast_assert(ridx < m_bounds.total_size(), "index is out of bounds of the underlying data"); + return Ret {m_pdata + ridx, m_bounds.slice()}; + } - constexpr operator bool () const noexcept - { - return m_pdata != nullptr; - } + constexpr operator bool () const noexcept + { + return m_pdata != nullptr; + } - constexpr iterator begin() const - { - return iterator {this, true}; - } - constexpr iterator end() const - { - return iterator {this, false}; - } - constexpr const_iterator cbegin() const - { - return const_iterator {reinterpret_cast *>(this), true}; - } - constexpr const_iterator cend() const - { - return const_iterator {reinterpret_cast *>(this), false}; - } + constexpr iterator begin() const + { + return iterator {this, true}; + } + constexpr iterator end() const + { + return iterator {this, false}; + } + constexpr const_iterator cbegin() const + { + return const_iterator {reinterpret_cast *>(this), true}; + } + constexpr const_iterator cend() const + { + return const_iterator {reinterpret_cast *>(this), false}; + } - constexpr reverse_iterator rbegin() const - { - return reverse_iterator {end()}; - } - constexpr reverse_iterator rend() const - { - return reverse_iterator {begin()}; - } - constexpr const_reverse_iterator crbegin() const - { - return const_reverse_iterator {cend()}; - } - constexpr const_reverse_iterator crend() const - { - return const_reverse_iterator {cbegin()}; - } + 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 basic_array_view & 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 basic_array_view & 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 basic_array_view & other) const noexcept - { - return !(*this == other); - } + template , std::remove_cv_t>::value>> + constexpr bool operator!= (const basic_array_view & other) const noexcept + { + return !(*this == other); + } - template , std::remove_cv_t>::value>> - constexpr bool operator< (const basic_array_view & 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 basic_array_view & 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 basic_array_view & other) const noexcept - { - return !(other < *this); - } + template , std::remove_cv_t>::value>> + constexpr bool operator<= (const basic_array_view & other) const noexcept + { + return !(other < *this); + } - template , std::remove_cv_t>::value>> - constexpr bool operator> (const basic_array_view & other) const noexcept - { - return (other < *this); - } + template , std::remove_cv_t>::value>> + constexpr bool operator> (const basic_array_view & other) const noexcept + { + return (other < *this); + } - template , std::remove_cv_t>::value>> - constexpr bool operator>= (const basic_array_view & other) const noexcept - { - return !(*this < other); - } + template , std::remove_cv_t>::value>> + constexpr bool operator>= (const basic_array_view & other) const noexcept + { + return !(*this < other); + } public: - template ::value - && std::is_convertible::value>> - constexpr basic_array_view(const basic_array_view & other ) noexcept - : m_pdata(other.m_pdata), m_bounds(other.m_bounds) - { - } + template ::value + && std::is_convertible::value>> + constexpr basic_array_view(const basic_array_view & other ) noexcept + : m_pdata(other.m_pdata), m_bounds(other.m_bounds) + { + } protected: - constexpr basic_array_view(pointer data, bounds_type bound) noexcept - : m_pdata(data) - , m_bounds(std::move(bound)) - { - fail_fast_assert((m_bounds.size() > 0 && data != nullptr) || m_bounds.size() == 0); - } - template - constexpr basic_array_view(T *data, std::enable_if_t>::value, bounds_type> bound) noexcept - : m_pdata(reinterpret_cast(data)) - , m_bounds(std::move(bound)) - { - fail_fast_assert((m_bounds.size() > 0 && data != nullptr) || m_bounds.size() == 0); - } - template - constexpr basic_array_view as_array_view(const DestBounds &bounds) - { - details::verifyBoundsReshape(m_bounds, bounds); - return {m_pdata, bounds}; - } + constexpr basic_array_view(pointer data, bounds_type bound) noexcept + : m_pdata(data) + , m_bounds(std::move(bound)) + { + fail_fast_assert((m_bounds.size() > 0 && data != nullptr) || m_bounds.size() == 0); + } + template + constexpr basic_array_view(T *data, std::enable_if_t>::value, bounds_type> bound) noexcept + : m_pdata(reinterpret_cast(data)) + , m_bounds(std::move(bound)) + { + fail_fast_assert((m_bounds.size() > 0 && data != nullptr) || m_bounds.size() == 0); + } + template + constexpr basic_array_view as_array_view(const DestBounds &bounds) + { + details::verifyBoundsReshape(m_bounds, bounds); + return {m_pdata, bounds}; + } private: - friend iterator; - friend const_iterator; - template - friend class basic_array_view; + friend iterator; + friend const_iterator; + template + friend class basic_array_view; }; template struct dim { - static const std::ptrdiff_t value = DimSize; + static const std::ptrdiff_t value = DimSize; }; template <> struct dim { - static const std::ptrdiff_t value = dynamic_range; - const std::ptrdiff_t dvalue; - dim(std::ptrdiff_t size) : dvalue(size) {} + static const std::ptrdiff_t value = dynamic_range; + const std::ptrdiff_t dvalue; + dim(std::ptrdiff_t size) : dvalue(size) {} }; template @@ -1230,89 +1230,89 @@ class strided_array_view; namespace details { - template - struct ArrayViewTypeTraits - { - using value_type = T; - using size_type = size_t; - }; + template + struct ArrayViewTypeTraits + { + using value_type = T; + using size_type = size_t; + }; - template - struct ArrayViewTypeTraits::type> - { - using value_type = typename Traits::array_view_traits::value_type; - using size_type = typename Traits::array_view_traits::size_type; - }; + template + struct ArrayViewTypeTraits::type> + { + using value_type = typename Traits::array_view_traits::value_type; + using size_type = typename Traits::array_view_traits::size_type; + }; - template - struct ArrayViewArrayTraits { - using type = array_view; - using value_type = T; - using bounds_type = static_bounds; - using pointer = T*; - using reference = T&; - }; - template - struct ArrayViewArrayTraits : ArrayViewArrayTraits {}; + template + struct ArrayViewArrayTraits { + using type = array_view; + using value_type = T; + using bounds_type = static_bounds; + using pointer = T*; + using reference = T&; + }; + template + struct ArrayViewArrayTraits : ArrayViewArrayTraits {}; - template - BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::true_type) // dynamic size - { - fail_fast_assert(totalSize <= PTRDIFF_MAX); - return BoundsType{totalSize}; - } - template - BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::false_type) // static size - { - fail_fast_assert(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()); - } - - struct Sep{}; - - template - T static_as_array_view_helper(Sep, Args... args) - { - return T{static_cast(args)...}; - } - template - std::enable_if_t>::value && !std::is_same::value, T> static_as_array_view_helper(Arg, Args... args) - { - return static_as_array_view_helper(args...); - } - template - T static_as_array_view_helper(dim val, Args ... args) - { - return static_as_array_view_helper(args..., val.dvalue); - } + template + BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::true_type) // dynamic size + { + fail_fast_assert(totalSize <= PTRDIFF_MAX); + return BoundsType{totalSize}; + } + template + BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::false_type) // static size + { + fail_fast_assert(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()); + } + + struct Sep{}; + + template + T static_as_array_view_helper(Sep, Args... args) + { + return T{static_cast(args)...}; + } + template + std::enable_if_t>::value && !std::is_same::value, T> static_as_array_view_helper(Arg, Args... args) + { + return static_as_array_view_helper(args...); + } + template + T static_as_array_view_helper(dim val, Args ... args) + { + return static_as_array_view_helper(args..., val.dvalue); + } - template - struct static_as_array_view_static_bounds_helper - { - using type = static_bounds<(Dimensions::value)...>; - }; + template + struct static_as_array_view_static_bounds_helper + { + using type = static_bounds<(Dimensions::value)...>; + }; - template - struct is_array_view_oracle : std::false_type - {}; - - template - struct is_array_view_oracle> : std::true_type - {}; - - template - struct is_array_view_oracle> : std::true_type - {}; - template - struct is_array_view : is_array_view_oracle> - {}; + struct is_array_view_oracle : std::false_type + {}; + + template + struct is_array_view_oracle> : std::true_type + {}; + + template + struct is_array_view_oracle> : std::true_type + {}; + + template + struct is_array_view : is_array_view_oracle> + {}; } @@ -1320,265 +1320,266 @@ namespace details template class array_view : public basic_array_view > { - template - friend class array_view; + template + friend class array_view; - using Base = basic_array_view>; + using Base = basic_array_view>; public: - using typename Base::bounds_type; - using typename Base::size_type; - using typename Base::pointer; - using typename Base::value_type; - using typename Base::index_type; - using typename Base::iterator; - using typename Base::const_iterator; - using typename Base::reference; - using Base::rank; + using typename Base::bounds_type; + using typename Base::size_type; + using typename Base::pointer; + using typename Base::value_type; + using typename Base::index_type; + using typename Base::iterator; + using typename Base::const_iterator; + using typename Base::reference; + using Base::rank; public: - // basic + // basic constexpr array_view(pointer ptr, size_type size) : Base(ptr, bounds_type{ size }) {} constexpr array_view(pointer ptr, bounds_type bounds) : Base(ptr, std::move(bounds)) {} - constexpr array_view(std::nullptr_t) : Base(nullptr, bounds_type{}) - {} + constexpr array_view(std::nullptr_t) : Base(nullptr, bounds_type{}) + {} - constexpr array_view(std::nullptr_t, size_type size) : Base(nullptr, bounds_type{}) - { - fail_fast_assert(size == 0); - } + constexpr array_view(std::nullptr_t, size_type size) : Base(nullptr, bounds_type{}) + { + fail_fast_assert(size == 0); + } - // default - template > - constexpr array_view() : Base(nullptr, bounds_type()) - {} + // default + template > + constexpr array_view() : Base(nullptr, bounds_type()) + {} - // from n-dimensions dynamic array (e.g. new int[m][4]) (precedence will be lower than the 1-dimension pointer) - template + // 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>*/> - constexpr array_view(T* const& data, size_type size) : Base(data, typename Helper::bounds_type{size}) - {} + constexpr array_view(T* const& data, size_type size) : Base(data, typename Helper::bounds_type{size}) + {} - // from n-dimensions static array - template , + // from n-dimensions static array + template , typename = std::enable_if_t::value>> - constexpr array_view (T (&arr)[N]) : Base(arr, typename Helper::bounds_type()) - {} + constexpr array_view (T (&arr)[N]) : Base(arr, typename Helper::bounds_type()) + {} - // from n-dimensions static array with size - template , - typename = std::enable_if_t::value> + // from n-dimensions static array with size + template , + typename = std::enable_if_t::value> > constexpr array_view(T(&arr)[N], size_type size) : Base(arr, typename Helper::bounds_type{size}) - { - fail_fast_assert(size <= N); - } + { + fail_fast_assert(size <= N); + } - // from std array - template , typename Base::bounds_type>::value> > - constexpr array_view (std::array, N> & arr) : Base(arr.data(), static_bounds()) - {} + constexpr array_view (std::array, N> & arr) : Base(arr.data(), static_bounds()) + {} - template , typename Base::bounds_type>::value && std::is_const::value> > - constexpr array_view (const std::array, N> & arr) : Base(arr.data(), static_bounds()) - {} + constexpr array_view (const std::array, N> & arr) : Base(arr.data(), static_bounds()) + {} - // from begin, end pointers. We don't provide iterator pair since no way to guarantee the contiguity - template ::value - && details::LessThan::value> + // from begin, end pointers. We don't provide iterator pair since no way to guarantee the contiguity + template ::value + && details::LessThan::value> > // remove literal 0 case - constexpr array_view (pointer begin, Ptr end) : Base(begin, details::newBoundsHelper(static_cast(end) - begin)) - {} + constexpr array_view (pointer begin, Ptr end) : Base(begin, details::newBoundsHelper(static_cast(end) - begin)) + {} - // from containers. It must has .size() and .data() two function signatures - template ::value - && std::is_convertible::value - && std::is_same().size(), *std::declval().data())>, DataType>::value> - > - constexpr array_view (Cont& cont) : Base(static_cast(cont.data()), details::newBoundsHelper(cont.size())) - {} + // from containers. It must has .size() and .data() two function signatures + template ::value + && std::is_convertible::value + && std::is_same().size(), *std::declval().data())>, DataType>::value> + > + constexpr array_view (Cont& cont) : Base(static_cast(cont.data()), details::newBoundsHelper(cont.size())) + {} - constexpr array_view(const array_view &) = default; + constexpr array_view(const array_view &) = default; - // convertible - template >, - typename OtherBaseType = basic_array_view>, - typename Dummy = std::enable_if_t::value> - > - constexpr array_view(const array_view &av) + // convertible + template >, + typename OtherBaseType = basic_array_view>, + typename Dummy = std::enable_if_t::value> + > + constexpr array_view(const array_view &av) : Base(static_cast::Base&>(av)) {} - // reshape + // reshape // DimCount here is a workaround for a bug in MSVC 2015 template 0)>> constexpr array_view as_array_view(Dimensions2... dims) - { - using BoundsType = typename array_view::bounds_type; - auto tobounds = details::static_as_array_view_helper(dims..., details::Sep{}); - details::verifyBoundsReshape(this->bounds(), tobounds); - return {this->data(), tobounds}; - } + { + using BoundsType = typename array_view::bounds_type; + auto tobounds = details::static_as_array_view_helper(dims..., details::Sep{}); + details::verifyBoundsReshape(this->bounds(), tobounds); + return {this->data(), tobounds}; + } - // to bytes array - template >::value> - auto as_bytes() const noexcept -> array_view - { - static_assert(Enabled, "The value_type of array_view must be standarded layout"); - return { reinterpret_cast(this->data()), this->bytes() }; - } + // to bytes array + template >::value> + auto as_bytes() const noexcept -> array_view + { + static_assert(Enabled, "The value_type of array_view must be standarded layout"); + return { reinterpret_cast(this->data()), this->bytes() }; + } - template >::value> - auto as_writeable_bytes() const noexcept -> array_view - { - static_assert(Enabled, "The value_type of array_view must be standarded layout"); - return { reinterpret_cast(this->data()), this->bytes() }; - } + template >::value> + auto as_writeable_bytes() const noexcept -> array_view + { + static_assert(Enabled, "The value_type of array_view must be standarded layout"); + return { reinterpret_cast(this->data()), this->bytes() }; + } // from bytes array - template::value, typename = std::enable_if_t> - constexpr auto as_array_view() const noexcept -> array_view(static_cast(Base::bounds_type::static_size) / sizeof(U)) : dynamic_range)> - { - static_assert(std::is_standard_layout::value && (Base::bounds_type::static_size == dynamic_range || Base::bounds_type::static_size % static_cast(sizeof(U)) == 0), - "Target type must be standard layout and its size must match the byte array size"); - fail_fast_assert((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_array_view() const noexcept -> array_view(static_cast(Base::bounds_type::static_size) / sizeof(U)) : dynamic_range)> + { + static_assert(std::is_standard_layout::value && (Base::bounds_type::static_size == dynamic_range || Base::bounds_type::static_size % static_cast(sizeof(U)) == 0), + "Target type must be standard layout and its size must match the byte array size"); + fail_fast_assert((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_array_view() const noexcept -> array_view(static_cast(Base::bounds_type::static_size) / sizeof(U)) : dynamic_range)> - { - static_assert(std::is_standard_layout::value && (Base::bounds_type::static_size == dynamic_range || Base::bounds_type::static_size % static_cast(sizeof(U)) == 0), - "Target type must be standard layout and its size must match the byte array size"); - fail_fast_assert((this->bytes() % sizeof(U)) == 0); - return { reinterpret_cast(this->data()), this->bytes() / static_cast(sizeof(U)) }; - } + template::value, typename = std::enable_if_t> + constexpr auto as_array_view() const noexcept -> array_view(static_cast(Base::bounds_type::static_size) / sizeof(U)) : dynamic_range)> + { + static_assert(std::is_standard_layout::value && (Base::bounds_type::static_size == dynamic_range || Base::bounds_type::static_size % static_cast(sizeof(U)) == 0), + "Target type must be standard layout and its size must match the byte array size"); + fail_fast_assert((this->bytes() % sizeof(U)) == 0); + return { reinterpret_cast(this->data()), this->bytes() / static_cast(sizeof(U)) }; + } - // section on linear space - template - constexpr array_view first() const noexcept - { - static_assert(bounds_type::static_size == dynamic_range || Count <= bounds_type::static_size, "Index is out of bound"); - fail_fast_assert(bounds_type::static_size != dynamic_range || Count <= this->size()); // ensures we only check condition when needed - return { this->data(), Count }; - } + // section on linear space + template + constexpr array_view first() const noexcept + { + static_assert(bounds_type::static_size == dynamic_range || Count <= bounds_type::static_size, "Index is out of bound"); + fail_fast_assert(bounds_type::static_size != dynamic_range || Count <= this->size()); // ensures we only check condition when needed + return { this->data(), Count }; + } - constexpr array_view first(size_type count) const noexcept - { - fail_fast_assert(count <= this->size()); - return { this->data(), count }; - } + constexpr array_view first(size_type count) const noexcept + { + fail_fast_assert(count <= this->size()); + return { this->data(), count }; + } - template - constexpr array_view last() const noexcept - { - static_assert(bounds_type::static_size == dynamic_range || Count <= bounds_type::static_size, "Index is out of bound"); - fail_fast_assert(bounds_type::static_size != dynamic_range || Count <= this->size()); - return { this->data() + this->size() - Count, Count }; - } + template + constexpr array_view last() const noexcept + { + static_assert(bounds_type::static_size == dynamic_range || Count <= bounds_type::static_size, "Index is out of bound"); + fail_fast_assert(bounds_type::static_size != dynamic_range || Count <= this->size()); + return { this->data() + this->size() - Count, Count }; + } - constexpr array_view last(size_type count) const noexcept - { - fail_fast_assert(count <= this->size()); - return { this->data() + this->size() - count, count }; - } + constexpr array_view last(size_type count) const noexcept + { + fail_fast_assert(count <= this->size()); + return { this->data() + this->size() - count, count }; + } - template - constexpr array_view sub() 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"); - fail_fast_assert(bounds_type::static_size != dynamic_range || ((Offset == 0 || Offset <= this->size()) && Offset + Count <= this->size())); - return { this->data() + Offset, Count }; - } + template + constexpr array_view sub() 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"); + fail_fast_assert(bounds_type::static_size != dynamic_range || ((Offset == 0 || Offset <= this->size()) && Offset + Count <= this->size())); + return { this->data() + Offset, Count }; + } - constexpr array_view sub(size_type offset, size_type count = dynamic_range) const noexcept - { - fail_fast_assert((offset == 0 || offset <= this->size()) && (count == dynamic_range || (offset + count) <= this->size())); - return { this->data() + offset, count == dynamic_range ? this->length() - offset : count }; - } + constexpr array_view sub(size_type offset, size_type count = dynamic_range) const noexcept + { + fail_fast_assert((offset == 0 || offset <= this->size()) && (count == dynamic_range || (offset + count) <= this->size())); + return { this->data() + offset, count == dynamic_range ? this->length() - offset : count }; + } - // size - constexpr size_type length() const noexcept - { - return this->size(); - } + // size + constexpr size_type length() const noexcept + { + return this->size(); + } - constexpr size_type used_length() const noexcept - { - return length(); - } + constexpr size_type used_length() const noexcept + { + return length(); + } - constexpr size_type bytes() const noexcept - { - return sizeof(value_type) * this->size(); - } + constexpr size_type bytes() const noexcept + { + return sizeof(value_type) * this->size(); + } - constexpr size_type used_bytes() const noexcept - { - return bytes(); - } + constexpr size_type used_bytes() const noexcept + { + return bytes(); + } - // section - constexpr strided_array_view section(index_type origin, index_type extents) const - { - size_type size = this->bounds().total_size() - this->bounds().linearize(origin); - return{ &this->operator[](origin), size, strided_bounds {extents, details::make_stride(Base::bounds())} }; - } - - constexpr reference operator[](const index_type& idx) const - { - return Base::operator[](idx); - } - - template 1), typename Dummy = std::enable_if_t> - constexpr array_view operator[](size_type idx) const - { - auto ret = Base::operator[](idx); - return{ ret.data(), ret.bounds() }; - } + // section + constexpr strided_array_view section(index_type origin, index_type extents) const + { + size_type size = this->bounds().total_size() - this->bounds().linearize(origin); + return{ &this->operator[](origin), size, strided_bounds {extents, details::make_stride(Base::bounds())} }; + } + + constexpr reference operator[](const index_type& idx) const + { + return Base::operator[](idx); + } + + template 1), typename Dummy = std::enable_if_t> + constexpr array_view operator[](size_type idx) const + { + auto ret = Base::operator[](idx); + return{ ret.data(), ret.bounds() }; + } - using Base::operator==; - using Base::operator!=; - using Base::operator<; - using Base::operator<=; - using Base::operator>; - using Base::operator>=; + using Base::operator==; + using Base::operator!=; + using Base::operator<; + using Base::operator<=; + using Base::operator>; + using Base::operator>=; }; template constexpr auto as_array_view(T* const& ptr, dim... args) -> array_view, Dimensions...> { - return {reinterpret_cast*>(ptr), details::static_as_array_view_helper>(args..., details::Sep{})}; + return {reinterpret_cast*>(ptr), details::static_as_array_view_helper>(args..., details::Sep{})}; } template constexpr auto as_array_view (T* arr, std::ptrdiff_t len) -> typename details::ArrayViewArrayTraits::type { - return {reinterpret_cast*>(arr), len}; + return {reinterpret_cast*>(arr), len}; } template constexpr auto as_array_view (T (&arr)[N]) -> typename details::ArrayViewArrayTraits::type { - return {arr}; + return {arr}; } template constexpr array_view as_array_view(const std::array &arr) { - return {arr}; + return {arr}; } template @@ -1587,374 +1588,374 @@ constexpr array_view as_array_view(const std::array &&) = dele template constexpr array_view as_array_view(std::array &arr) { - return {arr}; + return {arr}; } template constexpr array_view as_array_view(T *begin, T *end) { - return {begin, end}; + return {begin, end}; } template constexpr auto as_array_view(Cont &arr) -> std::enable_if_t>::value, - array_view, dynamic_range>> + array_view, dynamic_range>> { fail_fast_assert(arr.size() < PTRDIFF_MAX); - return {arr.data(), static_cast(arr.size())}; + return {arr.data(), static_cast(arr.size())}; } template constexpr auto as_array_view(Cont &&arr) -> std::enable_if_t>::value, - array_view, dynamic_range>> = delete; + array_view, dynamic_range>> = delete; template class strided_array_view : public basic_array_view> { - using Base = basic_array_view>; + using Base = basic_array_view>; - template - friend class strided_array_view; + template + friend class strided_array_view; public: - using Base::rank; - using typename Base::bounds_type; - using typename Base::size_type; - using typename Base::pointer; - using typename Base::value_type; - using typename Base::index_type; - using typename Base::iterator; - using typename Base::const_iterator; - using typename Base::reference; - - // from static array of size N - template - strided_array_view(value_type(&values)[N], bounds_type bounds) : Base(values, std::move(bounds)) - { - fail_fast_assert(this->bounds().total_size() <= N, "Bounds cross data boundaries"); - } + using Base::rank; + using typename Base::bounds_type; + using typename Base::size_type; + using typename Base::pointer; + using typename Base::value_type; + using typename Base::index_type; + using typename Base::iterator; + using typename Base::const_iterator; + using typename Base::reference; + + // from static array of size N + template + strided_array_view(value_type(&values)[N], bounds_type bounds) : Base(values, std::move(bounds)) + { + fail_fast_assert(this->bounds().total_size() <= N, "Bounds cross data boundaries"); + } - // from raw data - strided_array_view(pointer ptr, size_type size, bounds_type bounds): Base(ptr, std::move(bounds)) - { - fail_fast_assert(this->bounds().total_size() <= size, "Bounds cross data boundaries"); - } + // from raw data + strided_array_view(pointer ptr, size_type size, bounds_type bounds): Base(ptr, std::move(bounds)) + { + fail_fast_assert(this->bounds().total_size() <= size, "Bounds cross data boundaries"); + } - // from array view - template > - strided_array_view(array_view av, bounds_type bounds) : Base(av.data(), std::move(bounds)) - { - fail_fast_assert(this->bounds().total_size() <= av.bounds().total_size(), "Bounds cross data boundaries"); - } - - // convertible - template >, - typename OtherBaseType = basic_array_view>, - typename Dummy = std::enable_if_t::value> - > + // from array view + template > + strided_array_view(array_view av, bounds_type bounds) : Base(av.data(), std::move(bounds)) + { + fail_fast_assert(this->bounds().total_size() <= av.bounds().total_size(), "Bounds cross data boundaries"); + } + + // convertible + template >, + typename OtherBaseType = basic_array_view>, + typename Dummy = std::enable_if_t::value> + > constexpr strided_array_view(const strided_array_view &av) : Base(static_cast::Base &>(av)) // static_cast is required {} - // convert from bytes - template - strided_array_view::value, OtherValueType>::type, rank> as_strided_array_view() 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)); + // convert from bytes + template + strided_array_view::value, OtherValueType>::type, rank> as_strided_array_view() 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)); - 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)} }; - } + 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)} }; + } - strided_array_view 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(Base::bounds())}}; - } + strided_array_view 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(Base::bounds())}}; + } - constexpr reference operator[](const index_type& idx) const - { - return Base::operator[](idx); - } + constexpr reference operator[](const index_type& idx) const + { + return Base::operator[](idx); + } - template 1), typename Dummy = std::enable_if_t> - constexpr strided_array_view operator[](size_type idx) const - { - auto ret = Base::operator[](idx); - return{ ret.data(), ret.bounds().total_size(), ret.bounds() }; - } + template 1), typename Dummy = std::enable_if_t> + constexpr strided_array_view operator[](size_type idx) const + { + auto ret = Base::operator[](idx); + return{ ret.data(), ret.bounds().total_size(), ret.bounds() }; + } private: - static index_type resize_extent(const index_type& extent, std::ptrdiff_t d) - { - fail_fast_assert(extent[rank - 1] >= d && (extent[rank-1] % d == 0), "The last dimension of the array needs to contain a multiple of new type elements"); + static index_type resize_extent(const index_type& extent, std::ptrdiff_t d) + { + fail_fast_assert(extent[rank - 1] >= d && (extent[rank-1] % d == 0), "The last dimension of the array needs to contain a multiple of new type elements"); - index_type ret = extent; - ret[rank - 1] /= d; + index_type ret = extent; + ret[rank - 1] /= d; - return ret; - } + return ret; + } - template > - static index_type resize_stride(const index_type& strides, std::ptrdiff_t , void * = 0) - { - fail_fast_assert(strides[rank - 1] == 1, "Only strided arrays with regular strides can be resized"); + template > + static index_type resize_stride(const index_type& strides, std::ptrdiff_t , void * = 0) + { + fail_fast_assert(strides[rank - 1] == 1, "Only strided arrays with regular strides can be resized"); - return strides; - } + return strides; + } - template 1), typename Dummy = std::enable_if_t> - static index_type resize_stride(const index_type& strides, std::ptrdiff_t d) - { - fail_fast_assert(strides[rank - 1] == 1, "Only strided arrays with regular strides can be resized"); - fail_fast_assert(strides[rank - 2] >= d && (strides[rank - 2] % d == 0), "The strides must have contiguous chunks of memory that can contain a multiple of new type elements"); + template 1), typename Dummy = std::enable_if_t> + static index_type resize_stride(const index_type& strides, std::ptrdiff_t d) + { + fail_fast_assert(strides[rank - 1] == 1, "Only strided arrays with regular strides can be resized"); + fail_fast_assert(strides[rank - 2] >= d && (strides[rank - 2] % d == 0), "The strides must have contiguous chunks of memory that can contain a multiple of new type elements"); - for (size_t i = rank - 1; i > 0; --i) - fail_fast_assert((strides[i-1] >= strides[i]) && (strides[i-1] % strides[i] == 0), "Only strided arrays with regular strides can be resized"); + for (size_t i = rank - 1; i > 0; --i) + fail_fast_assert((strides[i-1] >= strides[i]) && (strides[i-1] % strides[i] == 0), "Only strided arrays with regular strides can be resized"); - index_type ret = strides / d; - ret[rank - 1] = 1; + index_type ret = strides / d; + ret[rank - 1] = 1; - return ret; - } + return ret; + } }; template class contiguous_array_view_iterator : public std::iterator { - using Base = std::iterator; + using Base = std::iterator; public: - using typename Base::reference; - using typename Base::pointer; - using typename Base::difference_type; + using typename Base::reference; + using typename Base::pointer; + using typename Base::difference_type; private: - template - friend class basic_array_view; + template + friend class basic_array_view; pointer m_pdata; - const ArrayView * m_validator; - void validateThis() const - { - fail_fast_assert(m_pdata >= m_validator->m_pdata && m_pdata < m_validator->m_pdata + m_validator->size(), "iterator is out of range of the array"); - } - contiguous_array_view_iterator (const ArrayView *container, bool isbegin) : - m_pdata(isbegin ? container->m_pdata : container->m_pdata + container->size()), m_validator(container) {} + const ArrayView * m_validator; + void validateThis() const + { + fail_fast_assert(m_pdata >= m_validator->m_pdata && m_pdata < m_validator->m_pdata + m_validator->size(), "iterator is out of range of the array"); + } + contiguous_array_view_iterator (const ArrayView *container, bool isbegin) : + m_pdata(isbegin ? container->m_pdata : container->m_pdata + container->size()), m_validator(container) {} public: - reference operator*() const noexcept - { - validateThis(); - return *m_pdata; - } - pointer operator->() const noexcept - { - validateThis(); - return m_pdata; - } - contiguous_array_view_iterator& operator++() noexcept - { - ++m_pdata; - return *this; - } - contiguous_array_view_iterator operator++(int)noexcept - { - auto ret = *this; - ++(*this); - return ret; - } - contiguous_array_view_iterator& operator--() noexcept - { - --m_pdata; - return *this; - } - contiguous_array_view_iterator operator--(int)noexcept - { - auto ret = *this; - --(*this); - return ret; - } - contiguous_array_view_iterator operator+(difference_type n) const noexcept - { - contiguous_array_view_iterator ret{ *this }; - return ret += n; - } - contiguous_array_view_iterator& operator+=(difference_type n) noexcept - { - m_pdata += n; - return *this; - } - contiguous_array_view_iterator operator-(difference_type n) const noexcept - { - contiguous_array_view_iterator ret{ *this }; - return ret -= n; - } - contiguous_array_view_iterator& operator-=(difference_type n) noexcept - { - return *this += -n; - } - difference_type operator-(const contiguous_array_view_iterator& rhs) const noexcept - { - fail_fast_assert(m_validator == rhs.m_validator); - return m_pdata - rhs.m_pdata; - } - reference operator[](difference_type n) const noexcept - { - return *(*this + n); - } - bool operator==(const contiguous_array_view_iterator& rhs) const noexcept - { - fail_fast_assert(m_validator == rhs.m_validator); - return m_pdata == rhs.m_pdata; - } - bool operator!=(const contiguous_array_view_iterator& rhs) const noexcept - { - return !(*this == rhs); - } - bool operator<(const contiguous_array_view_iterator& rhs) const noexcept - { - fail_fast_assert(m_validator == rhs.m_validator); - return m_pdata < rhs.m_pdata; - } - bool operator<=(const contiguous_array_view_iterator& rhs) const noexcept - { - return !(rhs < *this); - } - bool operator>(const contiguous_array_view_iterator& rhs) const noexcept - { - return rhs < *this; - } - bool operator>=(const contiguous_array_view_iterator& rhs) const noexcept - { - return !(rhs > *this); - } - void swap(contiguous_array_view_iterator& rhs) noexcept - { - std::swap(m_pdata, rhs.m_pdata); - std::swap(m_validator, rhs.m_validator); - } + reference operator*() const noexcept + { + validateThis(); + return *m_pdata; + } + pointer operator->() const noexcept + { + validateThis(); + return m_pdata; + } + contiguous_array_view_iterator& operator++() noexcept + { + ++m_pdata; + return *this; + } + contiguous_array_view_iterator operator++(int)noexcept + { + auto ret = *this; + ++(*this); + return ret; + } + contiguous_array_view_iterator& operator--() noexcept + { + --m_pdata; + return *this; + } + contiguous_array_view_iterator operator--(int)noexcept + { + auto ret = *this; + --(*this); + return ret; + } + contiguous_array_view_iterator operator+(difference_type n) const noexcept + { + contiguous_array_view_iterator ret{ *this }; + return ret += n; + } + contiguous_array_view_iterator& operator+=(difference_type n) noexcept + { + m_pdata += n; + return *this; + } + contiguous_array_view_iterator operator-(difference_type n) const noexcept + { + contiguous_array_view_iterator ret{ *this }; + return ret -= n; + } + contiguous_array_view_iterator& operator-=(difference_type n) noexcept + { + return *this += -n; + } + difference_type operator-(const contiguous_array_view_iterator& rhs) const noexcept + { + fail_fast_assert(m_validator == rhs.m_validator); + return m_pdata - rhs.m_pdata; + } + reference operator[](difference_type n) const noexcept + { + return *(*this + n); + } + bool operator==(const contiguous_array_view_iterator& rhs) const noexcept + { + fail_fast_assert(m_validator == rhs.m_validator); + return m_pdata == rhs.m_pdata; + } + bool operator!=(const contiguous_array_view_iterator& rhs) const noexcept + { + return !(*this == rhs); + } + bool operator<(const contiguous_array_view_iterator& rhs) const noexcept + { + fail_fast_assert(m_validator == rhs.m_validator); + return m_pdata < rhs.m_pdata; + } + bool operator<=(const contiguous_array_view_iterator& rhs) const noexcept + { + return !(rhs < *this); + } + bool operator>(const contiguous_array_view_iterator& rhs) const noexcept + { + return rhs < *this; + } + bool operator>=(const contiguous_array_view_iterator& rhs) const noexcept + { + return !(rhs > *this); + } + void swap(contiguous_array_view_iterator& rhs) noexcept + { + std::swap(m_pdata, rhs.m_pdata); + std::swap(m_validator, rhs.m_validator); + } }; template contiguous_array_view_iterator operator+(typename contiguous_array_view_iterator::difference_type n, const contiguous_array_view_iterator& rhs) noexcept { - return rhs + n; + return rhs + n; } template class general_array_view_iterator : public std::iterator { - using Base = 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; + using typename Base::reference; + using typename Base::pointer; + using typename Base::difference_type; + using typename Base::value_type; private: - template - friend class basic_array_view; - + template + friend class basic_array_view; + const ArrayView * m_container; - typename ArrayView::bounds_type::iterator m_itr; - general_array_view_iterator(const ArrayView *container, bool isbegin) : - m_container(container), m_itr(isbegin ? m_container->bounds().begin() : m_container->bounds().end()) - {} + typename ArrayView::bounds_type::iterator m_itr; + general_array_view_iterator(const ArrayView *container, bool isbegin) : + m_container(container), m_itr(isbegin ? m_container->bounds().begin() : m_container->bounds().end()) + {} public: - reference operator*() noexcept - { - return (*m_container)[*m_itr]; - } - pointer operator->() noexcept - { - return &(*m_container)[*m_itr]; - } - general_array_view_iterator& operator++() noexcept - { - ++m_itr; - return *this; - } - general_array_view_iterator operator++(int)noexcept - { - auto ret = *this; - ++(*this); - return ret; - } - general_array_view_iterator& operator--() noexcept - { - --m_itr; - return *this; - } - general_array_view_iterator operator--(int)noexcept - { - auto ret = *this; - --(*this); - return ret; - } - general_array_view_iterator operator+(difference_type n) const noexcept - { - general_array_view_iterator ret{ *this }; - return ret += n; - } - general_array_view_iterator& operator+=(difference_type n) noexcept - { - m_itr += n; - return *this; - } - general_array_view_iterator operator-(difference_type n) const noexcept - { - general_array_view_iterator ret{ *this }; - return ret -= n; - } - general_array_view_iterator& operator-=(difference_type n) noexcept - { - return *this += -n; - } - difference_type operator-(const general_array_view_iterator& rhs) const noexcept - { - fail_fast_assert(m_container == rhs.m_container); - return m_itr - rhs.m_itr; - } - value_type operator[](difference_type n) const noexcept - { - return (*m_container)[m_itr[n]];; - } - bool operator==(const general_array_view_iterator& rhs) const noexcept - { - fail_fast_assert(m_container == rhs.m_container); - return m_itr == rhs.m_itr; - } - bool operator !=(const general_array_view_iterator& rhs) const noexcept - { - return !(*this == rhs); - } - bool operator<(const general_array_view_iterator& rhs) const noexcept - { - fail_fast_assert(m_container == rhs.m_container); - return m_itr < rhs.m_itr; - } - bool operator<=(const general_array_view_iterator& rhs) const noexcept - { - return !(rhs < *this); - } - bool operator>(const general_array_view_iterator& rhs) const noexcept - { - return rhs < *this; - } - bool operator>=(const general_array_view_iterator& rhs) const noexcept - { - return !(rhs > *this); - } - void swap(general_array_view_iterator& rhs) noexcept - { - std::swap(m_itr, rhs.m_itr); - std::swap(m_container, rhs.m_container); - } + reference operator*() noexcept + { + return (*m_container)[*m_itr]; + } + pointer operator->() noexcept + { + return &(*m_container)[*m_itr]; + } + general_array_view_iterator& operator++() noexcept + { + ++m_itr; + return *this; + } + general_array_view_iterator operator++(int)noexcept + { + auto ret = *this; + ++(*this); + return ret; + } + general_array_view_iterator& operator--() noexcept + { + --m_itr; + return *this; + } + general_array_view_iterator operator--(int)noexcept + { + auto ret = *this; + --(*this); + return ret; + } + general_array_view_iterator operator+(difference_type n) const noexcept + { + general_array_view_iterator ret{ *this }; + return ret += n; + } + general_array_view_iterator& operator+=(difference_type n) noexcept + { + m_itr += n; + return *this; + } + general_array_view_iterator operator-(difference_type n) const noexcept + { + general_array_view_iterator ret{ *this }; + return ret -= n; + } + general_array_view_iterator& operator-=(difference_type n) noexcept + { + return *this += -n; + } + difference_type operator-(const general_array_view_iterator& rhs) const noexcept + { + fail_fast_assert(m_container == rhs.m_container); + return m_itr - rhs.m_itr; + } + value_type operator[](difference_type n) const noexcept + { + return (*m_container)[m_itr[n]];; + } + bool operator==(const general_array_view_iterator& rhs) const noexcept + { + fail_fast_assert(m_container == rhs.m_container); + return m_itr == rhs.m_itr; + } + bool operator !=(const general_array_view_iterator& rhs) const noexcept + { + return !(*this == rhs); + } + bool operator<(const general_array_view_iterator& rhs) const noexcept + { + fail_fast_assert(m_container == rhs.m_container); + return m_itr < rhs.m_itr; + } + bool operator<=(const general_array_view_iterator& rhs) const noexcept + { + return !(rhs < *this); + } + bool operator>(const general_array_view_iterator& rhs) const noexcept + { + return rhs < *this; + } + bool operator>=(const general_array_view_iterator& rhs) const noexcept + { + return !(rhs > *this); + } + void swap(general_array_view_iterator& rhs) noexcept + { + std::swap(m_itr, rhs.m_itr); + std::swap(m_container, rhs.m_container); + } }; template general_array_view_iterator operator+(typename general_array_view_iterator::difference_type n, const general_array_view_iterator& rhs) noexcept { - return rhs + n; + return rhs + n; } } // namespace gsl