SeqAn3 3.2.0-rc.1
The Modern C++ library for sequence analysis.
common_tuple.hpp
Go to the documentation of this file.
1// -----------------------------------------------------------------------------------------------------
2// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
3// Copyright (c) 2016-2021, Knut Reinert & MPI für molekulare Genetik
4// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
5// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
6// -----------------------------------------------------------------------------------------------------
7
13#pragma once
14
15#include <tuple>
16
17#include <seqan3/utility/tuple/common_pair.hpp>
18#include <seqan3/utility/type_pack/traits.hpp>
19
20#include <range/v3/utility/common_tuple.hpp>
21
22namespace seqan3
23{
24
29template <class... Types>
30class common_tuple : public std::tuple<Types...>
31{
32private:
34 using base_t = std::tuple<Types...>;
35
37 template <typename tuple_like_t, std::size_t... N>
38 common_tuple(tuple_like_t && other, std::integer_sequence<size_t, N...>) :
39 base_t((std::forward<std::tuple_element_t<N, tuple_like_t>>(std::get<N>(other)))...)
40 {}
41
42public:
46 common_tuple() = default;
47 common_tuple(common_tuple const &) = default;
48 common_tuple & operator=(common_tuple const &) = default;
49 ~common_tuple() = default;
51
55 base_t & as_base() noexcept
56 {
57 return *this;
58 }
59
63 base_t const & as_base() const noexcept
64 {
65 return *this;
66 }
67
72 template <class... UTypes>
73 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes &> && ...)
74 constexpr common_tuple(UTypes &... other) : base_t(other...)
75 {}
76
77 template <class... UTypes>
78 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
79 constexpr common_tuple(UTypes const &... other) : base_t(other...)
80 {}
81
82 template <class... UTypes>
83 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes> && ...)
84 constexpr common_tuple(UTypes &&... other) : base_t(std::forward<UTypes>(other)...)
85 {}
86
87 template <class... UTypes>
88 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
89 constexpr common_tuple(UTypes const &&... other) : base_t(std::forward<UTypes const>(other)...)
90 {}
93
98 template <class... UTypes>
99 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes &> && ...)
100 constexpr common_tuple(common_tuple<UTypes...> & other) : common_tuple(other, std::index_sequence_for<Types...>{})
101 {}
102
103 template <class... UTypes>
104 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
105 constexpr common_tuple(common_tuple<UTypes...> const & other) :
106 common_tuple(other, std::index_sequence_for<Types...>{})
107 {}
108
109 template <class... UTypes>
110 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes> && ...)
111 constexpr common_tuple(common_tuple<UTypes...> && other) :
112 common_tuple(std::move(other), std::index_sequence_for<Types...>{})
113 {}
114
115 template <class... UTypes>
116 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
117 constexpr common_tuple(common_tuple<UTypes...> const && other) :
118 common_tuple(std::move(other), std::index_sequence_for<Types...>{})
119 {}
122
127 template <class... UTypes>
128 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes &> && ...)
129 constexpr common_tuple(common_pair<UTypes...> & other) : common_tuple(other, std::index_sequence_for<Types...>{})
130 {}
131
132 template <class... UTypes>
133 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
134 constexpr common_tuple(common_pair<UTypes...> const & other) :
135 common_tuple(other, std::index_sequence_for<Types...>{})
136 {}
137
138 template <class... UTypes>
139 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes> && ...)
140 constexpr common_tuple(common_pair<UTypes...> && other) :
141 common_tuple(std::move(other), std::index_sequence_for<Types...>{})
142 {}
143
144 template <class... UTypes>
145 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
146 constexpr common_tuple(common_pair<UTypes...> const && other) :
147 common_tuple(std::move(other), std::index_sequence_for<Types...>{})
148 {}
151
156 template <class... UTypes>
157 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes &> && ...)
158 constexpr common_tuple(std::tuple<UTypes...> & other) : common_tuple(other, std::index_sequence_for<Types...>{})
159 {}
160
161 template <class... UTypes>
162 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
163 constexpr common_tuple(std::tuple<UTypes...> const & other) :
164 common_tuple(other, std::index_sequence_for<Types...>{})
165 {}
166
167 template <class... UTypes>
168 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes> && ...)
169 constexpr common_tuple(std::tuple<UTypes...> && other) :
170 common_tuple(std::move(other), std::index_sequence_for<Types...>{})
171 {}
172
173 template <class... UTypes>
174 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
175 constexpr common_tuple(std::tuple<UTypes...> const && other) :
176 common_tuple(std::move(other), std::index_sequence_for<Types...>{})
177 {}
178
183 template <class... UTypes>
184 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes &> && ...)
185 constexpr common_tuple(std::pair<UTypes...> & other) : common_tuple(other, std::index_sequence_for<Types...>{})
186 {}
187
188 template <class... UTypes>
189 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
190 constexpr common_tuple(std::pair<UTypes...> const & other) :
191 common_tuple(other, std::index_sequence_for<Types...>{})
192 {}
193
194 template <class... UTypes>
195 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes> && ...)
196 constexpr common_tuple(std::pair<UTypes...> && other) :
197 common_tuple(std::move(other), std::index_sequence_for<Types...>{})
198 {}
199
200 template <class... UTypes>
201 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
202 constexpr common_tuple(std::pair<UTypes...> const && other) :
203 common_tuple(std::move(other), std::index_sequence_for<Types...>{})
204 {}
207
212 template <class... UTypes>
213 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes &> && ...)
214 constexpr common_tuple & operator=(common_tuple<UTypes...> & other)
215 {
216 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
217 {
218 ((std::get<N>(*this) = std::get<N>(other)), ...);
219 }
220 (std::index_sequence_for<Types...>{});
221
222 return *this;
223 }
224
225 template <class... UTypes>
226 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
227 constexpr common_tuple & operator=(common_tuple<UTypes...> const & other)
228 {
229 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
230 {
231 ((std::get<N>(*this) = std::get<N>(other)), ...);
232 }
233 (std::index_sequence_for<Types...>{});
234
235 return *this;
236 }
237
238 template <class... UTypes>
239 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes> && ...)
240 constexpr common_tuple & operator=(common_tuple<UTypes...> && other)
241 {
242 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
243 {
244 ((std::get<N>(*this) = std::get<N>(other)), ...);
245 }
246 (std::index_sequence_for<Types...>{});
247
248 return *this;
249 }
250
251 template <class... UTypes>
252 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
253 constexpr common_tuple & operator=(common_tuple<UTypes...> const && other)
254 {
255 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
256 {
257 ((std::get<N>(*this) = std::get<N>(other)), ...);
258 }
259 (std::index_sequence_for<Types...>{});
260
261 return *this;
262 }
263
264 template <class... UTypes>
265 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes &> && ...)
266 constexpr common_tuple const & operator=(common_tuple<UTypes...> & other) const
267 {
268 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
269 {
270 ((std::get<N>(*this) = std::get<N>(other)), ...);
271 }
272 (std::index_sequence_for<Types...>{});
273
274 return *this;
275 }
276
277 template <class... UTypes>
278 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
279 constexpr common_tuple const & operator=(common_tuple<UTypes...> const & other) const
280 {
281 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
282 {
283 ((std::get<N>(*this) = std::get<N>(other)), ...);
284 }
285 (std::index_sequence_for<Types...>{});
286
287 return *this;
288 }
289
290 template <class... UTypes>
291 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes> && ...)
292 constexpr common_tuple const & operator=(common_tuple<UTypes...> && other) const
293 {
294 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
295 {
296 ((std::get<N>(*this) = std::get<N>(other)), ...);
297 }
298 (std::index_sequence_for<Types...>{});
299
300 return *this;
301 }
302
303 template <class... UTypes>
304 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
305 constexpr common_tuple const & operator=(common_tuple<UTypes...> const && other) const
306 {
307 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
308 {
309 ((std::get<N>(*this) = std::get<N>(other)), ...);
310 }
311 (std::index_sequence_for<Types...>{});
312
313 return *this;
314 }
317
322 template <class... UTypes>
323 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes &> && ...)
324 constexpr common_tuple & operator=(common_pair<UTypes...> & other)
325 {
326 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
327 {
328 ((std::get<N>(*this) = std::get<N>(other)), ...);
329 }
330 (std::index_sequence_for<Types...>{});
331
332 return *this;
333 }
334
335 template <class... UTypes>
336 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
337 constexpr common_tuple & operator=(common_pair<UTypes...> const & other)
338 {
339 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
340 {
341 ((std::get<N>(*this) = std::get<N>(other)), ...);
342 }
343 (std::index_sequence_for<Types...>{});
344
345 return *this;
346 }
347
348 template <class... UTypes>
349 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes> && ...)
350 constexpr common_tuple & operator=(common_pair<UTypes...> && other)
351 {
352 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
353 {
354 ((std::get<N>(*this) = std::get<N>(other)), ...);
355 }
356 (std::index_sequence_for<Types...>{});
357
358 return *this;
359 }
360
361 template <class... UTypes>
362 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
363 constexpr common_tuple & operator=(common_pair<UTypes...> const && other)
364 {
365 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
366 {
367 ((std::get<N>(*this) = std::get<N>(other)), ...);
368 }
369 (std::index_sequence_for<Types...>{});
370
371 return *this;
372 }
373
374 template <class... UTypes>
375 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes &> && ...)
376 constexpr common_tuple const & operator=(common_pair<UTypes...> & other) const
377 {
378 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
379 {
380 ((std::get<N>(*this) = std::get<N>(other)), ...);
381 }
382 (std::index_sequence_for<Types...>{});
383
384 return *this;
385 }
386
387 template <class... UTypes>
388 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
389 constexpr common_tuple const & operator=(common_pair<UTypes...> const & other) const
390 {
391 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
392 {
393 ((std::get<N>(*this) = std::get<N>(other)), ...);
394 }
395 (std::index_sequence_for<Types...>{});
396
397 return *this;
398 }
399
400 template <class... UTypes>
401 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes> && ...)
402 constexpr common_tuple const & operator=(common_pair<UTypes...> && other) const
403 {
404 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
405 {
406 ((std::get<N>(*this) = std::get<N>(other)), ...);
407 }
408 (std::index_sequence_for<Types...>{});
409
410 return *this;
411 }
412
413 template <class... UTypes>
414 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
415 constexpr common_tuple const & operator=(common_pair<UTypes...> const && other) const
416 {
417 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
418 {
419 ((std::get<N>(*this) = std::get<N>(other)), ...);
420 }
421 (std::index_sequence_for<Types...>{});
422
423 return *this;
424 }
427
432 template <class... UTypes>
433 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes &> && ...)
434 constexpr common_tuple & operator=(std::tuple<UTypes...> & other)
435 {
436 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
437 {
438 ((std::get<N>(*this) = std::get<N>(other)), ...);
439 }
440 (std::index_sequence_for<Types...>{});
441
442 return *this;
443 }
444
445 template <class... UTypes>
446 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
447 constexpr common_tuple & operator=(std::tuple<UTypes...> const & other)
448 {
449 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
450 {
451 ((std::get<N>(*this) = std::get<N>(other)), ...);
452 }
453 (std::index_sequence_for<Types...>{});
454
455 return *this;
456 }
457
458 template <class... UTypes>
459 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes> && ...)
460 constexpr common_tuple & operator=(std::tuple<UTypes...> && other)
461 {
462 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
463 {
464 ((std::get<N>(*this) = std::get<N>(other)), ...);
465 }
466 (std::index_sequence_for<Types...>{});
467
468 return *this;
469 }
470
471 template <class... UTypes>
472 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
473 constexpr common_tuple & operator=(std::tuple<UTypes...> const && other)
474 {
475 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
476 {
477 ((std::get<N>(*this) = std::get<N>(other)), ...);
478 }
479 (std::index_sequence_for<Types...>{});
480
481 return *this;
482 }
483
484 template <class... UTypes>
485 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes &> && ...)
486 constexpr common_tuple const & operator=(std::tuple<UTypes...> & other) const
487 {
488 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
489 {
490 ((std::get<N>(*this) = std::get<N>(other)), ...);
491 }
492 (std::index_sequence_for<Types...>{});
493
494 return *this;
495 }
496
497 template <class... UTypes>
498 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
499 constexpr common_tuple const & operator=(std::tuple<UTypes...> const & other) const
500 {
501 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
502 {
503 ((std::get<N>(*this) = std::get<N>(other)), ...);
504 }
505 (std::index_sequence_for<Types...>{});
506
507 return *this;
508 }
509
510 template <class... UTypes>
511 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes> && ...)
512 constexpr common_tuple const & operator=(std::tuple<UTypes...> && other) const
513 {
514 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
515 {
516 ((std::get<N>(*this) = std::get<N>(other)), ...);
517 }
518 (std::index_sequence_for<Types...>{});
519
520 return *this;
521 }
522
523 template <class... UTypes>
524 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
525 constexpr common_tuple const & operator=(std::tuple<UTypes...> const && other) const
526 {
527 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
528 {
529 ((std::get<N>(*this) = std::get<N>(other)), ...);
530 }
531 (std::index_sequence_for<Types...>{});
532
533 return *this;
534 }
537
542 template <class... UTypes>
543 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes &> && ...)
544 constexpr common_tuple & operator=(std::pair<UTypes...> & other)
545 {
546 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
547 {
548 ((std::get<N>(*this) = std::get<N>(other)), ...);
549 }
550 (std::index_sequence_for<Types...>{});
551
552 return *this;
553 }
554
555 template <class... UTypes>
556 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
557 constexpr common_tuple & operator=(std::pair<UTypes...> const & other)
558 {
559 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
560 {
561 ((std::get<N>(*this) = std::get<N>(other)), ...);
562 }
563 (std::index_sequence_for<Types...>{});
564
565 return *this;
566 }
567
568 template <class... UTypes>
569 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes> && ...)
570 constexpr common_tuple & operator=(std::pair<UTypes...> && other)
571 {
572 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
573 {
574 ((std::get<N>(*this) = std::get<N>(other)), ...);
575 }
576 (std::index_sequence_for<Types...>{});
577
578 return *this;
579 }
580
581 template <class... UTypes>
582 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
583 constexpr common_tuple & operator=(std::pair<UTypes...> const && other)
584 {
585 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
586 {
587 ((std::get<N>(*this) = std::get<N>(other)), ...);
588 }
589 (std::index_sequence_for<Types...>{});
590
591 return *this;
592 }
593
594 template <class... UTypes>
595 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes &> && ...)
596 constexpr common_tuple const & operator=(std::pair<UTypes...> & other) const
597 {
598 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
599 {
600 ((std::get<N>(*this) = std::get<N>(other)), ...);
601 }
602 (std::index_sequence_for<Types...>{});
603
604 return *this;
605 }
606
607 template <class... UTypes>
608 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
609 constexpr common_tuple const & operator=(std::pair<UTypes...> const & other) const
610 {
611 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
612 {
613 ((std::get<N>(*this) = std::get<N>(other)), ...);
614 }
615 (std::index_sequence_for<Types...>{});
616
617 return *this;
618 }
619
620 template <class... UTypes>
621 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes> && ...)
622 constexpr common_tuple const & operator=(std::pair<UTypes...> && other) const
623 {
624 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
625 {
626 ((std::get<N>(*this) = std::get<N>(other)), ...);
627 }
628 (std::index_sequence_for<Types...>{});
629
630 return *this;
631 }
632
633 template <class... UTypes>
634 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
635 constexpr common_tuple const & operator=(std::pair<UTypes...> const && other) const
636 {
637 [&]<size_t... N>(std::integer_sequence<size_t, N...>)
638 {
639 ((std::get<N>(*this) = std::get<N>(other)), ...);
640 }
641 (std::index_sequence_for<Types...>{});
642
643 return *this;
644 }
647
652 template <class... UTypes>
653 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<UTypes, Types &> && ...)
654 operator std::tuple<UTypes...>() &
655 {
656 return std::make_from_tuple<std::tuple<UTypes...>>(*this);
657 }
658
659 template <class... UTypes>
660 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<UTypes, Types const> && ...)
661 operator std::tuple<UTypes...>() const &
662 {
663 return std::make_from_tuple<std::tuple<UTypes...>>(*this);
664 }
665
666 template <class... UTypes>
667 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<UTypes, Types> && ...)
668 operator std::tuple<UTypes...>() &&
669 {
670 return std::make_from_tuple<std::tuple<UTypes...>>(std::move(*this));
671 }
672
673 template <class... UTypes>
674 requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<UTypes, Types const> && ...)
675 operator std::tuple<UTypes...>() const &&
676 {
677 return std::make_from_tuple<std::tuple<UTypes...>>(std::move(*this));
678 }
681
691 template <class... UTypes>
692 requires (sizeof...(Types) == sizeof...(UTypes))
693 && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); } // Defer instantiation
694 constexpr friend bool operator==(common_tuple const & lhs, common_tuple<UTypes...> const & rhs)
695 {
696 static_assert((std::equality_comparable_with<Types, UTypes> && ...));
697 return lhs.as_base() == rhs.as_base();
698 }
699
706 template <class... UTypes>
707 requires (sizeof...(Types) == sizeof...(UTypes))
708 && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); } // Defer instantiation
709 constexpr friend bool operator!=(common_tuple const & lhs, common_tuple<UTypes...> const & rhs)
710 {
711 return lhs.as_base() != rhs.as_base();
712 }
713
720 template <class... UTypes>
721 requires (sizeof...(Types) == sizeof...(UTypes))
722 && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); } // Defer instantiation
723 constexpr friend bool operator<(common_tuple const & lhs, common_tuple<UTypes...> const & rhs)
724 {
725 return lhs.as_base() < rhs.as_base();
726 }
727
734 template <class... UTypes>
735 requires (sizeof...(Types) == sizeof...(UTypes))
736 && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); } // Defer instantiation
737 constexpr friend bool operator<=(common_tuple const & lhs, common_tuple<UTypes...> const & rhs)
738 {
739 return lhs.as_base() <= rhs.as_base();
740 }
741
748 template <class... UTypes>
749 requires (sizeof...(Types) == sizeof...(UTypes))
750 && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); } // Defer instantiation
751 constexpr friend bool operator>(common_tuple const & lhs, common_tuple<UTypes...> const & rhs)
752 {
753 return lhs.as_base() > rhs.as_base();
754 }
755
762 template <class... UTypes>
763 requires (sizeof...(Types) == sizeof...(UTypes))
764 && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); } // Defer instantiation
765 constexpr friend bool operator>=(common_tuple const & lhs, common_tuple<UTypes...> const & rhs)
766 {
767 return lhs.as_base() >= rhs.as_base();
768 }
769
770#ifdef __cpp_lib_three_way_comparison
778 template <class... UTypes>
779 requires (sizeof...(Types) == sizeof...(UTypes))
780 && requires { requires (std::three_way_comparable_with<Types, UTypes> && ...); } // Defer instantiation
781 constexpr friend auto operator<=>(common_tuple const & lhs, common_tuple<UTypes...> const & rhs)
782 {
783 return lhs.as_base() <=> rhs.as_base();
784 }
785#endif // __cpp_lib_three_way_comparison
787
797 template <class... UTypes>
798 requires (sizeof...(Types) == sizeof...(UTypes))
799 && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); } // Defer instantiation
800 constexpr friend bool operator==(common_tuple const & lhs, std::tuple<UTypes...> const & rhs)
801 {
802 return lhs.as_base() == rhs;
803 }
804
811 template <class... UTypes>
812 requires (sizeof...(Types) == sizeof...(UTypes))
813 && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); } // Defer instantiation
814 constexpr friend bool operator!=(common_tuple const & lhs, std::tuple<UTypes...> const & rhs)
815 {
816 return lhs.as_base() != rhs;
817 }
818
825 template <class... UTypes>
826 requires (sizeof...(Types) == sizeof...(UTypes))
827 && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); } // Defer instantiation
828 constexpr friend bool operator<(common_tuple const & lhs, std::tuple<UTypes...> const & rhs)
829 {
830 return lhs.as_base() < rhs;
831 }
832
839 template <class... UTypes>
840 requires (sizeof...(Types) == sizeof...(UTypes))
841 && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); } // Defer instantiation
842 constexpr friend bool operator<=(common_tuple const & lhs, std::tuple<UTypes...> const & rhs)
843 {
844 return lhs.as_base() <= rhs;
845 }
846
853 template <class... UTypes>
854 requires (sizeof...(Types) == sizeof...(UTypes))
855 && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); } // Defer instantiation
856 constexpr friend bool operator>(common_tuple const & lhs, std::tuple<UTypes...> const & rhs)
857 {
858 return lhs.as_base() > rhs;
859 }
860
867 template <class... UTypes>
868 requires (sizeof...(Types) == sizeof...(UTypes))
869 && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); } // Defer instantiation
870 constexpr friend bool operator>=(common_tuple const & lhs, std::tuple<UTypes...> const & rhs)
871 {
872 return lhs.as_base() >= rhs;
873 }
874
875#ifdef __cpp_lib_three_way_comparison
883 template <class... UTypes>
884 requires (sizeof...(Types) == sizeof...(UTypes))
885 && requires { requires (std::three_way_comparable_with<Types, UTypes> && ...); } // Defer instantiation
886 constexpr friend auto operator<=>(common_tuple const & lhs, std::tuple<UTypes...> const & rhs)
887 {
888 return lhs.as_base() <=> rhs;
889 }
890#endif // __cpp_lib_three_way_comparison
892};
893
895template <class... UTypes>
896common_tuple(UTypes...) -> common_tuple<UTypes...>;
897
898} // namespace seqan3
899
901namespace std
902{
903
904template <typename... args>
905struct tuple_size<seqan3::common_tuple<args...>> : public tuple_size<std::tuple<args...>>
906{};
907
908template <size_t index, typename... args>
909struct tuple_element<index, seqan3::common_tuple<args...>> : public tuple_element<index, std::tuple<args...>>
910{};
911
912template <class... Ts, class... Us>
913 requires requires { typename seqan3::common_tuple<std::common_type_t<Ts, Us>...>; }
914struct common_type<seqan3::common_tuple<Ts...>, seqan3::common_tuple<Us...>>
915{
916 using type = seqan3::common_tuple<std::common_type_t<Ts, Us>...>;
917};
918
919template <class... Ts, class... Us>
920 requires requires { typename seqan3::common_tuple<std::common_type_t<Ts, Us>...>; }
921struct common_type<std::tuple<Ts...>, seqan3::common_tuple<Us...>>
922{
923 using type = seqan3::common_tuple<std::common_type_t<Ts, Us>...>;
924};
925
926template <class... Ts, class... Us>
927 requires requires { typename seqan3::common_tuple<std::common_type_t<Ts, Us>...>; }
928struct common_type<seqan3::common_tuple<Ts...>, std::tuple<Us...>>
929{
930 using type = seqan3::common_tuple<std::common_type_t<Ts, Us>...>;
931};
932
933template <class... Ts, class... Us, template <class> class TQual, template <class> class UQual>
934 requires requires { typename seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
935struct basic_common_reference<seqan3::common_tuple<Ts...>, seqan3::common_tuple<Us...>, TQual, UQual>
936{
937 using type = seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
938};
939
940template <class... Ts, class... Us, template <class> class TQual, template <class> class UQual>
941 requires requires { typename seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
942struct basic_common_reference<seqan3::common_tuple<Ts...>, std::tuple<Us...>, TQual, UQual>
943{
944 using type = seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
945};
946
947template <class... Ts, class... Us, template <class> class TQual, template <class> class UQual>
948 requires requires { typename seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
949struct basic_common_reference<std::tuple<Ts...>, seqan3::common_tuple<Us...>, TQual, UQual>
950{
951 using type = seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
952};
953
954template <std::size_t i, typename... types>
955constexpr std::tuple_element_t<i, seqan3::common_tuple<types...>> & get(seqan3::common_tuple<types...> & t) noexcept
956 requires (i < sizeof...(types))
957{
958 return std::get<i>(static_cast<std::tuple<types...> &>(t));
959}
960
961template <std::size_t i, typename... types>
962constexpr std::tuple_element_t<i, seqan3::common_tuple<types...>> const &
963get(seqan3::common_tuple<types...> const & t) noexcept
964 requires (i < sizeof...(types))
965{
966 return std::get<i>(static_cast<std::tuple<types...> const &>(t));
967}
968
969template <std::size_t i, typename... types>
970constexpr std::tuple_element_t<i, seqan3::common_tuple<types...>> && get(seqan3::common_tuple<types...> && t) noexcept
971 requires (i < sizeof...(types))
972{
973 return std::get<i>(static_cast<std::tuple<types...> &&>(std::move(t)));
974}
975
976template <std::size_t i, typename... types>
977constexpr std::tuple_element_t<i, seqan3::common_tuple<types...>> const &&
978get(seqan3::common_tuple<types...> const && t) noexcept
979 requires (i < sizeof...(types))
980{
981 return std::get<i>(static_cast<std::tuple<types...> const &&>(std::move(t)));
982}
983
984template <typename type, typename... types>
985constexpr type & get(seqan3::common_tuple<types...> & t) noexcept
986 requires (seqan3::pack_traits::count<type, types...> == 1)
987{
988 return std::get<type>(static_cast<std::tuple<types...> &>(t));
989}
990
991template <typename type, typename... types>
992constexpr type const & get(seqan3::common_tuple<types...> const & t) noexcept
993 requires (seqan3::pack_traits::count<type, types...> == 1)
994{
995 return std::get<type>(static_cast<std::tuple<types...> const &>(t));
996}
997
998template <typename type, typename... types>
999constexpr type && get(seqan3::common_tuple<types...> && t) noexcept
1000 requires (seqan3::pack_traits::count<type, types...> == 1)
1001{
1002 return std::get<type>(static_cast<std::tuple<types...> &&>(std::move(t)));
1003}
1004
1005template <typename type, typename... types>
1006constexpr type const && get(seqan3::common_tuple<types...> const && t) noexcept
1007 requires (seqan3::pack_traits::count<type, types...> == 1)
1008{
1009 return std::get<type>(static_cast<std::tuple<types...> const &&>(std::move(t)));
1010}
1011
1012} // namespace std
1014
1016// Definitions for range-v3 -- same as in std
1017namespace concepts
1018{
1019
1020template <class... T>
1021struct common_type;
1022
1023template <class... Ts, class... Us>
1024 requires requires { typename seqan3::common_tuple<std::common_type_t<Ts, Us>...>; }
1025struct common_type<seqan3::common_tuple<Ts...>, seqan3::common_tuple<Us...>>
1026{
1027 using type = seqan3::common_tuple<std::common_type_t<Ts, Us>...>;
1028};
1029
1030template <class... Ts, class... Us>
1031 requires requires { typename seqan3::common_tuple<std::common_type_t<Ts, Us>...>; }
1032struct common_type<std::tuple<Ts...>, seqan3::common_tuple<Us...>>
1033{
1034 using type = seqan3::common_tuple<std::common_type_t<Ts, Us>...>;
1035};
1036
1037template <class... Ts, class... Us>
1038 requires requires { typename seqan3::common_tuple<std::common_type_t<Ts, Us>...>; }
1039struct common_type<seqan3::common_tuple<Ts...>, std::tuple<Us...>>
1040{
1041 using type = seqan3::common_tuple<std::common_type_t<Ts, Us>...>;
1042};
1043
1044template <class T, class U, template <class> class TQual, template <class> class UQual>
1045struct basic_common_reference;
1046
1047template <class... Ts, class... Us, template <class> class TQual, template <class> class UQual>
1048 requires requires { typename seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
1049struct basic_common_reference<seqan3::common_tuple<Ts...>, seqan3::common_tuple<Us...>, TQual, UQual>
1050{
1051 using type = seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
1052};
1053
1054template <class... Ts, class... Us, template <class> class TQual, template <class> class UQual>
1055 requires requires { typename seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
1056struct basic_common_reference<seqan3::common_tuple<Ts...>, std::tuple<Us...>, TQual, UQual>
1057{
1058 using type = seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
1059};
1060
1061template <class... Ts, class... Us, template <class> class TQual, template <class> class UQual>
1062 requires requires { typename seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
1063struct basic_common_reference<std::tuple<Ts...>, seqan3::common_tuple<Us...>, TQual, UQual>
1064{
1065 using type = seqan3::common_tuple<std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
1066};
1067
1068} // namespace concepts
seqan3::common_tuple
A std::tuple implementation that incorporates most changes from C++23's standard library.
Definition: common_tuple.hpp:31
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(common_pair< UTypes... > &&other)
Assigns from common_pair.
Definition: common_tuple.hpp:350
seqan3::common_tuple::common_tuple
constexpr common_tuple(std::pair< UTypes... > &&other)
Constructs from std::pair.
Definition: common_tuple.hpp:196
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(std::tuple< UTypes... > const &&other)
Assigns from std::tuple.
Definition: common_tuple.hpp:473
seqan3::common_tuple::common_tuple
constexpr common_tuple(common_tuple< UTypes... > &other)
Constructs from common_tuple.
Definition: common_tuple.hpp:100
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(std::tuple< UTypes... > &other) const
Assigns from std::tuple.
Definition: common_tuple.hpp:486
seqan3::common_tuple::common_tuple
common_tuple(tuple_like_t &&other, std::integer_sequence< size_t, N... >)
Constructs by unfolding another tuple-like object.
Definition: common_tuple.hpp:38
seqan3::common_tuple::common_tuple
constexpr common_tuple(common_pair< UTypes... > &&other)
Constructs from common_pair.
Definition: common_tuple.hpp:140
seqan3::common_tuple::common_tuple
constexpr common_tuple(common_tuple< UTypes... > const &other)
Constructs from common_tuple.
Definition: common_tuple.hpp:105
seqan3::common_tuple::operator>
constexpr friend bool operator>(common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
Checks whether lhs is greater than rhs.
Definition: common_tuple.hpp:751
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(common_pair< UTypes... > const &other)
Assigns from common_pair.
Definition: common_tuple.hpp:337
seqan3::common_tuple::as_base
base_t & as_base() noexcept
Returns the common_tuple as the underlying std::tuple type.
Definition: common_tuple.hpp:55
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(std::tuple< UTypes... > const &other) const
Assigns from std::tuple.
Definition: common_tuple.hpp:499
seqan3::common_tuple::common_tuple
constexpr common_tuple(UTypes &... other)
Constructs from arguments.
Definition: common_tuple.hpp:74
seqan3::common_tuple::common_tuple
constexpr common_tuple(std::tuple< UTypes... > const &other)
Constructs from std::tuple.
Definition: common_tuple.hpp:163
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(common_tuple< UTypes... > &&other)
Assigns from common_tuple.
Definition: common_tuple.hpp:240
seqan3::common_tuple::common_tuple
constexpr common_tuple(std::pair< UTypes... > &other)
Constructs from std::pair.
Definition: common_tuple.hpp:185
seqan3::common_tuple::operator<=>
constexpr friend auto operator<=>(common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
Performs a three-way comparison between lhs and rhs
Definition: common_tuple.hpp:781
seqan3::common_tuple::common_tuple
constexpr common_tuple(UTypes const &&... other)
Constructs from arguments.
Definition: common_tuple.hpp:89
seqan3::common_tuple::common_tuple
constexpr common_tuple(std::tuple< UTypes... > &&other)
Constructs from std::tuple.
Definition: common_tuple.hpp:169
seqan3::common_tuple::common_tuple
constexpr common_tuple(common_pair< UTypes... > const &other)
Constructs from common_pair.
Definition: common_tuple.hpp:134
seqan3::common_tuple::operator>=
constexpr friend bool operator>=(common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
Checks whether lhs is greater than or equal to rhs.
Definition: common_tuple.hpp:870
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(common_tuple< UTypes... > const &other) const
Assigns from common_tuple.
Definition: common_tuple.hpp:279
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(std::pair< UTypes... > const &&other) const
Assigns from std::pair.
Definition: common_tuple.hpp:635
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(common_pair< UTypes... > const &other) const
Assigns from common_pair.
Definition: common_tuple.hpp:389
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(std::pair< UTypes... > const &other)
Assigns from std::pair.
Definition: common_tuple.hpp:557
seqan3::common_tuple::operator<=
constexpr friend bool operator<=(common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
Checks whether lhs is less than or equal to rhs.
Definition: common_tuple.hpp:737
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(common_tuple< UTypes... > const &other)
Assigns from common_tuple.
Definition: common_tuple.hpp:227
seqan3::common_tuple::common_tuple
constexpr common_tuple(std::pair< UTypes... > const &other)
Constructs from std::pair.
Definition: common_tuple.hpp:190
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(common_tuple< UTypes... > &other)
Assigns from common_tuple.
Definition: common_tuple.hpp:214
seqan3::common_tuple::common_tuple
common_tuple()=default
Defaulted.
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(std::pair< UTypes... > const &&other)
Assigns from std::pair.
Definition: common_tuple.hpp:583
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(common_pair< UTypes... > const &&other)
Assigns from common_pair.
Definition: common_tuple.hpp:363
seqan3::common_tuple::common_tuple
constexpr common_tuple(std::tuple< UTypes... > const &&other)
Constructs from std::tuple.
Definition: common_tuple.hpp:175
seqan3::common_tuple::common_tuple
common_tuple(common_tuple const &)=default
Defaulted.
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(std::pair< UTypes... > &other) const
Assigns from std::pair.
Definition: common_tuple.hpp:596
seqan3::common_tuple::operator>
constexpr friend bool operator>(common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
Checks whether lhs is greater than rhs.
Definition: common_tuple.hpp:856
seqan3::common_tuple::common_tuple
constexpr common_tuple(UTypes &&... other)
Constructs from arguments.
Definition: common_tuple.hpp:84
seqan3::common_tuple::operator!=
constexpr friend bool operator!=(common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
Checks whether lhs and rhs are unequal.
Definition: common_tuple.hpp:814
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(std::pair< UTypes... > &&other) const
Assigns from std::pair.
Definition: common_tuple.hpp:622
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(std::tuple< UTypes... > &other)
Assigns from std::tuple.
Definition: common_tuple.hpp:434
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(std::tuple< UTypes... > &&other) const
Assigns from std::tuple.
Definition: common_tuple.hpp:512
seqan3::common_tuple::operator=
common_tuple & operator=(common_tuple const &)=default
Defaulted.
seqan3::common_tuple::common_tuple
constexpr common_tuple(common_tuple< UTypes... > &&other)
Constructs from common_tuple.
Definition: common_tuple.hpp:111
seqan3::common_tuple::operator<=>
constexpr friend auto operator<=>(common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
Performs a three-way comparison between lhs and rhs
Definition: common_tuple.hpp:886
seqan3::common_tuple::common_tuple
constexpr common_tuple(common_pair< UTypes... > &other)
Constructs from common_pair.
Definition: common_tuple.hpp:129
seqan3::common_tuple::operator==
constexpr friend bool operator==(common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
Checks whether lhs and rhs are equal.
Definition: common_tuple.hpp:694
seqan3::common_tuple::operator!=
constexpr friend bool operator!=(common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
Checks whether lhs and rhs are unequal.
Definition: common_tuple.hpp:709
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(common_pair< UTypes... > &&other) const
Assigns from common_pair.
Definition: common_tuple.hpp:402
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(common_tuple< UTypes... > &&other) const
Assigns from common_tuple.
Definition: common_tuple.hpp:292
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(common_pair< UTypes... > &other)
Assigns from common_pair.
Definition: common_tuple.hpp:324
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(common_pair< UTypes... > &other) const
Assigns from common_pair.
Definition: common_tuple.hpp:376
seqan3::common_tuple::operator==
constexpr friend bool operator==(common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
Checks whether lhs and rhs are equal.
Definition: common_tuple.hpp:800
seqan3::common_tuple::~common_tuple
~common_tuple()=default
seqan3::common_tuple::common_tuple
constexpr common_tuple(common_tuple< UTypes... > const &&other)
Constructs from common_tuple.
Definition: common_tuple.hpp:117
seqan3::common_tuple::operator<=
constexpr friend bool operator<=(common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
Checks whether lhs is less than or equal to rhs.
Definition: common_tuple.hpp:842
seqan3::common_tuple::common_tuple
constexpr common_tuple(common_pair< UTypes... > const &&other)
Constructs from common_pair.
Definition: common_tuple.hpp:146
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(common_tuple< UTypes... > const &&other) const
Assigns from common_tuple.
Definition: common_tuple.hpp:305
seqan3::common_tuple::operator<
constexpr friend bool operator<(common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
Checks whether lhs is less than rhs.
Definition: common_tuple.hpp:723
seqan3::common_tuple::as_base
base_t const & as_base() const noexcept
Returns the common_tuple as the underlying std::tuple type.
Definition: common_tuple.hpp:63
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(common_pair< UTypes... > const &&other) const
Assigns from common_pair.
Definition: common_tuple.hpp:415
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(std::tuple< UTypes... > &&other)
Assigns from std::tuple.
Definition: common_tuple.hpp:460
seqan3::common_tuple::common_tuple
constexpr common_tuple(std::tuple< UTypes... > &other)
Constructs from std::tuple.
Definition: common_tuple.hpp:158
seqan3::common_tuple::common_tuple
constexpr common_tuple(UTypes const &... other)
Constructs from arguments.
Definition: common_tuple.hpp:79
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(common_tuple< UTypes... > const &&other)
Assigns from common_tuple.
Definition: common_tuple.hpp:253
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(std::tuple< UTypes... > const &&other) const
Assigns from std::tuple.
Definition: common_tuple.hpp:525
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(std::pair< UTypes... > const &other) const
Assigns from std::pair.
Definition: common_tuple.hpp:609
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(std::tuple< UTypes... > const &other)
Assigns from std::tuple.
Definition: common_tuple.hpp:447
seqan3::common_tuple::operator<
constexpr friend bool operator<(common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
Checks whether lhs is less than rhs.
Definition: common_tuple.hpp:828
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(std::pair< UTypes... > &&other)
Assigns from std::pair.
Definition: common_tuple.hpp:570
seqan3::common_tuple::common_tuple
constexpr common_tuple(std::pair< UTypes... > const &&other)
Constructs from std::pair.
Definition: common_tuple.hpp:202
seqan3::common_tuple::operator>=
constexpr friend bool operator>=(common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
Checks whether lhs is greater than or equal to rhs.
Definition: common_tuple.hpp:765
seqan3::common_tuple::operator=
constexpr common_tuple const & operator=(common_tuple< UTypes... > &other) const
Assigns from common_tuple.
Definition: common_tuple.hpp:266
seqan3::common_tuple::operator=
constexpr common_tuple & operator=(std::pair< UTypes... > &other)
Assigns from std::pair.
Definition: common_tuple.hpp:544
common_pair.hpp
Provides seqan3::common_pair.
seqan3::pack_traits::count
constexpr ptrdiff_t count
Count the occurrences of a type in a pack.
Definition: traits.hpp:164
tuple_size
Subconcept definition for seqan3::tuple_like to test for std::tuple_size-interface.
std::make_from_tuple
T make_from_tuple(T... args)
seqan3
The main SeqAn3 namespace.
Definition: aligned_sequence_concept.hpp:29
seqan3::common_tuple
common_tuple(UTypes...) -> common_tuple< UTypes... >
Class template argument deduction guide.
seqan3::get
constexpr auto const & get(configuration< configs_t... > const &config) noexcept
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: configuration.hpp:415
std
SeqAn specific customisations in the standard namespace.
seqan3::common_pair
A std::pair implementation that incorporates most changes from C++23's standard library.
Definition: common_pair.hpp:28
traits.hpp
Provides various traits for template packs.