Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : #pragma once
5 :
6 : #include <array>
7 : #include <cstddef>
8 : #include <functional>
9 : #include <iterator>
10 : #include <ostream>
11 : #include <utility>
12 :
13 : #include "Utilities/Requires.hpp"
14 : #include "Utilities/TMPL.hpp"
15 : #include "Utilities/TypeTraits/IsA.hpp"
16 :
17 : namespace cpp20 {
18 : namespace detail {
19 : template <typename T, size_t Size, size_t... Is>
20 : constexpr std::array<T, Size> convert_to_array(
21 : // NOLINTNEXTLINE(modernize-avoid-c-arrays)
22 : const T (&t)[Size], std::index_sequence<Is...> /*meta*/) {
23 : return {{t[Is]...}};
24 : }
25 : } // namespace detail
26 :
27 : /// \brief A `std::array` implementation with partial C++20 support
28 : ///
29 : /// \warning This is not a standard-compliant C++20 `std::array` implementation.
30 : /// We provide this implementation because we need the `constexpr operator==`
31 : /// from C++20. Note that other C++20 changes, such as the replacement of the
32 : /// other comparison operators in favor of `operator<=>`, are not implemented.
33 : /// This class can be removed when we support C++20.
34 : template <typename T, size_t Size>
35 1 : struct array {
36 0 : using value_type = T;
37 0 : using reference = value_type&;
38 0 : using const_reference = const value_type&;
39 0 : using iterator = value_type*;
40 0 : using const_iterator = const value_type*;
41 0 : using pointer = value_type*;
42 0 : using const_pointer = const value_type*;
43 0 : using size_type = size_t;
44 0 : using difference_type = std::ptrdiff_t;
45 0 : using reverse_iterator = std::reverse_iterator<iterator>;
46 0 : using const_reverse_iterator = std::reverse_iterator<const_iterator>;
47 :
48 : // clang-tidy: mark explicit. We want implicit conversion
49 : constexpr operator std::array<T, Size>() const { // NOLINT
50 : return detail::convert_to_array(data_, std::make_index_sequence<Size>{});
51 : }
52 :
53 0 : constexpr iterator begin() {
54 : return iterator(data_); // NOLINT
55 : }
56 0 : constexpr const_iterator begin() const {
57 : return const_iterator(data_); // NOLINT
58 : }
59 0 : constexpr iterator end() {
60 : return iterator(data_ + Size); // NOLINT
61 : }
62 0 : constexpr const_iterator end() const {
63 : return const_iterator(data_ + Size); // NOLINT
64 : }
65 :
66 0 : constexpr const_iterator cbegin() const { return begin(); }
67 0 : constexpr const_iterator cend() const { return end(); }
68 :
69 0 : constexpr size_type size() const { return Size; }
70 0 : constexpr size_type max_size() const { return Size; }
71 0 : constexpr bool empty() const { return Size == 0; }
72 :
73 0 : constexpr reference operator[](const size_type i) {
74 : return data_[i]; // NOLINT
75 : }
76 0 : constexpr const_reference operator[](const size_type i) const {
77 : return data_[i]; // NOLINT
78 : }
79 :
80 0 : constexpr reference at(const size_type i) {
81 : return data_[i]; // NOLINT
82 : }
83 0 : constexpr const_reference at(const size_type i) const {
84 : return data_[i]; // NOLINT
85 : }
86 :
87 0 : constexpr reference front() { return data_[0]; }
88 0 : constexpr const_reference front() const { return data_[0]; }
89 0 : constexpr reference back() { return data_[Size > 0 ? Size - 1 : 0]; }
90 0 : constexpr const_reference back() const {
91 : return data_[Size > 0 ? Size - 1 : 0];
92 : }
93 :
94 0 : constexpr value_type* data() { return data_; }
95 0 : constexpr const value_type* data() const { return data_; }
96 :
97 : // NOLINTNEXTLINE(modernize-avoid-c-arrays)
98 0 : value_type data_[Size > 0 ? Size : 1];
99 : };
100 : namespace detail {
101 : template <typename T = void>
102 : struct Equal {
103 : constexpr bool inline operator()(const T& lhs, const T& rhs) const {
104 : return lhs == rhs;
105 : }
106 : };
107 :
108 : template <>
109 : struct Equal<void> {
110 : template <class T0, class T1>
111 : constexpr bool inline operator()(T0&& lhs, T1&& rhs) const {
112 : return std::forward<T0>(lhs) == std::forward<T1>(rhs);
113 : }
114 : };
115 : } // namespace detail
116 :
117 : template <typename InputIter1, typename InputIter2,
118 : typename BinaryPred = detail::Equal<>>
119 0 : constexpr bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2,
120 : BinaryPred pred = detail::Equal<>{}) {
121 : for (; first1 != last1; ++first1, ++first2) {
122 : if (not pred(*first1, *first2)) {
123 : return false;
124 : }
125 : }
126 : return true;
127 : }
128 :
129 : template <typename InputIter1, typename InputIter2,
130 : typename BinaryPred = std::less_equal<>>
131 0 : constexpr bool lexicographical_compare(InputIter1 first1, InputIter1 last1,
132 : InputIter2 first2, InputIter2 last2,
133 : BinaryPred pred = std::less_equal<>{}) {
134 : for (; first2 != last2; ++first1, ++first2) {
135 : if (first1 == last1 or pred(*first1, *first2)) {
136 : return true;
137 : } else if (pred(*first2, *first1)) {
138 : return false;
139 : }
140 : }
141 : return false;
142 : }
143 :
144 : template <class T, size_t Size>
145 0 : inline constexpr bool operator==(const array<T, Size>& x,
146 : const array<T, Size>& y) {
147 : return equal(x.data_, x.data_ + Size, y.data_); // NOLINT
148 : }
149 :
150 : template <class T, size_t Size>
151 0 : inline constexpr bool operator!=(const array<T, Size>& lhs,
152 : const array<T, Size>& rhs) {
153 : return not(lhs == rhs);
154 : }
155 :
156 : template <class T, size_t Size>
157 0 : inline constexpr bool operator<(const array<T, Size>& lhs,
158 : const array<T, Size>& rhs) {
159 : return lexicographical_compare(lhs.__elems_, lhs.__elems_ + Size,
160 : rhs.__elems_, rhs.__elems_ + Size);
161 : }
162 :
163 : template <class T, size_t Size>
164 0 : inline constexpr bool operator>(const array<T, Size>& lhs,
165 : const array<T, Size>& rhs) {
166 : return rhs < lhs;
167 : }
168 :
169 : template <class T, size_t Size>
170 0 : inline constexpr bool operator<=(const array<T, Size>& lhs,
171 : const array<T, Size>& rhs) {
172 : return not(rhs < lhs);
173 : }
174 :
175 : template <class T, size_t Size>
176 0 : inline constexpr bool operator>=(const array<T, Size>& lhs,
177 : const array<T, Size>& rhs) {
178 : return not(lhs < rhs);
179 : }
180 :
181 : template <typename T>
182 0 : inline std::ostream& operator<<(std::ostream& os, const array<T, 0>& /*a*/) {
183 : return os << "()";
184 : }
185 :
186 : template <typename T, size_t N>
187 0 : inline std::ostream& operator<<(std::ostream& os, const array<T, N>& a) {
188 : os << '(';
189 : for (size_t i = 0; i < N - 1; ++i) {
190 : os << a[i] << ',';
191 : }
192 : if (N > 0) {
193 : os << a[N - 1];
194 : }
195 : os << ')';
196 : return os;
197 : }
198 : } // namespace cpp20
199 :
200 : namespace detail {
201 : template <typename List, size_t... indices,
202 : Requires<not tt::is_a_v<tmpl::list, tmpl::front<List>>> = nullptr>
203 : inline constexpr auto make_cpp20_array_from_list_helper(
204 : std::integer_sequence<size_t, indices...> /*meta*/)
205 : -> cpp20::array<std::decay_t<decltype(tmpl::front<List>::value)>,
206 : tmpl::size<List>::value> {
207 : return cpp20::array<std::decay_t<decltype(tmpl::front<List>::value)>,
208 : tmpl::size<List>::value>{
209 : {tmpl::at<List, tmpl::size_t<indices>>::value...}};
210 : }
211 : } // namespace detail
212 :
213 : /// \ingroup ConstantExpressionsGroup
214 : /// Make an array from a typelist that holds std::integral_constant's all of
215 : /// which have the same `value_type`
216 : ///
217 : /// \tparam List the typelist of std::integral_constant's
218 : /// \return array of integral values from the typelist
219 : template <typename List,
220 : Requires<not tt::is_a_v<tmpl::list, tmpl::front<List>>> = nullptr>
221 1 : inline constexpr auto make_cpp20_array_from_list()
222 : -> cpp20::array<std::decay_t<decltype(tmpl::front<List>::value)>,
223 : tmpl::size<List>::value> {
224 : return detail::make_cpp20_array_from_list_helper<List>(
225 : std::make_integer_sequence<size_t, tmpl::size<List>::value>{});
226 : }
227 :
228 : template <typename TypeForZero,
229 : Requires<not tt::is_a_v<tmpl::list, TypeForZero>> = nullptr>
230 : inline constexpr cpp20::array<std::decay_t<TypeForZero>, 0>
231 0 : make_cpp20_array_from_list() {
232 : return cpp20::array<std::decay_t<TypeForZero>, 0>{{}};
233 : }
234 :
235 : namespace detail {
236 : template <typename T, size_t Size, size_t... Is>
237 : inline constexpr cpp20::array<T, Size> convert_to_cpp20_array_impl(
238 : const std::array<T, Size>& t, std::index_sequence<Is...> /*meta*/) {
239 : return {{t[Is]...}};
240 : }
241 : } // namespace detail
242 :
243 : template <typename T, size_t Size, size_t... Is>
244 0 : inline constexpr cpp20::array<T, Size> convert_to_cpp20_array(
245 : const std::array<T, Size>& t) {
246 : return detail::convert_to_cpp20_array_impl(t,
247 : std::make_index_sequence<Size>{});
248 : }
|
