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 <type_traits>
10 : #include <utility>
11 : #include <variant>
12 :
13 : #include "Options/String.hpp"
14 : #include "Utilities/ErrorHandling/Error.hpp"
15 : #include "Utilities/Gsl.hpp"
16 : #include "Utilities/Requires.hpp"
17 : #include "Utilities/Serialization/PupStlCpp17.hpp"
18 : #include "Utilities/TMPL.hpp"
19 :
20 : /// \cond
21 : namespace Options {
22 : template <typename... AlternativeLists>
23 : struct Alternatives;
24 : } // namespace Options
25 : namespace PUP {
26 : class er;
27 : } // namespace PUP
28 : /// \endcond
29 :
30 : /// \ingroup DataStructuresGroup
31 : ///
32 : /// TaggedVariant and related functionality.
33 1 : namespace variants {
34 : namespace TaggedVariant_detail {
35 : template <typename R, typename Variant, typename Tag, typename Visitor>
36 : struct VisitAlternative;
37 : } // namespace TaggedVariant_detail
38 :
39 : /// \cond
40 : template <typename... Tags>
41 : class TaggedVariant;
42 : template <typename... Tags>
43 : constexpr bool operator==(const TaggedVariant<Tags...>& a,
44 : const TaggedVariant<Tags...>& b);
45 : template <typename... Tags>
46 : constexpr bool operator<(const TaggedVariant<Tags...>& a,
47 : const TaggedVariant<Tags...>& b);
48 : /// \endcond
49 :
50 : /// \ingroup DataStructuresGroup
51 : ///
52 : /// A class similar to `std::variant`, but indexed by tag structs.
53 : ///
54 : /// \see variants::get, variants::get_if, variants::holds_alternative,
55 : /// variants::visit
56 : template <typename... Tags>
57 1 : class TaggedVariant {
58 : private:
59 : static_assert(sizeof...(Tags) > 0);
60 : static_assert(
61 : std::is_same_v<tmpl::remove_duplicates<TaggedVariant>, TaggedVariant>,
62 : "TaggedVariant cannot have duplicate tags.");
63 :
64 : template <typename Tag>
65 0 : static constexpr size_t data_index =
66 : tmpl::index_of<TaggedVariant, Tag>::value;
67 :
68 : public:
69 : /// A default constructed instance has the first tag active.
70 1 : TaggedVariant() = default;
71 0 : TaggedVariant(const TaggedVariant&) = default;
72 0 : TaggedVariant(TaggedVariant&&) = default;
73 0 : TaggedVariant& operator=(const TaggedVariant&) = default;
74 0 : TaggedVariant& operator=(TaggedVariant&&) = default;
75 0 : ~TaggedVariant() = default;
76 :
77 : /// Construct with \p Tag active, using \p args to construct the
78 : /// contained object.
79 : ///
80 : /// \snippet DataStructures/Test_TaggedVariant.cpp construct in_place_type
81 : template <
82 : typename Tag, typename... Args,
83 : Requires<(... or std::is_same_v<Tag, Tags>) and
84 : std::is_constructible_v<typename Tag::type, Args...>> = nullptr>
85 1 : constexpr explicit TaggedVariant(std::in_place_type_t<Tag> /*meta*/,
86 : Args&&... args)
87 : : data_(std::in_place_index<data_index<Tag>>,
88 : std::forward<Args>(args)...) {}
89 :
90 : /// Construct the contained object from \p args. Only available if
91 : /// the TaggedVariant only has one tag.
92 : ///
93 : /// \snippet DataStructures/Test_TaggedVariant.cpp construct single
94 : template <typename... Args,
95 : Requires<sizeof...(Tags) == 1 and
96 : std::is_constructible_v<
97 : typename tmpl::front<TaggedVariant>::type, Args...>> =
98 : nullptr>
99 1 : constexpr explicit TaggedVariant(Args&&... args)
100 : : TaggedVariant(std::in_place_type<tmpl::front<TaggedVariant>>,
101 : std::forward<Args>(args)...) {}
102 :
103 : /// A TaggedVariant can be implicitly move-converted to another
104 : /// variant with a superset of the tags.
105 : ///
106 : /// \snippet DataStructures/Test_TaggedVariant.cpp convert
107 : /// @{
108 : template <typename... OtherTags,
109 : Requires<tmpl::size<tmpl::list_difference<
110 : TaggedVariant<OtherTags...>, TaggedVariant>>::value ==
111 : 0> = nullptr>
112 : // NOLINTNEXTLINE(google-explicit-constructor)
113 1 : constexpr TaggedVariant(TaggedVariant<OtherTags...>&& other)
114 : : TaggedVariant(visit(
115 : []<typename Tag>(
116 : std::pair<tmpl::type_<Tag>, typename Tag::type&&> entry) {
117 : return TaggedVariant(std::in_place_type<Tag>,
118 : std::move(entry.second));
119 : },
120 : std::move(other))) {}
121 :
122 : template <typename... OtherTags,
123 : Requires<tmpl::size<tmpl::list_difference<
124 : TaggedVariant<OtherTags...>, TaggedVariant>>::value ==
125 : 0> = nullptr>
126 1 : constexpr TaggedVariant& operator=(TaggedVariant<OtherTags...>&& other) {
127 : visit(
128 : [&]<typename Tag>(
129 : std::pair<tmpl::type_<Tag>, typename Tag::type&&> entry) {
130 : emplace<Tag>(std::move(entry.second));
131 : },
132 : std::move(other));
133 : return *this;
134 : }
135 : /// @}
136 :
137 : /// The index into the `Tags...` of the active object.
138 1 : constexpr size_t index() const { return data_.index(); }
139 :
140 : /// See `std::variant::valueless_by_exception`.
141 1 : constexpr bool valueless_by_exception() const {
142 : return data_.valueless_by_exception();
143 : }
144 :
145 : /// Destroys the contained object and actives \p Tag, constructing a
146 : /// new value from \p args.
147 : ///
148 : /// \snippet DataStructures/Test_TaggedVariant.cpp emplace
149 : template <
150 : typename Tag, typename... Args,
151 : Requires<(... or std::is_same_v<Tag, Tags>) and
152 : std::is_constructible_v<typename Tag::type, Args...>> = nullptr>
153 1 : constexpr typename Tag::type& emplace(Args&&... args) {
154 : return data_.template emplace<data_index<Tag>>(std::forward<Args>(args)...);
155 : }
156 :
157 0 : constexpr void swap(TaggedVariant& other) noexcept(noexcept(
158 : (... and (std::is_nothrow_move_constructible_v<typename Tags::type> and
159 : std::is_nothrow_swappable_v<typename Tags::type>)))) {
160 : data_.swap(other.data_);
161 : }
162 :
163 0 : void pup(PUP::er& p) { p | data_; }
164 :
165 : /// A TaggedVariant over option tags can be parsed as any of them.
166 : /// @{
167 1 : static constexpr Options::String help = "One of multiple options";
168 1 : using options = tmpl::list<Options::Alternatives<tmpl::list<Tags>...>>;
169 : template <typename Tag>
170 1 : explicit TaggedVariant(tmpl::list<Tag> /*meta*/, typename Tag::type value)
171 : : TaggedVariant(std::in_place_type<Tag>, std::move(value)) {}
172 : /// @}
173 :
174 : private:
175 : template <typename R, typename Variant, typename Tag, typename Visitor>
176 : friend struct TaggedVariant_detail::VisitAlternative;
177 :
178 : template <typename Tag, typename... Tags2>
179 0 : friend constexpr typename Tag::type& get(TaggedVariant<Tags2...>& variant);
180 : template <typename Tag, typename... Tags2>
181 0 : friend constexpr const typename Tag::type& get(
182 : const TaggedVariant<Tags2...>& variant);
183 : template <typename Tag, typename... Tags2>
184 0 : friend constexpr typename Tag::type&& get(TaggedVariant<Tags2...>&& variant);
185 : template <typename Tag, typename... Tags2>
186 0 : friend constexpr const typename Tag::type&& get(
187 : const TaggedVariant<Tags2...>&& variant);
188 :
189 0 : friend constexpr bool operator== <Tags...>(const TaggedVariant<Tags...>& a,
190 : const TaggedVariant<Tags...>& b);
191 0 : friend constexpr bool operator< <Tags...>(const TaggedVariant<Tags...>& a,
192 : const TaggedVariant<Tags...>& b);
193 :
194 : friend struct std::hash<TaggedVariant>;
195 :
196 0 : std::variant<typename Tags::type...> data_;
197 : };
198 :
199 : namespace TaggedVariant_detail {
200 : template <typename... Tags>
201 : constexpr bool is_variant_or_derived(const TaggedVariant<Tags...>* /*meta*/) {
202 : return true;
203 : }
204 : // NOLINTNEXTLINE(cert-dcl50-cpp) - variadic function
205 : constexpr bool is_variant_or_derived(...) { return false; }
206 :
207 : template <typename Tag, typename Value>
208 : constexpr std::pair<tmpl::type_<Tag>, Value&&> make_visitor_pair(
209 : Value&& value) {
210 : return {tmpl::type_<Tag>{}, std::forward<Value>(value)};
211 : }
212 :
213 : struct DeduceReturn;
214 :
215 : template <typename R, typename Variant, typename Tag, typename Visitor>
216 : struct VisitAlternative {
217 : static constexpr R apply(Variant&& variant, const Visitor& visitor) {
218 : return std::forward<Visitor>(visitor)(make_visitor_pair<Tag>(
219 : get<std::decay_t<Variant>::template data_index<Tag>>(
220 : std::forward<Variant>(variant).data_)));
221 : }
222 : };
223 :
224 : template <typename Variant, typename Tag, typename Visitor>
225 : struct VisitAlternative<void, Variant, Tag, Visitor> {
226 : static constexpr void apply(Variant&& variant, const Visitor& visitor) {
227 : std::forward<Visitor>(visitor)(make_visitor_pair<Tag>(
228 : get<std::decay_t<Variant>::template data_index<Tag>>(
229 : std::forward<Variant>(variant).data_)));
230 : }
231 : };
232 :
233 : template <typename Variant, typename Tag, typename Visitor>
234 : struct VisitAlternative<DeduceReturn, Variant, Tag, Visitor> {
235 : static constexpr decltype(auto) apply(Variant&& variant,
236 : const Visitor& visitor) {
237 : return std::forward<Visitor>(visitor)(make_visitor_pair<Tag>(
238 : get<std::decay_t<Variant>::template data_index<Tag>>(
239 : std::forward<Variant>(variant).data_)));
240 : }
241 : };
242 :
243 : template <typename... Tags>
244 : constexpr TaggedVariant<Tags...>& as_variant(TaggedVariant<Tags...>& variant) {
245 : return variant;
246 : }
247 : template <typename... Tags>
248 : constexpr const TaggedVariant<Tags...>& as_variant(
249 : const TaggedVariant<Tags...>& variant) {
250 : return variant;
251 : }
252 : template <typename... Tags>
253 : constexpr TaggedVariant<Tags...>&& as_variant(
254 : TaggedVariant<Tags...>&& variant) {
255 : return std::move(variant);
256 : }
257 : template <typename... Tags>
258 : constexpr const TaggedVariant<Tags...>&& as_variant(
259 : const TaggedVariant<Tags...>&& variant) {
260 : return std::move(variant);
261 : }
262 :
263 : template <typename R, typename Visitor, typename... Variants>
264 : constexpr decltype(auto) visit_impl(Visitor&& visitor) {
265 : return std::forward<Visitor>(visitor)();
266 : }
267 :
268 : template <typename R, typename Variant, typename Visitor,
269 : typename DecayedVariant = std::decay_t<Variant>>
270 : struct VisitJumpTable;
271 :
272 : template <typename R, typename Variant, typename Visitor, typename... Tags>
273 : struct VisitJumpTable<R, Variant, Visitor, TaggedVariant<Tags...>> {
274 : static constexpr std::array value{
275 : VisitAlternative<R, Variant, Tags, Visitor>::apply...};
276 : };
277 :
278 : template <typename R, typename Visitor, typename FirstVariant,
279 : typename... Variants>
280 : constexpr decltype(auto) visit_impl(Visitor&& visitor,
281 : FirstVariant&& first_variant,
282 : Variants&&... variants) {
283 : const auto recurse = [&]<typename Arg>(Arg&& first_arg) {
284 : return visit_impl<R>(
285 : [&]<typename... Rest>(Rest&&... rest) {
286 : return std::forward<Visitor>(visitor)(std::forward<Arg>(first_arg),
287 : std::forward<Rest>(rest)...);
288 : },
289 : std::forward<Variants>(variants)...);
290 : };
291 : if (UNLIKELY(first_variant.valueless_by_exception())) {
292 : throw std::bad_variant_access{};
293 : }
294 : return gsl::at(VisitJumpTable<R, FirstVariant, decltype(recurse)>::value,
295 : first_variant.index())(
296 : std::forward<FirstVariant>(first_variant), recurse);
297 : }
298 : } // namespace TaggedVariant_detail
299 :
300 : /// Call \p visitor with the contents of one or more variants.
301 : ///
302 : /// Calls \p visitor with the contents of each variant as arguments,
303 : /// passed as `std::pair<tmpl::type_<Tag>, typename Tag::type ref>`,
304 : /// where `Tag` is the active tag of the variant and `ref` is a
305 : /// reference qualifier matching that of the passed variant.
306 : ///
307 : /// If the template parameter \p R is supplied, the result is
308 : /// implicitly converted to that type (which may be `void`).
309 : /// Otherwise it is deduced from the return type of \p visitor, which
310 : /// must be the same for all tags in the variant.
311 : ///
312 : /// \warning Unlike `visit` for `std::variant`, the types of the
313 : /// visitor arguments do not allow for implicit conversions between
314 : /// reference types. If the visitor expects, for example,
315 : /// `std::pair<tmpl::type_<Tag>, const typename Tag::type&>`, the caller must
316 : /// ensure that the passed variant is a const lvalue.
317 : ///
318 : /// \snippet DataStructures/Test_TaggedVariant.cpp visit
319 : /// @{
320 : template <typename Visitor, typename... Variants,
321 : Requires<(... and TaggedVariant_detail::is_variant_or_derived(
322 : std::add_pointer_t<std::remove_reference_t<
323 : Variants>>{}))> = nullptr>
324 1 : constexpr decltype(auto) visit(Visitor&& visitor, Variants&&... variants) {
325 : return TaggedVariant_detail::visit_impl<TaggedVariant_detail::DeduceReturn>(
326 : visitor,
327 : TaggedVariant_detail::as_variant(std::forward<Variants>(variants))...);
328 : }
329 :
330 : template <typename R, typename Visitor, typename... Variants,
331 : Requires<(... and TaggedVariant_detail::is_variant_or_derived(
332 : std::add_pointer_t<std::remove_reference_t<
333 : Variants>>{}))> = nullptr>
334 1 : constexpr R visit(Visitor&& visitor, Variants&&... variants) {
335 : return TaggedVariant_detail::visit_impl<R>(
336 : visitor,
337 : TaggedVariant_detail::as_variant(std::forward<Variants>(variants))...);
338 : }
339 : /// @}
340 :
341 : /// Check whether \p Tag is active.
342 : template <typename Tag, typename... Tags>
343 1 : constexpr bool holds_alternative(const TaggedVariant<Tags...>& variant) {
344 : return variant.index() == tmpl::index_of<TaggedVariant<Tags...>, Tag>::value;
345 : }
346 :
347 : /// Access the contained object. Throws `std::bad_variant_access` if
348 : /// \p Tag is not active.
349 : /// @{
350 : template <typename Tag, typename... Tags>
351 1 : constexpr typename Tag::type& get(TaggedVariant<Tags...>& variant) {
352 : return get<TaggedVariant<Tags...>::template data_index<Tag>>(variant.data_);
353 : }
354 : template <typename Tag, typename... Tags>
355 1 : constexpr const typename Tag::type& get(const TaggedVariant<Tags...>& variant) {
356 : return get<TaggedVariant<Tags...>::template data_index<Tag>>(variant.data_);
357 : }
358 : template <typename Tag, typename... Tags>
359 1 : constexpr typename Tag::type&& get(TaggedVariant<Tags...>&& variant) {
360 : return get<TaggedVariant<Tags...>::template data_index<Tag>>(
361 : std::move(variant.data_));
362 : }
363 : template <typename Tag, typename... Tags>
364 1 : constexpr const typename Tag::type&& get(
365 : const TaggedVariant<Tags...>&& variant) {
366 : return get<TaggedVariant<Tags...>::template data_index<Tag>>(
367 : std::move(variant.data_));
368 : }
369 : /// @}
370 :
371 : /// Returns a pointer to the contained object if \p variant is a
372 : /// non-null pointer and \p Tag is active. Otherwise, returns
373 : /// `nullptr`.
374 : /// @{
375 : template <typename Tag, typename... Tags>
376 1 : constexpr const typename Tag::type* get_if(
377 : const TaggedVariant<Tags...>* variant) {
378 : if (variant != nullptr and holds_alternative<Tag>(*variant)) {
379 : return &get<Tag>(*variant);
380 : } else {
381 : return nullptr;
382 : }
383 : }
384 : template <typename Tag, typename... Tags>
385 1 : constexpr typename Tag::type* get_if(TaggedVariant<Tags...>* variant) {
386 : if (variant != nullptr and holds_alternative<Tag>(*variant)) {
387 : return &get<Tag>(*variant);
388 : } else {
389 : return nullptr;
390 : }
391 : }
392 : /// @}
393 :
394 : template <typename... Tags>
395 0 : constexpr bool operator==(const TaggedVariant<Tags...>& a,
396 : const TaggedVariant<Tags...>& b) {
397 : return a.data_ == b.data_;
398 : }
399 : template <typename... Tags>
400 0 : constexpr bool operator!=(const TaggedVariant<Tags...>& a,
401 : const TaggedVariant<Tags...>& b) {
402 : return not(a == b);
403 : }
404 : template <typename... Tags>
405 0 : constexpr bool operator<(const TaggedVariant<Tags...>& a,
406 : const TaggedVariant<Tags...>& b) {
407 : return a.data_ < b.data_;
408 : }
409 : template <typename... Tags>
410 0 : constexpr bool operator>(const TaggedVariant<Tags...>& a,
411 : const TaggedVariant<Tags...>& b) {
412 : return b < a;
413 : }
414 : template <typename... Tags>
415 0 : constexpr bool operator<=(const TaggedVariant<Tags...>& a,
416 : const TaggedVariant<Tags...>& b) {
417 : return not(b < a);
418 : }
419 : template <typename... Tags>
420 0 : constexpr bool operator>=(const TaggedVariant<Tags...>& a,
421 : const TaggedVariant<Tags...>& b) {
422 : return not(a < b);
423 : }
424 :
425 : /// Comparison operators against single-tag variants. Primarily useful
426 : /// in tests.
427 : /// @{
428 : template <typename... Tags, typename Tag,
429 : Requires<(sizeof...(Tags) > 1 and
430 : (... or std::is_same_v<Tags, Tag>))> = nullptr>
431 1 : constexpr bool operator==(const TaggedVariant<Tags...>& a,
432 : const TaggedVariant<Tag>& b) {
433 : return holds_alternative<Tag>(a) and get<Tag>(a) == get<Tag>(b);
434 : }
435 : template <typename... Tags, typename Tag,
436 : Requires<(sizeof...(Tags) > 1 and
437 : (... or std::is_same_v<Tags, Tag>))> = nullptr>
438 1 : constexpr bool operator==(const TaggedVariant<Tag>& a,
439 : const TaggedVariant<Tags...>& b) {
440 : return b == a;
441 : }
442 : template <typename... Tags, typename Tag,
443 : Requires<(sizeof...(Tags) > 1 and
444 : (... or std::is_same_v<Tags, Tag>))> = nullptr>
445 1 : constexpr bool operator!=(const TaggedVariant<Tags...>& a,
446 : const TaggedVariant<Tag>& b) {
447 : return not(a == b);
448 : }
449 : template <typename... Tags, typename Tag,
450 : Requires<(sizeof...(Tags) > 1 and
451 : (... or std::is_same_v<Tags, Tag>))> = nullptr>
452 1 : constexpr bool operator!=(const TaggedVariant<Tag>& a,
453 : const TaggedVariant<Tags...>& b) {
454 : return not(a == b);
455 : }
456 : /// @}
457 :
458 : template <
459 : typename... Tags,
460 : Requires<(... and (std::is_move_constructible_v<typename Tags::type> and
461 : std::is_swappable_v<typename Tags::type>))> = nullptr>
462 0 : constexpr void swap(TaggedVariant<Tags...>& a,
463 : TaggedVariant<Tags...>& b) noexcept(noexcept(a.swap(b))) {
464 : a.swap(b);
465 : }
466 : } // namespace variants
467 :
468 : namespace std {
469 : template <typename... Tags>
470 : // https://github.com/llvm/llvm-project/issues/45454
471 : // NOLINTNEXTLINE(cert-dcl58-cpp)
472 : struct hash<::variants::TaggedVariant<Tags...>> {
473 : size_t operator()(const ::variants::TaggedVariant<Tags...>& variant) const {
474 : return std::hash<decltype(variant.data_)>{}(variant.data_);
475 : }
476 : };
477 : } // namespace std
|
