Debian Codegraph @

src/3rdparty/gsl/span_ext

raw
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
17 #ifndef GSL_SPAN_EXT_H
18 #define GSL_SPAN_EXT_H
19
20 ///////////////////////////////////////////////////////////////////////////////
21 //
22 // File: span_ext
23 // Purpose: continue offering features that have been cut from the official
24 // implementation of span.
25 // While modernizing gsl::span a number of features needed to be removed to
26 // be compliant with the design of std::span
27 //
28 ///////////////////////////////////////////////////////////////////////////////
29
30 #include "./assert" // GSL_KERNEL_MODE
31 #include "./util" // for narrow_cast, narrow
32
33 #include <cstddef> // for ptrdiff_t, size_t
34 #include <utility>
35
36 #ifndef GSL_KERNEL_MODE
37 #include <algorithm> // for lexicographical_compare
38 #endif // GSL_KERNEL_MODE
39
40 namespace gsl
41 {
42
43 // [span.views.constants], constants
44 GSL_INLINE constexpr const std::size_t dynamic_extent = narrow_cast<std::size_t>(-1);
45
46 template <class ElementType, std::size_t Extent = dynamic_extent>
47 class span;
48
49 // std::equal and std::lexicographical_compare are not /kernel compatible
50 // so all comparison operators must be removed for kernel mode.
51 #ifndef GSL_KERNEL_MODE
52
53 // [span.comparison], span comparison operators
54 template <class ElementType, std::size_t FirstExtent, std::size_t SecondExtent>
55 constexpr bool operator==(span<ElementType, FirstExtent> l, span<ElementType, SecondExtent> r)
56 {
57 return std::equal(l.begin(), l.end(), r.begin(), r.end());
58 }
59
60 template <class ElementType, std::size_t Extent>
61 constexpr bool operator!=(span<ElementType, Extent> l, span<ElementType, Extent> r)
62 {
63 return !(l == r);
64 }
65
66 template <class ElementType, std::size_t Extent>
67 constexpr bool operator<(span<ElementType, Extent> l, span<ElementType, Extent> r)
68 {
69 return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
70 }
71
72 template <class ElementType, std::size_t Extent>
73 constexpr bool operator<=(span<ElementType, Extent> l, span<ElementType, Extent> r)
74 {
75 return !(l > r);
76 }
77
78 template <class ElementType, std::size_t Extent>
79 constexpr bool operator>(span<ElementType, Extent> l, span<ElementType, Extent> r)
80 {
81 return r < l;
82 }
83
84 template <class ElementType, std::size_t Extent>
85 constexpr bool operator>=(span<ElementType, Extent> l, span<ElementType, Extent> r)
86 {
87 return !(l < r);
88 }
89
90 #endif // GSL_KERNEL_MODE
91
92 //
93 // make_span() - Utility functions for creating spans
94 //
95 template <class ElementType>
96 constexpr span<ElementType> make_span(ElementType* ptr, typename span<ElementType>::size_type count)
97 {
98 return span<ElementType>(ptr, count);
99 }
100
101 template <class ElementType>
102 constexpr span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem)
103 {
104 return span<ElementType>(firstElem, lastElem);
105 }
106
107 template <class ElementType, std::size_t N>
108 constexpr span<ElementType, N> make_span(ElementType (&arr)[N]) noexcept
109 {
110 return span<ElementType, N>(arr);
111 }
112
113 template <class Container>
114 constexpr span<typename Container::value_type> make_span(Container& cont)
115 {
116 return span<typename Container::value_type>(cont);
117 }
118
119 template <class Container>
120 constexpr span<const typename Container::value_type> make_span(const Container& cont)
121 {
122 return span<const typename Container::value_type>(cont);
123 }
124
125 template <class Ptr>
126 GSL_DEPRECATED("This function is deprecated. See GSL issue #1092.")
127 constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::size_t count)
128 {
129 return span<typename Ptr::element_type>(cont, count);
130 }
131
132 template <class Ptr>
133 GSL_DEPRECATED("This function is deprecated. See GSL issue #1092.")
134 constexpr span<typename Ptr::element_type> make_span(Ptr& cont)
135 {
136 return span<typename Ptr::element_type>(cont);
137 }
138
139 // Specialization of gsl::at for span
140 template <class ElementType, std::size_t Extent>
141 constexpr ElementType& at(span<ElementType, Extent> s, index i)
142 {
143 // No bounds checking here because it is done in span::operator[] called below
144 Ensures(i >= 0);
145 return s[narrow_cast<std::size_t>(i)];
146 }
147
148 // [span.obs] Free observer functions
149 template <class ElementType, std::size_t Extent>
150 constexpr std::ptrdiff_t ssize(const span<ElementType, Extent>& s) noexcept
151 {
152 return static_cast<std::ptrdiff_t>(s.size());
153 }
154
155 // [span.iter] Free functions for begin/end functions
156 template <class ElementType, std::size_t Extent>
157 constexpr typename span<ElementType, Extent>::iterator
158 begin(const span<ElementType, Extent>& s) noexcept
159 {
160 return s.begin();
161 }
162
163 template <class ElementType, std::size_t Extent = dynamic_extent>
164 constexpr typename span<ElementType, Extent>::iterator
165 end(const span<ElementType, Extent>& s) noexcept
166 {
167 return s.end();
168 }
169
170 template <class ElementType, std::size_t Extent>
171 constexpr typename span<ElementType, Extent>::reverse_iterator
172 rbegin(const span<ElementType, Extent>& s) noexcept
173 {
174 return s.rbegin();
175 }
176
177 template <class ElementType, std::size_t Extent>
178 constexpr typename span<ElementType, Extent>::reverse_iterator
179 rend(const span<ElementType, Extent>& s) noexcept
180 {
181 return s.rend();
182 }
183
184 template <class ElementType, std::size_t Extent>
185 constexpr typename span<ElementType, Extent>::iterator
186 cbegin(const span<ElementType, Extent>& s) noexcept
187 {
188 return s.begin();
189 }
190
191 template <class ElementType, std::size_t Extent = dynamic_extent>
192 constexpr typename span<ElementType, Extent>::iterator
193 cend(const span<ElementType, Extent>& s) noexcept
194 {
195 return s.end();
196 }
197
198 template <class ElementType, std::size_t Extent>
199 constexpr typename span<ElementType, Extent>::reverse_iterator
200 crbegin(const span<ElementType, Extent>& s) noexcept
201 {
202 return s.rbegin();
203 }
204
205 template <class ElementType, std::size_t Extent>
206 constexpr typename span<ElementType, Extent>::reverse_iterator
207 crend(const span<ElementType, Extent>& s) noexcept
208 {
209 return s.rend();
210 }
211
212 } // namespace gsl
213
214 #endif // GSL_SPAN_EXT_H