sumty  0.1.0
Better sum types for C++
utils.hpp
1 /* Copyright 2023 Jack A Bernard Jr.
2  *
3  * Licensed under the Apache License, Version 2.0 (the License);
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an AS IS BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef SUMTY_DETAIL_UTILS_HPP
17 #define SUMTY_DETAIL_UTILS_HPP
18 
19 #include "sumty/detail/fwd.hpp"
20 #include "sumty/detail/traits.hpp"
21 #include "sumty/utils.hpp"
22 
23 #include <cstddef>
24 #include <cstdint>
25 #include <limits>
26 #include <type_traits>
27 
28 namespace sumty::detail {
29 
30 template <typename T, typename = void>
31 struct is_sumty_empty : std::false_type {};
32 
33 template <typename T>
34 struct is_sumty_empty<T, std::enable_if_t<std::is_empty_v<T> && std::is_trivial_v<T>>>
35  : std::true_type {};
36 
37 template <typename T>
38 static inline constexpr bool is_sumty_empty_v = is_sumty_empty<T>::value;
39 
40 template <uint64_t COUNT, typename = void>
41 struct discriminant {
42  using type = uint64_t;
43 };
44 
45 template <uint64_t COUNT>
46 struct discriminant<COUNT,
47  std::enable_if_t<(COUNT <= (std::numeric_limits<uint8_t>::max)())>> {
48  using type = uint8_t;
49 };
50 
51 template <uint64_t COUNT>
52 struct discriminant<COUNT,
53  std::enable_if_t<(COUNT <= (std::numeric_limits<uint16_t>::max)() &&
54  COUNT > (std::numeric_limits<uint8_t>::max)())>> {
55  using type = uint16_t;
56 };
57 
58 template <uint64_t COUNT>
59 struct discriminant<COUNT,
60  std::enable_if_t<(COUNT <= (std::numeric_limits<uint32_t>::max)() &&
61  COUNT > (std::numeric_limits<uint16_t>::max)())>> {
62  using type = uint32_t;
63 };
64 
65 template <uint64_t COUNT>
66 using discriminant_t = typename discriminant<COUNT>::type;
67 
68 template <size_t IDX, typename... T>
69 struct select;
70 
71 template <typename T0, typename... TN>
72 struct select<0, T0, TN...> {
73  using type = T0;
74 };
75 
76 template <size_t IDX, typename T0, typename... TN>
77 struct select<IDX, T0, TN...> {
78  using type = typename select<IDX - 1, TN...>::type;
79 };
80 
81 template <size_t IDX>
82 struct select<IDX> {
83  using type = void;
84 };
85 
86 template <size_t IDX, typename... T>
87 using select_t = typename select<IDX, T...>::type;
88 
89 template <typename... T>
90 using first_t = select_t<0, T...>;
91 
92 template <typename... T>
93 using last_t = select_t<sizeof...(T) - 1, T...>;
94 
95 template <typename... T>
96 struct type_list {
97  template <size_t I>
98  using nth = select_t<I, T...>;
99 
100  template <typename U>
101  using push_back = type_list<T..., U>;
102 
103  template <typename U>
104  using push_front = type_list<U, T...>;
105 };
106 
107 template <typename F, typename RealArgs, typename... Args>
108 struct invoke_result_impl;
109 
110 template <typename F, typename... Args>
111 struct invoke_result_impl<F, type_list<Args...>> {
112  using type = std::invoke_result_t<F, Args...>;
113 };
114 
115 template <typename F, typename RealArgs, typename... Args>
116 struct invoke_result_impl<F, RealArgs, void, Args...>
117  : invoke_result_impl<F, RealArgs, void_t, Args...> {};
118 
119 template <typename F, typename RealArgs, typename FirstArg, typename... Args>
120 struct invoke_result_impl<F, RealArgs, FirstArg, Args...>
121  : invoke_result_impl<F, typename RealArgs::template push_back<FirstArg>, Args...> {};
122 
123 template <typename F, typename... Args>
124 struct invoke_result : invoke_result_impl<F, type_list<>, Args...> {};
125 
126 template <typename F, typename... Args>
127 using invoke_result_t = typename invoke_result<F, Args...>::type;
128 
129 template <size_t N, typename T, typename... U>
130 struct type_count_impl;
131 
132 template <size_t N, typename T>
133 struct type_count_impl<N, T> : std::integral_constant<size_t, N> {};
134 
135 template <size_t N, typename T, typename U0, typename... UN>
136 struct type_count_impl<N, T, U0, UN...> : type_count_impl<N, T, UN...> {};
137 
138 template <size_t N, typename T, typename... UN>
139 struct type_count_impl<N, T, T, UN...> : type_count_impl<N + 1, T, UN...> {};
140 
141 template <typename T, typename... U>
142 struct type_count : type_count_impl<0, T, U...> {};
143 
144 template <typename T, typename... U>
145 static inline constexpr size_t type_count_v = type_count<T, U...>::value;
146 
147 template <typename T, typename... U>
148 struct is_unique : std::integral_constant<bool, type_count_v<T, U...> == 1> {};
149 
150 template <typename T, typename... U>
151 static inline constexpr bool is_unique_v = is_unique<T, U...>::value;
152 
153 template <typename T, typename... U>
154 struct type_list_contains
155  : std::integral_constant<bool, (false || ... || std::is_same_v<T, U>)> {};
156 
157 template <typename T, typename... U>
158 static inline constexpr bool type_list_contains_v = type_list_contains<T, U...>::value;
159 
160 template <typename... T>
161 struct all_unique;
162 
163 template <>
164 struct all_unique<> : std::true_type {};
165 
166 template <typename T>
167 struct all_unique<T> : std::true_type {};
168 
169 template <typename T0, typename... TN>
170 struct all_unique<T0, TN...>
171  : std::integral_constant<bool,
172  !type_list_contains_v<T0, TN...> && all_unique<TN...>::value> {
173 };
174 
175 template <typename... T>
176 static inline constexpr bool all_unique_v = all_unique<T...>::value;
177 
178 template <typename T, typename... U>
179 struct is_uniquely_convertible
180  : std::integral_constant<bool,
181  (0 + ... +
182  static_cast<size_t>(
183  traits<U>::template is_convertible_from<T>)) == 1> {};
184 
185 template <typename T, typename... U>
186 static inline constexpr bool is_uniquely_convertible_v =
187  is_uniquely_convertible<T, U...>::value;
188 
189 template <typename T, typename... U>
190 struct is_uniquely_constructible
191  : std::integral_constant<
192  bool,
193  (0 + ... + static_cast<size_t>(traits<U>::template is_constructible<T>)) == 1> {};
194 
195 template <typename T, typename... U>
196 static inline constexpr bool is_uniquely_constructible_v =
197  is_uniquely_constructible<T, U...>::value;
198 
199 template <typename T, typename... U>
200 struct is_uniquely_explicitly_constructible
201  : std::integral_constant<bool,
202  (0 + ... +
203  static_cast<size_t>(
204  traits<U>::template is_constructible<T> &&
205  !traits<U>::template is_convertible_from<T>)) == 1> {};
206 
207 template <typename T, typename... U>
208 static inline constexpr bool is_uniquely_explicitly_constructible_v =
209  is_uniquely_explicitly_constructible<T, U...>::value;
210 
211 template <typename T, typename... U>
212 struct is_uniquely_assignable
213  : std::integral_constant<
214  bool,
215  (0 + ... + static_cast<size_t>(traits<U>::template is_assignable<T>)) == 1> {};
216 
217 template <typename T, typename... U>
218 static inline constexpr bool is_uniquely_assignable_v =
219  is_uniquely_assignable<T, U...>::value;
220 
221 template <typename T, typename U0, typename... UN>
222 constexpr size_t index_of_impl() noexcept {
223  if constexpr (std::is_same_v<T, U0>) {
224  return 0;
225  } else {
226  return 1 + index_of_impl<T, UN...>();
227  }
228 }
229 
230 template <typename T, typename... U>
231 struct index_of : std::integral_constant<size_t, index_of_impl<T, U...>()> {};
232 
233 template <typename T, typename... U>
234 static inline constexpr size_t index_of_v = index_of<T, U...>::value;
235 
236 template <typename T>
237 struct is_variant : std::false_type {};
238 
239 template <typename... T>
240 struct is_variant<variant<T...>> : std::true_type {};
241 
242 template <typename T>
243 static inline constexpr bool is_variant_v = is_variant<T>::value;
244 
245 template <typename T>
246 struct is_option : std::false_type {};
247 
248 template <typename T>
249 struct is_option<option<T>> : std::true_type {};
250 
251 template <typename T>
252 static inline constexpr bool is_option_v = is_option<T>::value;
253 
254 template <typename T>
255 struct is_result : std::false_type {};
256 
257 template <typename T, typename E>
258 struct is_result<result<T, E>> : std::true_type {};
259 
260 template <typename T>
261 static inline constexpr bool is_result_v = is_result<T>::value;
262 
263 template <typename ES1, typename ES2>
264 struct is_subset_of_impl;
265 
266 template <typename... T>
267 struct is_subset_of_impl<error_set<>, error_set<T...>> : std::true_type {};
268 
269 template <typename T11, typename... T1N, typename... T2>
270 struct is_subset_of_impl<error_set<T11, T1N...>, error_set<T2...>>
271  : std::integral_constant<
272  bool,
273  is_unique_v<T11, T2...> &&
274  is_subset_of_impl<error_set<T1N...>, error_set<T2...>>::value> {};
275 
276 template <typename ES1, typename ES2>
277 static inline constexpr bool is_subset_of_impl_v = is_subset_of_impl<ES1, ES2>::value;
278 
279 template <typename ES1, typename ES2>
280 struct is_equivalent_impl : std::integral_constant<bool,
281  is_subset_of_impl_v<ES1, ES2> &&
282  is_subset_of_impl_v<ES2, ES1>> {};
283 
284 template <typename ES1, typename ES2>
285 static inline constexpr bool is_equivalent_impl_v = is_equivalent_impl<ES1, ES2>::value;
286 
287 template <typename T>
288 struct is_error_set : std::false_type {};
289 
290 template <typename... T>
291 struct is_error_set<error_set<T...>> : std::true_type {};
292 
293 template <typename T>
294 static inline constexpr bool is_error_set_v = is_error_set<T>::value;
295 
296 } // namespace sumty::detail
297 
298 #endif