Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 1 | /////////////////////////////////////////////////////////////////////////////// |
| 2 | // |
| 3 | // Copyright (c) 2015 Microsoft Corporation. All rights reserved. |
| 4 | // |
| 5 | // This code is licensed under the MIT License (MIT). |
| 6 | // |
| 7 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 8 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 9 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 10 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 11 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 12 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 13 | // THE SOFTWARE. |
| 14 | // |
| 15 | /////////////////////////////////////////////////////////////////////////////// |
| 16 | |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 17 | #ifndef GSL_SPAN_H |
| 18 | #define GSL_SPAN_H |
| 19 | |
Tiago | 0d33bf6 | 2017-11-28 07:13:49 -0800 | [diff] [blame] | 20 | #include <gsl/gsl_assert> // for Expects |
| 21 | #include <gsl/gsl_byte> // for byte |
| 22 | #include <gsl/gsl_util> // for narrow_cast, narrow |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 23 | |
Tiago | 0d33bf6 | 2017-11-28 07:13:49 -0800 | [diff] [blame] | 24 | #include <algorithm> // for lexicographical_compare |
| 25 | #include <array> // for array |
| 26 | #include <cstddef> // for ptrdiff_t, size_t, nullptr_t |
| 27 | #include <iterator> // for reverse_iterator, distance, random_access_... |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 28 | #include <limits> |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 29 | #include <stdexcept> |
Tiago | 0d33bf6 | 2017-11-28 07:13:49 -0800 | [diff] [blame] | 30 | #include <type_traits> // for enable_if_t, declval, is_convertible, inte... |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 31 | #include <utility> |
Anna Gringauze | 1995e86 | 2018-08-19 17:10:53 -0700 | [diff] [blame] | 32 | #include <memory> // for std::addressof |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 33 | |
Anna Gringauze | 6418b5f | 2019-01-15 10:27:34 -0800 | [diff] [blame] | 34 | #if defined(_MSC_VER) && !defined(__clang__) |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 35 | #pragma warning(push) |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 36 | |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 37 | // turn off some warnings that are noisy about our Expects statements |
| 38 | #pragma warning(disable : 4127) // conditional expression is constant |
Neil MacIntosh | b2ee484 | 2017-07-13 13:53:56 -0700 | [diff] [blame] | 39 | #pragma warning(disable : 4702) // unreachable code |
Neil MacIntosh | a9f0ce2 | 2016-03-31 12:01:07 -0700 | [diff] [blame] | 40 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 41 | // Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool. |
| 42 | #pragma warning(disable : 26495) // uninitalized member when constructor calls constructor |
| 43 | #pragma warning(disable : 26446) // parser bug does not allow attributes on some templates |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 44 | |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 45 | #if _MSC_VER < 1910 |
| 46 | #pragma push_macro("constexpr") |
| 47 | #define constexpr /*constexpr*/ |
Neil MacIntosh | 6a33b97 | 2018-03-03 19:12:45 -0800 | [diff] [blame] | 48 | #define GSL_USE_STATIC_CONSTEXPR_WORKAROUND |
Neil MacIntosh | a9f0ce2 | 2016-03-31 12:01:07 -0700 | [diff] [blame] | 49 | |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 50 | #endif // _MSC_VER < 1910 |
| 51 | #endif // _MSC_VER |
Neil MacIntosh | 6a33b97 | 2018-03-03 19:12:45 -0800 | [diff] [blame] | 52 | |
| 53 | // See if we have enough C++17 power to use a static constexpr data member |
| 54 | // without needing an out-of-line definition |
| 55 | #if !(defined(__cplusplus) && (__cplusplus >= 201703L)) |
| 56 | #define GSL_USE_STATIC_CONSTEXPR_WORKAROUND |
| 57 | #endif // !(defined(__cplusplus) && (__cplusplus >= 201703L)) |
| 58 | |
menete | ffdaf0f | 2018-06-08 20:41:06 +0200 | [diff] [blame] | 59 | // GCC 7 does not like the signed unsigned missmatch (size_t ptrdiff_t) |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 60 | // While there is a conversion from signed to unsigned, it happens at |
| 61 | // compiletime, so the compiler wouldn't have to warn indiscriminently, but |
| 62 | // could check if the source value actually doesn't fit into the target type |
menete | ffdaf0f | 2018-06-08 20:41:06 +0200 | [diff] [blame] | 63 | // and only warn in those cases. |
Anna Gringauze | 6418b5f | 2019-01-15 10:27:34 -0800 | [diff] [blame] | 64 | #if defined(__GNUC__) && __GNUC__ > 6 |
menete | ffdaf0f | 2018-06-08 20:41:06 +0200 | [diff] [blame] | 65 | #pragma GCC diagnostic push |
| 66 | #pragma GCC diagnostic ignored "-Wsign-conversion" |
| 67 | #endif |
| 68 | |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 69 | namespace gsl |
| 70 | { |
| 71 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 72 | // [views.constants], constants |
Neil MacIntosh | c94a66f | 2016-06-12 18:28:19 -0700 | [diff] [blame] | 73 | constexpr const std::ptrdiff_t dynamic_extent = -1; |
| 74 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 75 | template <class ElementType, std::ptrdiff_t Extent = dynamic_extent> |
| 76 | class span; |
| 77 | |
Neil MacIntosh | c94a66f | 2016-06-12 18:28:19 -0700 | [diff] [blame] | 78 | // implementation details |
Neil MacIntosh | c40094a | 2016-03-01 12:11:41 -0800 | [diff] [blame] | 79 | namespace details |
| 80 | { |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 81 | template <class T> |
| 82 | struct is_span_oracle : std::false_type |
Neil MacIntosh | d9d6ff0 | 2016-05-29 13:52:28 -0700 | [diff] [blame] | 83 | { |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 84 | }; |
| 85 | |
| 86 | template <class ElementType, std::ptrdiff_t Extent> |
| 87 | struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type |
| 88 | { |
| 89 | }; |
| 90 | |
| 91 | template <class T> |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 92 | struct is_span : public is_span_oracle<std::remove_cv_t<T>> |
| 93 | { |
| 94 | }; |
| 95 | |
| 96 | template <class T> |
| 97 | struct is_std_array_oracle : std::false_type |
| 98 | { |
| 99 | }; |
| 100 | |
Casey Carter | 3819df6 | 2017-02-13 12:11:45 -0800 | [diff] [blame] | 101 | template <class ElementType, std::size_t Extent> |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 102 | struct is_std_array_oracle<std::array<ElementType, Extent>> : std::true_type |
| 103 | { |
| 104 | }; |
| 105 | |
| 106 | template <class T> |
| 107 | struct is_std_array : public is_std_array_oracle<std::remove_cv_t<T>> |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 108 | { |
| 109 | }; |
| 110 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 111 | template <std::ptrdiff_t From, std::ptrdiff_t To> |
| 112 | struct is_allowed_extent_conversion |
Neil MacIntosh | 6fadce9 | 2016-07-26 19:19:47 -0700 | [diff] [blame] | 113 | : public std::integral_constant<bool, From == To || From == gsl::dynamic_extent || |
| 114 | To == gsl::dynamic_extent> |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 115 | { |
| 116 | }; |
| 117 | |
| 118 | template <class From, class To> |
| 119 | struct is_allowed_element_type_conversion |
Neil MacIntosh | 831be5d | 2016-09-14 22:01:02 -0700 | [diff] [blame] | 120 | : public std::integral_constant<bool, std::is_convertible<From (*)[], To (*)[]>::value> |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 121 | { |
| 122 | }; |
| 123 | |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 124 | template <class Span, bool IsConst> |
Neil MacIntosh | 6c7be2c | 2016-08-01 21:41:20 -0700 | [diff] [blame] | 125 | class span_iterator |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 126 | { |
Eric Niebler | 9d13cb1 | 2016-12-09 20:19:50 -0800 | [diff] [blame] | 127 | using element_type_ = typename Span::element_type; |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 128 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 129 | public: |
Alex Howlett | c9e423d | 2018-03-05 15:04:22 -0500 | [diff] [blame] | 130 | #ifdef _MSC_VER |
| 131 | // Tell Microsoft standard library that span_iterators are checked. |
| 132 | using _Unchecked_type = typename Span::pointer; |
| 133 | #endif |
| 134 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 135 | using iterator_category = std::random_access_iterator_tag; |
Maciej T. Nowak | c2f953f | 2017-04-13 22:55:20 +0200 | [diff] [blame] | 136 | using value_type = std::remove_cv_t<element_type_>; |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 137 | using difference_type = typename Span::index_type; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 138 | |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 139 | using reference = std::conditional_t<IsConst, const element_type_, element_type_>&; |
Eric Niebler | 9d13cb1 | 2016-12-09 20:19:50 -0800 | [diff] [blame] | 140 | using pointer = std::add_pointer_t<reference>; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 141 | |
Casey Carter | 39902b6 | 2017-05-26 15:41:12 -0700 | [diff] [blame] | 142 | span_iterator() = default; |
Neil MacIntosh | 0dd5f56 | 2016-08-08 13:33:02 -0700 | [diff] [blame] | 143 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 144 | constexpr span_iterator(const Span* span, typename Span::index_type idx) noexcept |
paweldac | b3870ca | 2018-02-21 22:33:07 +0100 | [diff] [blame] | 145 | : span_(span), index_(idx) |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 146 | {} |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 147 | |
Casey Carter | 39902b6 | 2017-05-26 15:41:12 -0700 | [diff] [blame] | 148 | friend span_iterator<Span, true>; |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 149 | template <bool B, std::enable_if_t<!B && IsConst>* = nullptr> |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 150 | constexpr span_iterator(const span_iterator<Span, B>& other) noexcept |
Neil MacIntosh | 0dd5f56 | 2016-08-08 13:33:02 -0700 | [diff] [blame] | 151 | : span_iterator(other.span_, other.index_) |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 152 | {} |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 153 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 154 | GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 155 | constexpr reference operator*() const |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 156 | { |
Neil MacIntosh | 72688ff | 2018-02-10 18:58:28 -0800 | [diff] [blame] | 157 | Expects(index_ != span_->size()); |
Anna Gringauze | e7bcdf5 | 2017-09-18 15:16:23 -0700 | [diff] [blame] | 158 | return *(span_->data() + index_); |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 159 | } |
Neil MacIntosh | 94afa1f | 2016-08-01 18:49:48 -0700 | [diff] [blame] | 160 | |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 161 | constexpr pointer operator->() const |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 162 | { |
Neil MacIntosh | 72688ff | 2018-02-10 18:58:28 -0800 | [diff] [blame] | 163 | Expects(index_ != span_->size()); |
Casey Carter | 39902b6 | 2017-05-26 15:41:12 -0700 | [diff] [blame] | 164 | return span_->data() + index_; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 165 | } |
| 166 | |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 167 | constexpr span_iterator& operator++() |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 168 | { |
Neil MacIntosh | 72688ff | 2018-02-10 18:58:28 -0800 | [diff] [blame] | 169 | Expects(0 <= index_ && index_ != span_->size()); |
Neil MacIntosh | 94afa1f | 2016-08-01 18:49:48 -0700 | [diff] [blame] | 170 | ++index_; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 171 | return *this; |
| 172 | } |
| 173 | |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 174 | constexpr span_iterator operator++(int) |
Neil MacIntosh | 94afa1f | 2016-08-01 18:49:48 -0700 | [diff] [blame] | 175 | { |
| 176 | auto ret = *this; |
| 177 | ++(*this); |
| 178 | return ret; |
| 179 | } |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 180 | |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 181 | constexpr span_iterator& operator--() |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 182 | { |
Neil MacIntosh | 72688ff | 2018-02-10 18:58:28 -0800 | [diff] [blame] | 183 | Expects(index_ != 0 && index_ <= span_->size()); |
Neil MacIntosh | 94afa1f | 2016-08-01 18:49:48 -0700 | [diff] [blame] | 184 | --index_; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 185 | return *this; |
| 186 | } |
| 187 | |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 188 | constexpr span_iterator operator--(int) |
Neil MacIntosh | 94afa1f | 2016-08-01 18:49:48 -0700 | [diff] [blame] | 189 | { |
| 190 | auto ret = *this; |
| 191 | --(*this); |
| 192 | return ret; |
| 193 | } |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 194 | |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 195 | constexpr span_iterator operator+(difference_type n) const |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 196 | { |
Neil MacIntosh | 94afa1f | 2016-08-01 18:49:48 -0700 | [diff] [blame] | 197 | auto ret = *this; |
| 198 | return ret += n; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 199 | } |
| 200 | |
Casey Carter | d6a2242 | 2018-05-09 14:01:22 -0700 | [diff] [blame] | 201 | friend constexpr span_iterator operator+(difference_type n, span_iterator const& rhs) |
| 202 | { |
| 203 | return rhs + n; |
| 204 | } |
| 205 | |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 206 | constexpr span_iterator& operator+=(difference_type n) |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 207 | { |
Neil MacIntosh | 72688ff | 2018-02-10 18:58:28 -0800 | [diff] [blame] | 208 | Expects((index_ + n) >= 0 && (index_ + n) <= span_->size()); |
Neil MacIntosh | 94afa1f | 2016-08-01 18:49:48 -0700 | [diff] [blame] | 209 | index_ += n; |
| 210 | return *this; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 211 | } |
| 212 | |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 213 | constexpr span_iterator operator-(difference_type n) const |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 214 | { |
Neil MacIntosh | 94afa1f | 2016-08-01 18:49:48 -0700 | [diff] [blame] | 215 | auto ret = *this; |
| 216 | return ret -= n; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 217 | } |
| 218 | |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 219 | constexpr span_iterator& operator-=(difference_type n) { return *this += -n; } |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 220 | |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 221 | constexpr difference_type operator-(span_iterator rhs) const |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 222 | { |
Neil MacIntosh | 94afa1f | 2016-08-01 18:49:48 -0700 | [diff] [blame] | 223 | Expects(span_ == rhs.span_); |
| 224 | return index_ - rhs.index_; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 225 | } |
| 226 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 227 | constexpr reference operator[](difference_type n) const { return *(*this + n); } |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 228 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 229 | constexpr friend bool operator==(span_iterator lhs, span_iterator rhs) noexcept |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 230 | { |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 231 | return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 232 | } |
| 233 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 234 | constexpr friend bool operator!=(span_iterator lhs, span_iterator rhs) noexcept |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 235 | { |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 236 | return !(lhs == rhs); |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 237 | } |
| 238 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 239 | constexpr friend bool operator<(span_iterator lhs, span_iterator rhs) noexcept |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 240 | { |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 241 | return lhs.index_ < rhs.index_; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 242 | } |
| 243 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 244 | constexpr friend bool operator<=(span_iterator lhs, span_iterator rhs) noexcept |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 245 | { |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 246 | return !(rhs < lhs); |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 247 | } |
| 248 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 249 | constexpr friend bool operator>(span_iterator lhs, span_iterator rhs) noexcept |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 250 | { |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 251 | return rhs < lhs; |
| 252 | } |
| 253 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 254 | constexpr friend bool operator>=(span_iterator lhs, span_iterator rhs) noexcept |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 255 | { |
| 256 | return !(rhs > lhs); |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 257 | } |
| 258 | |
Anna Gringauze | 51ae678 | 2018-05-22 18:07:49 -0700 | [diff] [blame] | 259 | #ifdef _MSC_VER |
| 260 | // MSVC++ iterator debugging support; allows STL algorithms in 15.8+ |
| 261 | // to unwrap span_iterator to a pointer type after a range check in STL |
| 262 | // algorithm calls |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 263 | friend constexpr void _Verify_range(span_iterator lhs, span_iterator rhs) noexcept |
| 264 | { // test that [lhs, rhs) forms a valid range inside an STL algorithm |
| 265 | Expects(lhs.span_ == rhs.span_ // range spans have to match |
| 266 | && lhs.index_ <= rhs.index_); // range must not be transposed |
Anna Gringauze | 51ae678 | 2018-05-22 18:07:49 -0700 | [diff] [blame] | 267 | } |
| 268 | |
| 269 | constexpr void _Verify_offset(const difference_type n) const noexcept |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 270 | { // test that the iterator *this + n is a valid range in an STL |
Anna Gringauze | 51ae678 | 2018-05-22 18:07:49 -0700 | [diff] [blame] | 271 | // algorithm call |
| 272 | Expects((index_ + n) >= 0 && (index_ + n) <= span_->size()); |
| 273 | } |
| 274 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 275 | GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute |
Anna Gringauze | 51ae678 | 2018-05-22 18:07:49 -0700 | [diff] [blame] | 276 | constexpr pointer _Unwrapped() const noexcept |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 277 | { // after seeking *this to a high water mark, or using one of the |
Anna Gringauze | 51ae678 | 2018-05-22 18:07:49 -0700 | [diff] [blame] | 278 | // _Verify_xxx functions above, unwrap this span_iterator to a raw |
| 279 | // pointer |
| 280 | return span_->data() + index_; |
| 281 | } |
| 282 | |
| 283 | // Tell the STL that span_iterator should not be unwrapped if it can't |
| 284 | // validate in advance, even in release / optimized builds: |
| 285 | #if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND) |
| 286 | static constexpr const bool _Unwrap_when_unverified = false; |
| 287 | #else |
| 288 | static constexpr bool _Unwrap_when_unverified = false; |
| 289 | #endif |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 290 | GSL_SUPPRESS(con.3) // NO-FORMAT: attribute // TODO: false positive |
Anna Gringauze | 51ae678 | 2018-05-22 18:07:49 -0700 | [diff] [blame] | 291 | constexpr void _Seek_to(const pointer p) noexcept |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 292 | { // adjust the position of *this to previously verified location p |
Anna Gringauze | 51ae678 | 2018-05-22 18:07:49 -0700 | [diff] [blame] | 293 | // after _Unwrapped |
| 294 | index_ = p - span_->data(); |
| 295 | } |
| 296 | #endif |
| 297 | |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 298 | protected: |
Casey Carter | 39902b6 | 2017-05-26 15:41:12 -0700 | [diff] [blame] | 299 | const Span* span_ = nullptr; |
| 300 | std::ptrdiff_t index_ = 0; |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 301 | }; |
| 302 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 303 | template <std::ptrdiff_t Ext> |
| 304 | class extent_type |
| 305 | { |
| 306 | public: |
Neil MacIntosh | 6fadce9 | 2016-07-26 19:19:47 -0700 | [diff] [blame] | 307 | using index_type = std::ptrdiff_t; |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 308 | |
| 309 | static_assert(Ext >= 0, "A fixed-size span must be >= 0 in size."); |
| 310 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 311 | constexpr extent_type() noexcept {} |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 312 | |
| 313 | template <index_type Other> |
Casey Carter | 96eaf27 | 2017-01-28 00:08:48 -0800 | [diff] [blame] | 314 | constexpr extent_type(extent_type<Other> ext) |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 315 | { |
| 316 | static_assert(Other == Ext || Other == dynamic_extent, |
| 317 | "Mismatch between fixed-size extent and size of initializing data."); |
| 318 | Expects(ext.size() == Ext); |
| 319 | } |
| 320 | |
| 321 | constexpr extent_type(index_type size) { Expects(size == Ext); } |
| 322 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 323 | constexpr index_type size() const noexcept { return Ext; } |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 324 | }; |
| 325 | |
| 326 | template <> |
| 327 | class extent_type<dynamic_extent> |
| 328 | { |
| 329 | public: |
Neil MacIntosh | 6fadce9 | 2016-07-26 19:19:47 -0700 | [diff] [blame] | 330 | using index_type = std::ptrdiff_t; |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 331 | |
| 332 | template <index_type Other> |
| 333 | explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size()) |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 334 | {} |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 335 | |
| 336 | explicit constexpr extent_type(index_type size) : size_(size) { Expects(size >= 0); } |
| 337 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 338 | constexpr index_type size() const noexcept { return size_; } |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 339 | |
| 340 | private: |
| 341 | index_type size_; |
| 342 | }; |
Neil MacIntosh | 6a33b97 | 2018-03-03 19:12:45 -0800 | [diff] [blame] | 343 | |
| 344 | template <class ElementType, std::ptrdiff_t Extent, std::ptrdiff_t Offset, std::ptrdiff_t Count> |
| 345 | struct calculate_subspan_type |
| 346 | { |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 347 | using type = span<ElementType, Count != dynamic_extent |
| 348 | ? Count |
| 349 | : (Extent != dynamic_extent ? Extent - Offset : Extent)>; |
Neil MacIntosh | 6a33b97 | 2018-03-03 19:12:45 -0800 | [diff] [blame] | 350 | }; |
Neil MacIntosh | c40094a | 2016-03-01 12:11:41 -0800 | [diff] [blame] | 351 | } // namespace details |
| 352 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 353 | // [span], class template span |
Neil MacIntosh | c40094a | 2016-03-01 12:11:41 -0800 | [diff] [blame] | 354 | template <class ElementType, std::ptrdiff_t Extent> |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 355 | class span |
| 356 | { |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 357 | public: |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 358 | // constants and types |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 359 | using element_type = ElementType; |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 360 | using value_type = std::remove_cv_t<ElementType>; |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 361 | using index_type = std::ptrdiff_t; |
| 362 | using pointer = element_type*; |
| 363 | using reference = element_type&; |
Neil MacIntosh | d9d6ff0 | 2016-05-29 13:52:28 -0700 | [diff] [blame] | 364 | |
Neil MacIntosh | 82389aa | 2016-08-08 12:06:47 -0700 | [diff] [blame] | 365 | using iterator = details::span_iterator<span<ElementType, Extent>, false>; |
| 366 | using const_iterator = details::span_iterator<span<ElementType, Extent>, true>; |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 367 | using reverse_iterator = std::reverse_iterator<iterator>; |
Neil MacIntosh | 2674724 | 2016-06-26 17:00:56 +0300 | [diff] [blame] | 368 | using const_reverse_iterator = std::reverse_iterator<const_iterator>; |
Neil MacIntosh | d9d6ff0 | 2016-05-29 13:52:28 -0700 | [diff] [blame] | 369 | |
Maciej T. Nowak | c2f953f | 2017-04-13 22:55:20 +0200 | [diff] [blame] | 370 | using size_type = index_type; |
| 371 | |
Neil MacIntosh | 6a33b97 | 2018-03-03 19:12:45 -0800 | [diff] [blame] | 372 | #if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND) |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 373 | static constexpr const index_type extent{Extent}; |
Neil MacIntosh | 6a33b97 | 2018-03-03 19:12:45 -0800 | [diff] [blame] | 374 | #else |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 375 | static constexpr index_type extent{Extent}; |
Neil MacIntosh | 6a33b97 | 2018-03-03 19:12:45 -0800 | [diff] [blame] | 376 | #endif |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 377 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 378 | // [span.cons], span constructors, copy, assignment, and destructor |
Casey Carter | 96eaf27 | 2017-01-28 00:08:48 -0800 | [diff] [blame] | 379 | template <bool Dependent = false, |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 380 | // "Dependent" is needed to make "std::enable_if_t<Dependent || Extent <= 0>" SFINAE, |
| 381 | // since "std::enable_if_t<Extent <= 0>" is ill-formed when Extent is greater than 0. |
| 382 | class = std::enable_if_t<(Dependent || Extent <= 0)>> |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 383 | constexpr span() noexcept : storage_(nullptr, details::extent_type<0>()) |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 384 | {} |
Neil MacIntosh | cc22f2b | 2016-02-25 11:42:26 -0800 | [diff] [blame] | 385 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 386 | constexpr span(pointer ptr, index_type count) : storage_(ptr, count) {} |
Neil MacIntosh | cc22f2b | 2016-02-25 11:42:26 -0800 | [diff] [blame] | 387 | |
Neil MacIntosh | 502cd66 | 2016-02-28 00:50:53 -0800 | [diff] [blame] | 388 | constexpr span(pointer firstElem, pointer lastElem) |
| 389 | : storage_(firstElem, std::distance(firstElem, lastElem)) |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 390 | {} |
Neil MacIntosh | f61a9bb | 2016-02-29 13:16:48 -0800 | [diff] [blame] | 391 | |
Casey Carter | 3819df6 | 2017-02-13 12:11:45 -0800 | [diff] [blame] | 392 | template <std::size_t N> |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 393 | constexpr span(element_type (&arr)[N]) noexcept |
Anna Gringauze | 1995e86 | 2018-08-19 17:10:53 -0700 | [diff] [blame] | 394 | : storage_(KnownNotNull{std::addressof(arr[0])}, details::extent_type<N>()) |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 395 | {} |
Neil MacIntosh | 6fadce9 | 2016-07-26 19:19:47 -0700 | [diff] [blame] | 396 | |
Dave Hill | c02ddae | 2018-11-05 15:39:41 -0800 | [diff] [blame] | 397 | template <std::size_t N, class = std::enable_if_t<(N > 0)>> |
| 398 | constexpr span(std::array<std::remove_const_t<element_type>, N>& arr) noexcept |
| 399 | : storage_(KnownNotNull{arr.data()}, details::extent_type<N>()) |
| 400 | { |
| 401 | } |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 402 | |
Dave Hill | c02ddae | 2018-11-05 15:39:41 -0800 | [diff] [blame] | 403 | constexpr span(std::array<std::remove_const_t<element_type>, 0>&) noexcept |
| 404 | : storage_(static_cast<pointer>(nullptr), details::extent_type<0>()) |
| 405 | { |
| 406 | } |
| 407 | |
| 408 | template <std::size_t N, class = std::enable_if_t<(N > 0)>> |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 409 | constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr) noexcept |
Dave Hill | c02ddae | 2018-11-05 15:39:41 -0800 | [diff] [blame] | 410 | : storage_(KnownNotNull{arr.data()}, details::extent_type<N>()) |
| 411 | { |
| 412 | } |
| 413 | |
| 414 | constexpr span(const std::array<std::remove_const_t<element_type>, 0>&) noexcept |
| 415 | : storage_(static_cast<pointer>(nullptr), details::extent_type<0>()) |
| 416 | { |
| 417 | } |
Neil MacIntosh | cc22f2b | 2016-02-25 11:42:26 -0800 | [diff] [blame] | 418 | |
Neil MacIntosh | c40094a | 2016-03-01 12:11:41 -0800 | [diff] [blame] | 419 | // NB: the SFINAE here uses .data() as a incomplete/imperfect proxy for the requirement |
| 420 | // on Container to be a contiguous sequence container. |
| 421 | template <class Container, |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 422 | class = std::enable_if_t< |
Neil MacIntosh | 6fadce9 | 2016-07-26 19:19:47 -0700 | [diff] [blame] | 423 | !details::is_span<Container>::value && !details::is_std_array<Container>::value && |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 424 | std::is_convertible<typename Container::pointer, pointer>::value && |
| 425 | std::is_convertible<typename Container::pointer, |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 426 | decltype(std::declval<Container>().data())>::value>> |
Gary Furnish | 612747a | 2016-10-04 21:13:18 -0600 | [diff] [blame] | 427 | constexpr span(Container& cont) : span(cont.data(), narrow<index_type>(cont.size())) |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 428 | {} |
Neil MacIntosh | c40094a | 2016-03-01 12:11:41 -0800 | [diff] [blame] | 429 | |
Neil MacIntosh | c40094a | 2016-03-01 12:11:41 -0800 | [diff] [blame] | 430 | template <class Container, |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 431 | class = std::enable_if_t< |
| 432 | std::is_const<element_type>::value && !details::is_span<Container>::value && |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 433 | std::is_convertible<typename Container::pointer, pointer>::value && |
| 434 | std::is_convertible<typename Container::pointer, |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 435 | decltype(std::declval<Container>().data())>::value>> |
Gary Furnish | 612747a | 2016-10-04 21:13:18 -0600 | [diff] [blame] | 436 | constexpr span(const Container& cont) : span(cont.data(), narrow<index_type>(cont.size())) |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 437 | {} |
Neil MacIntosh | 3d4c349 | 2016-03-17 17:20:33 -0700 | [diff] [blame] | 438 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 439 | constexpr span(const span& other) noexcept = default; |
Neil MacIntosh | 717a2e3 | 2016-03-16 19:39:55 -0700 | [diff] [blame] | 440 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 441 | template < |
| 442 | class OtherElementType, std::ptrdiff_t OtherExtent, |
Neil MacIntosh | c94a66f | 2016-06-12 18:28:19 -0700 | [diff] [blame] | 443 | class = std::enable_if_t< |
| 444 | details::is_allowed_extent_conversion<OtherExtent, Extent>::value && |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 445 | details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>> |
| 446 | constexpr span(const span<OtherElementType, OtherExtent>& other) |
Neil MacIntosh | 831be5d | 2016-09-14 22:01:02 -0700 | [diff] [blame] | 447 | : storage_(other.data(), details::extent_type<OtherExtent>(other.size())) |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 448 | {} |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 449 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 450 | ~span() noexcept = default; |
| 451 | constexpr span& operator=(const span& other) noexcept = default; |
Casey Carter | d6a2242 | 2018-05-09 14:01:22 -0700 | [diff] [blame] | 452 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 453 | // [span.sub], span subviews |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 454 | template <std::ptrdiff_t Count> |
Neil MacIntosh | c8a412f | 2016-03-18 16:49:29 -0700 | [diff] [blame] | 455 | constexpr span<element_type, Count> first() const |
| 456 | { |
| 457 | Expects(Count >= 0 && Count <= size()); |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 458 | return {data(), Count}; |
Neil MacIntosh | c8a412f | 2016-03-18 16:49:29 -0700 | [diff] [blame] | 459 | } |
| 460 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 461 | template <std::ptrdiff_t Count> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 462 | GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute |
Neil MacIntosh | c8a412f | 2016-03-18 16:49:29 -0700 | [diff] [blame] | 463 | constexpr span<element_type, Count> last() const |
| 464 | { |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 465 | Expects(Count >= 0 && size() - Count >= 0); |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 466 | return {data() + (size() - Count), Count}; |
Neil MacIntosh | c8a412f | 2016-03-18 16:49:29 -0700 | [diff] [blame] | 467 | } |
| 468 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 469 | template <std::ptrdiff_t Offset, std::ptrdiff_t Count = dynamic_extent> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 470 | GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute |
| 471 | constexpr auto subspan() const -> |
| 472 | typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type |
Neil MacIntosh | c8a412f | 2016-03-18 16:49:29 -0700 | [diff] [blame] | 473 | { |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 474 | Expects((Offset >= 0 && size() - Offset >= 0) && |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 475 | (Count == dynamic_extent || (Count >= 0 && Offset + Count <= size()))); |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 476 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 477 | return {data() + Offset, Count == dynamic_extent ? size() - Offset : Count}; |
Neil MacIntosh | c8a412f | 2016-03-18 16:49:29 -0700 | [diff] [blame] | 478 | } |
| 479 | |
| 480 | constexpr span<element_type, dynamic_extent> first(index_type count) const |
| 481 | { |
| 482 | Expects(count >= 0 && count <= size()); |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 483 | return {data(), count}; |
Neil MacIntosh | c8a412f | 2016-03-18 16:49:29 -0700 | [diff] [blame] | 484 | } |
| 485 | |
| 486 | constexpr span<element_type, dynamic_extent> last(index_type count) const |
| 487 | { |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 488 | return make_subspan(size() - count, dynamic_extent, subspan_selector<Extent>{}); |
Neil MacIntosh | c8a412f | 2016-03-18 16:49:29 -0700 | [diff] [blame] | 489 | } |
| 490 | |
| 491 | constexpr span<element_type, dynamic_extent> subspan(index_type offset, |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 492 | index_type count = dynamic_extent) const |
Neil MacIntosh | c8a412f | 2016-03-18 16:49:29 -0700 | [diff] [blame] | 493 | { |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 494 | return make_subspan(offset, count, subspan_selector<Extent>{}); |
Neil MacIntosh | c8a412f | 2016-03-18 16:49:29 -0700 | [diff] [blame] | 495 | } |
| 496 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 497 | // [span.obs], span observers |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 498 | constexpr index_type size() const noexcept { return storage_.size(); } |
| 499 | constexpr index_type size_bytes() const noexcept |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 500 | { |
| 501 | return size() * narrow_cast<index_type>(sizeof(element_type)); |
| 502 | } |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 503 | constexpr bool empty() const noexcept { return size() == 0; } |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 504 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 505 | // [span.elem], span element access |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 506 | GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute |
Neil MacIntosh | cc22f2b | 2016-02-25 11:42:26 -0800 | [diff] [blame] | 507 | constexpr reference operator[](index_type idx) const |
| 508 | { |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 509 | Expects(CheckRange(idx, storage_.size())); |
Neil MacIntosh | f2ab3a5 | 2016-07-20 09:24:49 -0700 | [diff] [blame] | 510 | return data()[idx]; |
Neil MacIntosh | cc22f2b | 2016-02-25 11:42:26 -0800 | [diff] [blame] | 511 | } |
Rian Quinn | 6cffe0d | 2016-10-26 15:11:24 -0600 | [diff] [blame] | 512 | |
| 513 | constexpr reference at(index_type idx) const { return this->operator[](idx); } |
Neil MacIntosh | cc22f2b | 2016-02-25 11:42:26 -0800 | [diff] [blame] | 514 | constexpr reference operator()(index_type idx) const { return this->operator[](idx); } |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 515 | constexpr pointer data() const noexcept { return storage_.data(); } |
Neil MacIntosh | d9d6ff0 | 2016-05-29 13:52:28 -0700 | [diff] [blame] | 516 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 517 | // [span.iter], span iterator support |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 518 | constexpr iterator begin() const noexcept { return {this, 0}; } |
| 519 | constexpr iterator end() const noexcept { return {this, size()}; } |
Neil MacIntosh | 30a038c | 2016-07-18 11:38:01 -0700 | [diff] [blame] | 520 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 521 | constexpr const_iterator cbegin() const noexcept { return {this, 0}; } |
| 522 | constexpr const_iterator cend() const noexcept { return {this, size()}; } |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 523 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 524 | constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } |
| 525 | constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } |
Neil MacIntosh | 30a038c | 2016-07-18 11:38:01 -0700 | [diff] [blame] | 526 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 527 | constexpr const_reverse_iterator crbegin() const noexcept |
| 528 | { |
| 529 | return const_reverse_iterator{cend()}; |
| 530 | } |
| 531 | constexpr const_reverse_iterator crend() const noexcept |
| 532 | { |
| 533 | return const_reverse_iterator{cbegin()}; |
| 534 | } |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 535 | |
Casey Carter | d6a2242 | 2018-05-09 14:01:22 -0700 | [diff] [blame] | 536 | #ifdef _MSC_VER |
| 537 | // Tell MSVC how to unwrap spans in range-based-for |
| 538 | constexpr pointer _Unchecked_begin() const noexcept { return data(); } |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 539 | constexpr pointer _Unchecked_end() const noexcept |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 540 | { |
| 541 | GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute |
| 542 | return data() + size(); |
| 543 | } |
Casey Carter | d6a2242 | 2018-05-09 14:01:22 -0700 | [diff] [blame] | 544 | #endif // _MSC_VER |
| 545 | |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 546 | private: |
Alex Green | 7a7d025 | 2019-01-14 19:44:45 -0500 | [diff] [blame] | 547 | static constexpr bool CheckRange(index_type idx, index_type size) noexcept |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 548 | { |
| 549 | // Optimization: |
| 550 | // |
| 551 | // idx >= 0 && idx < size |
| 552 | // => |
| 553 | // static_cast<size_t>(idx) < static_cast<size_t>(size) |
| 554 | // |
| 555 | // because size >=0 by span construction, and negative idx will |
| 556 | // wrap around to a value always greater than size when casted. |
| 557 | |
| 558 | // check if we have enough space to wrap around |
kile0 | 5a7093f | 2018-11-28 11:52:11 -0800 | [diff] [blame] | 559 | #if defined(__cpp_if_constexpr) |
| 560 | if constexpr (sizeof(index_type) <= sizeof(size_t)) |
| 561 | #else |
Anna Gringauze | 585f48c | 2018-08-19 16:27:30 -0700 | [diff] [blame] | 562 | if (sizeof(index_type) <= sizeof(size_t)) |
kile0 | 5a7093f | 2018-11-28 11:52:11 -0800 | [diff] [blame] | 563 | #endif |
Anna Gringauze | 5016ce4 | 2018-08-17 11:36:06 -0700 | [diff] [blame] | 564 | { |
| 565 | return narrow_cast<size_t>(idx) < narrow_cast<size_t>(size); |
| 566 | } |
| 567 | else |
| 568 | { |
| 569 | return idx >= 0 && idx < size; |
| 570 | } |
| 571 | } |
| 572 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 573 | // Needed to remove unnecessary null check in subspans |
Casey Carter | d6a2242 | 2018-05-09 14:01:22 -0700 | [diff] [blame] | 574 | struct KnownNotNull |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 575 | { |
| 576 | pointer p; |
| 577 | }; |
| 578 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 579 | // this implementation detail class lets us take advantage of the |
Neil MacIntosh | 502cd66 | 2016-02-28 00:50:53 -0800 | [diff] [blame] | 580 | // empty base class optimization to pay for only storage of a single |
| 581 | // pointer in the case of fixed-size spans |
| 582 | template <class ExtentType> |
| 583 | class storage_type : public ExtentType |
| 584 | { |
| 585 | public: |
Casey Carter | d6a2242 | 2018-05-09 14:01:22 -0700 | [diff] [blame] | 586 | // KnownNotNull parameter is needed to remove unnecessary null check |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 587 | // in subspans and constructors from arrays |
Neil MacIntosh | 502cd66 | 2016-02-28 00:50:53 -0800 | [diff] [blame] | 588 | template <class OtherExtentType> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 589 | constexpr storage_type(KnownNotNull data, OtherExtentType ext) |
| 590 | : ExtentType(ext), data_(data.p) |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 591 | { |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 592 | Expects(ExtentType::size() >= 0); |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 593 | } |
Neil MacIntosh | 502cd66 | 2016-02-28 00:50:53 -0800 | [diff] [blame] | 594 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 595 | template <class OtherExtentType> |
| 596 | constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data) |
| 597 | { |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 598 | Expects(ExtentType::size() >= 0); |
| 599 | Expects(data || ExtentType::size() == 0); |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 600 | } |
| 601 | |
| 602 | constexpr pointer data() const noexcept { return data_; } |
Neil MacIntosh | 502cd66 | 2016-02-28 00:50:53 -0800 | [diff] [blame] | 603 | |
| 604 | private: |
| 605 | pointer data_; |
| 606 | }; |
| 607 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 608 | storage_type<details::extent_type<Extent>> storage_; |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 609 | |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 610 | // The rest is needed to remove unnecessary null check |
| 611 | // in subspans and constructors from arrays |
| 612 | constexpr span(KnownNotNull ptr, index_type count) : storage_(ptr, count) {} |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 613 | |
| 614 | template <std::ptrdiff_t CallerExtent> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 615 | class subspan_selector |
| 616 | { |
| 617 | }; |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 618 | |
| 619 | template <std::ptrdiff_t CallerExtent> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 620 | span<element_type, dynamic_extent> make_subspan(index_type offset, index_type count, |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 621 | subspan_selector<CallerExtent>) const |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 622 | { |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 623 | const span<element_type, dynamic_extent> tmp(*this); |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 624 | return tmp.subspan(offset, count); |
| 625 | } |
| 626 | |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 627 | GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute |
| 628 | span<element_type, dynamic_extent> make_subspan(index_type offset, index_type count, |
Anna Gringauze | cbd64c9 | 2018-03-03 19:12:23 -0800 | [diff] [blame] | 629 | subspan_selector<dynamic_extent>) const |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 630 | { |
| 631 | Expects(offset >= 0 && size() - offset >= 0); |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 632 | |
| 633 | if (count == dynamic_extent) { return {KnownNotNull{data() + offset}, size() - offset}; } |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 634 | |
| 635 | Expects(count >= 0 && size() - offset >= count); |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 636 | return {KnownNotNull{data() + offset}, count}; |
Anna Gringauze | 9a78979 | 2017-11-03 16:13:39 -0700 | [diff] [blame] | 637 | } |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 638 | }; |
| 639 | |
Neil MacIntosh | 6a33b97 | 2018-03-03 19:12:45 -0800 | [diff] [blame] | 640 | #if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND) |
| 641 | template <class ElementType, std::ptrdiff_t Extent> |
| 642 | constexpr const typename span<ElementType, Extent>::index_type span<ElementType, Extent>::extent; |
| 643 | #endif |
| 644 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 645 | // [span.comparison], span comparison operators |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 646 | template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondExtent> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 647 | constexpr bool operator==(span<ElementType, FirstExtent> l, span<ElementType, SecondExtent> r) |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 648 | { |
| 649 | return std::equal(l.begin(), l.end(), r.begin(), r.end()); |
| 650 | } |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 651 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 652 | template <class ElementType, std::ptrdiff_t Extent> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 653 | constexpr bool operator!=(span<ElementType, Extent> l, span<ElementType, Extent> r) |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 654 | { |
| 655 | return !(l == r); |
| 656 | } |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 657 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 658 | template <class ElementType, std::ptrdiff_t Extent> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 659 | constexpr bool operator<(span<ElementType, Extent> l, span<ElementType, Extent> r) |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 660 | { |
| 661 | return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end()); |
| 662 | } |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 663 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 664 | template <class ElementType, std::ptrdiff_t Extent> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 665 | constexpr bool operator<=(span<ElementType, Extent> l, span<ElementType, Extent> r) |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 666 | { |
| 667 | return !(l > r); |
| 668 | } |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 669 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 670 | template <class ElementType, std::ptrdiff_t Extent> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 671 | constexpr bool operator>(span<ElementType, Extent> l, span<ElementType, Extent> r) |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 672 | { |
| 673 | return r < l; |
| 674 | } |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 675 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 676 | template <class ElementType, std::ptrdiff_t Extent> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 677 | constexpr bool operator>=(span<ElementType, Extent> l, span<ElementType, Extent> r) |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 678 | { |
| 679 | return !(l < r); |
| 680 | } |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 681 | |
Neil MacIntosh | ba8ebef | 2016-05-29 17:06:29 -0700 | [diff] [blame] | 682 | namespace details |
| 683 | { |
| 684 | // if we only supported compilers with good constexpr support then |
| 685 | // this pair of classes could collapse down to a constexpr function |
| 686 | |
Casey Carter | 3819df6 | 2017-02-13 12:11:45 -0800 | [diff] [blame] | 687 | // we should use a narrow_cast<> to go to std::size_t, but older compilers may not see it as |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 688 | // constexpr |
Neil MacIntosh | ba8ebef | 2016-05-29 17:06:29 -0700 | [diff] [blame] | 689 | // and so will fail compilation of the template |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 690 | template <class ElementType, std::ptrdiff_t Extent> |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 691 | struct calculate_byte_size |
| 692 | : std::integral_constant<std::ptrdiff_t, |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 693 | static_cast<std::ptrdiff_t>(sizeof(ElementType) * |
Neil MacIntosh | 6fadce9 | 2016-07-26 19:19:47 -0700 | [diff] [blame] | 694 | static_cast<std::size_t>(Extent))> |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 695 | { |
| 696 | }; |
Neil MacIntosh | ba8ebef | 2016-05-29 17:06:29 -0700 | [diff] [blame] | 697 | |
| 698 | template <class ElementType> |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 699 | struct calculate_byte_size<ElementType, dynamic_extent> |
| 700 | : std::integral_constant<std::ptrdiff_t, dynamic_extent> |
| 701 | { |
| 702 | }; |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 703 | } // namespace details |
Neil MacIntosh | ba8ebef | 2016-05-29 17:06:29 -0700 | [diff] [blame] | 704 | |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 705 | // [span.objectrep], views of object representation |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 706 | template <class ElementType, std::ptrdiff_t Extent> |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 707 | span<const byte, details::calculate_byte_size<ElementType, Extent>::value> |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 708 | as_bytes(span<ElementType, Extent> s) noexcept |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 709 | { |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 710 | GSL_SUPPRESS(type.1) // NO-FORMAT: attribute |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 711 | return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; |
| 712 | } |
Neil MacIntosh | d3929c5 | 2016-02-24 16:11:33 -0800 | [diff] [blame] | 713 | |
Neil MacIntosh | c366f44 | 2016-07-26 18:34:27 -0700 | [diff] [blame] | 714 | template <class ElementType, std::ptrdiff_t Extent, |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 715 | class = std::enable_if_t<!std::is_const<ElementType>::value>> |
| 716 | span<byte, details::calculate_byte_size<ElementType, Extent>::value> |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 717 | as_writeable_bytes(span<ElementType, Extent> s) noexcept |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 718 | { |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 719 | GSL_SUPPRESS(type.1) // NO-FORMAT: attribute |
Neil MacIntosh | b03b04b | 2016-07-20 13:17:47 -0700 | [diff] [blame] | 720 | return {reinterpret_cast<byte*>(s.data()), s.size_bytes()}; |
| 721 | } |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 722 | |
Rian Quinn | 2df9f85 | 2016-11-16 11:17:04 -0700 | [diff] [blame] | 723 | // |
| 724 | // make_span() - Utility functions for creating spans |
| 725 | // |
| 726 | template <class ElementType> |
Anna Gringauze | cea0d0a | 2018-08-12 21:44:17 -0700 | [diff] [blame] | 727 | constexpr span<ElementType> make_span(ElementType* ptr, |
| 728 | typename span<ElementType>::index_type count) |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 729 | { |
| 730 | return span<ElementType>(ptr, count); |
| 731 | } |
Rian Quinn | 2df9f85 | 2016-11-16 11:17:04 -0700 | [diff] [blame] | 732 | |
| 733 | template <class ElementType> |
beinhaerter | 7eb8f41 | 2018-02-23 22:35:36 +0100 | [diff] [blame] | 734 | constexpr span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem) |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 735 | { |
| 736 | return span<ElementType>(firstElem, lastElem); |
| 737 | } |
Rian Quinn | 2df9f85 | 2016-11-16 11:17:04 -0700 | [diff] [blame] | 738 | |
Casey Carter | 3819df6 | 2017-02-13 12:11:45 -0800 | [diff] [blame] | 739 | template <class ElementType, std::size_t N> |
Anna Gringauze | c6bf25a | 2018-03-15 12:14:29 -0700 | [diff] [blame] | 740 | constexpr span<ElementType, N> make_span(ElementType (&arr)[N]) noexcept |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 741 | { |
ewoudvc | 64c0ca6 | 2017-04-25 21:01:49 +0200 | [diff] [blame] | 742 | return span<ElementType, N>(arr); |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 743 | } |
Rian Quinn | 2df9f85 | 2016-11-16 11:17:04 -0700 | [diff] [blame] | 744 | |
| 745 | template <class Container> |
beinhaerter | 7eb8f41 | 2018-02-23 22:35:36 +0100 | [diff] [blame] | 746 | constexpr span<typename Container::value_type> make_span(Container& cont) |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 747 | { |
| 748 | return span<typename Container::value_type>(cont); |
| 749 | } |
Rian Quinn | 2df9f85 | 2016-11-16 11:17:04 -0700 | [diff] [blame] | 750 | |
| 751 | template <class Container> |
beinhaerter | 7eb8f41 | 2018-02-23 22:35:36 +0100 | [diff] [blame] | 752 | constexpr span<const typename Container::value_type> make_span(const Container& cont) |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 753 | { |
| 754 | return span<const typename Container::value_type>(cont); |
| 755 | } |
Rian Quinn | 2df9f85 | 2016-11-16 11:17:04 -0700 | [diff] [blame] | 756 | |
| 757 | template <class Ptr> |
beinhaerter | 7eb8f41 | 2018-02-23 22:35:36 +0100 | [diff] [blame] | 758 | constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::ptrdiff_t count) |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 759 | { |
| 760 | return span<typename Ptr::element_type>(cont, count); |
| 761 | } |
Rian Quinn | 2df9f85 | 2016-11-16 11:17:04 -0700 | [diff] [blame] | 762 | |
| 763 | template <class Ptr> |
beinhaerter | 7eb8f41 | 2018-02-23 22:35:36 +0100 | [diff] [blame] | 764 | constexpr span<typename Ptr::element_type> make_span(Ptr& cont) |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 765 | { |
| 766 | return span<typename Ptr::element_type>(cont); |
| 767 | } |
Rian Quinn | 2df9f85 | 2016-11-16 11:17:04 -0700 | [diff] [blame] | 768 | |
ericLemanissier | 134f2db | 2016-08-23 10:30:06 +0200 | [diff] [blame] | 769 | // Specialization of gsl::at for span |
| 770 | template <class ElementType, std::ptrdiff_t Extent> |
paweldac | b3870ca | 2018-02-21 22:33:07 +0100 | [diff] [blame] | 771 | constexpr ElementType& at(span<ElementType, Extent> s, index i) |
ericLemanissier | 134f2db | 2016-08-23 10:30:06 +0200 | [diff] [blame] | 772 | { |
| 773 | // No bounds checking here because it is done in span::operator[] called below |
paweldac | b3870ca | 2018-02-21 22:33:07 +0100 | [diff] [blame] | 774 | return s[i]; |
ericLemanissier | 134f2db | 2016-08-23 10:30:06 +0200 | [diff] [blame] | 775 | } |
| 776 | |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 777 | } // namespace gsl |
| 778 | |
Anna Gringauze | 6418b5f | 2019-01-15 10:27:34 -0800 | [diff] [blame] | 779 | #if defined(_MSC_VER) && !defined(__clang__) |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 780 | #if _MSC_VER < 1910 |
| 781 | #undef constexpr |
| 782 | #pragma pop_macro("constexpr") |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 783 | |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 784 | #endif // _MSC_VER < 1910 |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 785 | |
Tiago | ebe7ebf | 2017-04-20 07:51:37 -0700 | [diff] [blame] | 786 | #pragma warning(pop) |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 787 | #endif // _MSC_VER |
| 788 | |
Anna Gringauze | 6418b5f | 2019-01-15 10:27:34 -0800 | [diff] [blame] | 789 | #if defined(__GNUC__) && __GNUC__ > 6 |
menete | ffdaf0f | 2018-06-08 20:41:06 +0200 | [diff] [blame] | 790 | #pragma GCC diagnostic pop |
| 791 | #endif // __GNUC__ > 6 |
| 792 | |
Neil MacIntosh | cec26a2 | 2016-02-24 11:26:28 -0800 | [diff] [blame] | 793 | #endif // GSL_SPAN_H |