14#ifndef RANGES_V3_UTILITY_COMMON_TUPLE_HPP
15#define RANGES_V3_UTILITY_COMMON_TUPLE_HPP
25#include <range/v3/detail/adl_get.hpp>
31#include <range/v3/detail/prologue.hpp>
38 template<
typename... Us,
typename Tup, std::size_t... Is>
41 return std::tuple<Us...>{adl_get<Is>(
static_cast<Tup &&
>(tup))...};
44#ifdef RANGES_WORKAROUND_MSVC_786312
45 template<std::size_t,
typename...>
48 template<
typename,
typename>
49 inline constexpr bool argstructible =
false;
50 template<std::size_t N,
typename... Ts,
typename... Us>
51 inline constexpr bool argstructible<args_<N, Ts...>, args_<N, Us...>> =
52 (META_IS_CONSTRUCTIBLE(Ts, Us) && ...);
54 template<
typename,
typename>
55 inline constexpr bool argsignable =
false;
56 template<std::size_t N,
typename... Ts,
typename... Us>
57 inline constexpr bool argsignable<args_<N, Ts...>, args_<N, Us...>> =
58 (std::is_assignable_v<Ts &, Us> && ...);
61 template<std::size_t N,
typename... Ts>
64 template<
typename... Us>
65 args_(args_<N, Us...>, meta::if_c<
66#ifdef RANGES_WORKAROUND_MSVC_786312
67 argstructible<args_, args_<N, Us...>>
74 template<
typename... Us>
76#ifdef RANGES_WORKAROUND_MSVC_786312
77 argsignable<args_, args_<N, Us...>>,
82 operator=(args_<N, Us...>)
87 template<
typename... Ts>
88 using args = args_<
sizeof...(Ts), Ts...>;
89 template<
typename... Ts>
90 using rargs = args_<
sizeof...(Ts), Ts &...>;
94 template<
typename... Ts>
95 struct common_tuple : _tuple_wrapper_::forward_tuple_interface<std::tuple<Ts...>>
98 template<
typename That, std::size_t... Is>
100 : common_tuple::forward_tuple_interface{
101 detail::adl_get<Is>(
static_cast<That &&
>(that))...}
103 struct element_assign_
105 template<
typename T,
typename U>
106 int operator()(T & t, U && u)
const
108 t =
static_cast<U &&
>(u);
118 meta::and_c<std::is_nothrow_default_constructible<Ts>::value...>::value)
119 requires default_constructible<std::tuple<Ts...>>)
120 : common_tuple::forward_tuple_interface{}
122 template(
typename... Us)(
123 requires constructible_from<detail::args<Ts...>, detail::args<Us...>>)
126 : common_tuple::forward_tuple_interface{
static_cast<Us &&
>(us)...}
128 template(
typename... Us)(
129 requires constructible_from<detail::args<Ts...>, detail::rargs<Us...>>)
135 template(
typename... Us)(
136 requires constructible_from<detail::args<Ts...>, detail::rargs<Us const...>>)
139 std::is_nothrow_constructible<Ts, Us const &>::value...>::value)
142 template(
typename... Us)(
143 requires constructible_from<detail::args<Ts...>, detail::args<Us...>>)
149 template(
typename... Us)(
150 requires constructible_from<detail::args<Ts...>, detail::rargs<Us...>>)
156 template(
typename... Us)(
157 requires constructible_from<detail::args<Ts...>, detail::rargs<Us const...>>)
160 std::is_nothrow_constructible<Ts, Us const &>::value...>::value)
163 template(
typename... Us)(
164 requires constructible_from<detail::args<Ts...>, detail::args<Us...>>)
171 std::tuple<Ts...> & base()
noexcept
175 std::tuple<Ts...>
const & base()
const noexcept
181 template(
typename... Us)(
182 requires std::is_assignable<detail::args<Ts...> &,
183 detail::rargs<Us...>>::value)
184 common_tuple & operator=(std::tuple<Us...> & that)
noexcept(
187 (void)tuple_transform(base(), that, element_assign_{});
190 template(
typename... Us)(
191 requires std::is_assignable<detail::args<Ts...> &,
192 detail::rargs<Us const...>>::value)
193 common_tuple & operator=(std::tuple<Us...>
const & that)
noexcept(
196 (void)tuple_transform(base(), that, element_assign_{});
199 template(
typename... Us)(
200 requires std::is_assignable<detail::args<Ts...> &,
201 detail::args<Us...>>::value)
202 common_tuple & operator=(std::tuple<Us...> && that)
noexcept(
205 (void)tuple_transform(base(), std::move(that), element_assign_{});
209 template(
typename... Us)(
210 requires std::is_assignable<detail::args<Ts const...> &,
211 detail::rargs<Us...>>::value)
212 common_tuple const & operator=(std::tuple<Us...> & that)
const noexcept(
215 (void)tuple_transform(base(), that, element_assign_{});
218 template(
typename... Us)(
219 requires std::is_assignable<detail::args<Ts const...> &,
220 detail::rargs<Us const...>>::value)
221 common_tuple const & operator=(std::tuple<Us...>
const & that)
const
223 std::is_nothrow_assignable<Ts const &, Us const &>::value...>::value)
225 (void)tuple_transform(base(), that, element_assign_{});
228 template(
typename... Us)(
229 requires std::is_assignable<detail::args<Ts const...> &,
230 detail::args<Us...>>::value)
231 common_tuple const & operator=(std::tuple<Us...> && that)
const noexcept(
234 (void)tuple_transform(base(), std::move(that), element_assign_{});
239 template(
typename... Us)(
240 requires constructible_from<detail::args<Us...>, detail::rargs<Ts...>>)
241 operator std::tuple<Us...>() &
noexcept(
242 meta::and_c<std::is_nothrow_constructible<Us, Ts &>::value...>::value)
244 return detail::to_std_tuple<Us...>(
247 template(
typename... Us)(
248 requires constructible_from<detail::args<Us...>,
249 detail::rargs<Ts const...>>)
250 operator std::tuple<Us...>()
const &
noexcept(
251 meta::and_c<std::is_nothrow_constructible<Us, Ts const &>::value...>::value)
253 return detail::to_std_tuple<Us...>(
256 template(
typename... Us)(
257 requires constructible_from<detail::args<Us...>, detail::args<Ts...>>)
258 operator std::tuple<Us...>() &&
259 noexcept(
meta::and_c<std::is_nothrow_constructible<Us, Ts>::value...>::value)
261 return detail::to_std_tuple<Us...>(
267#define LOGICAL_OP(OP, CONCEPT) \
268 template(typename... Ts, typename... Us)( \
269 requires and_v<CONCEPT<Ts, Us>...>) \
270 bool operator OP(common_tuple<Ts...> const & a, common_tuple<Us...> const & b) \
272 return a.base() OP b.base(); \
274 template(typename... Ts, typename... Us)( \
275 requires and_v<CONCEPT<Ts, Us>...>) \
276 bool operator OP(std::tuple<Ts...> const & a, common_tuple<Us...> const & b) \
278 return a OP b.base(); \
280 template(typename... Ts, typename... Us)( \
281 requires and_v<CONCEPT<Ts, Us>...>) \
282 bool operator OP(common_tuple<Ts...> const & a, std::tuple<Us...> const & b) \
284 return a.base() OP b; \
287 LOGICAL_OP(==, equality_comparable_with)
288 LOGICAL_OP(!=, equality_comparable_with)
289 LOGICAL_OP(<, totally_ordered_with)
290 LOGICAL_OP(<=, totally_ordered_with)
291 LOGICAL_OP(>, totally_ordered_with)
292 LOGICAL_OP(>=, totally_ordered_with)
297 template<
typename... Args>
303 unwrap_reference(
static_cast<Args &&
>(args))...};
311 template<
typename F,
typename S>
315 std::pair<F, S>
const & base()
const noexcept
324 noexcept(std::is_nothrow_default_constructible<F>::value &&
325 std::is_nothrow_default_constructible<S>::value)
326 requires default_constructible<F> && default_constructible<S>)
329 template(
typename F2,
typename S2)(
330 requires constructible_from<F, F2> AND constructible_from<S, S2>)
332 noexcept(std::is_nothrow_constructible<F, F2>::value &&
333 std::is_nothrow_constructible<S, S2>::value)
334 : std::pair<F, S>{
static_cast<F2 &&
>(f2),
static_cast<S2 &&
>(s2)}
336 template(
typename F2,
typename S2)(
337 requires constructible_from<F, F2 &> AND constructible_from<S, S2 &>)
339 noexcept(std::is_nothrow_constructible<F, F2 &>::value &&
340 std::is_nothrow_constructible<S, S2 &>::value)
341 : std::pair<F, S>{that.first, that.second}
343 template(
typename F2,
typename S2)(
344 requires constructible_from<F, F2 const &> AND
345 constructible_from<S, S2 const &>)
347 noexcept(std::is_nothrow_constructible<F, F2 const &>::value &&
348 std::is_nothrow_constructible<S, S2 const &>::value)
349 : std::pair<F, S>{that.first, that.second}
351 template(
typename F2,
typename S2)(
352 requires constructible_from<F, F2> AND constructible_from<S, S2>)
354 noexcept(std::is_nothrow_constructible<F, F2>::value &&
355 std::is_nothrow_constructible<S, S2>::value)
356 : std::pair<F, S>{std::forward<F2>(that.first), std::forward<S2>(that.second)}
360 template(
typename F2,
typename S2)(
361 requires constructible_from<F2, F &> AND constructible_from<S2, S &>)
362 operator std::pair<F2, S2>() &
363 noexcept(std::is_nothrow_constructible<F2, F &>::value &&
364 std::is_nothrow_constructible<S2, S &>::value)
366 return {this->first, this->second};
368 template(
typename F2,
typename S2)(
369 requires constructible_from<F2, F const &> AND
370 constructible_from<S2, S const &>)
371 operator std::pair<F2, S2>()
const &
372 noexcept(std::is_nothrow_constructible<F2, F const &>::value &&
373 std::is_nothrow_constructible<S2, S const &>::value)
375 return {this->first, this->second};
377 template(
typename F2,
typename S2)(
378 requires constructible_from<F2, F> AND constructible_from<S2, S>)
379 operator std::pair<F2, S2>() &&
380 noexcept(std::is_nothrow_constructible<F2, F>::value &&
381 std::is_nothrow_constructible<S2, S>::value)
383 return {std::forward<F>(this->first), std::forward<S>(this->second)};
387 template(
typename F2,
typename S2)(
388 requires assignable_from<F &, F2 &> AND assignable_from<S &, S2 &>)
390 noexcept(std::is_nothrow_assignable<F &, F2 &>::value &&
391 std::is_nothrow_assignable<S &, S2 &>::value)
393 this->first = that.first;
394 this->second = that.second;
397 template(
typename F2,
typename S2)(
398 requires assignable_from<F &, F2 const &> AND
399 assignable_from<S &, S2 const &>)
400 common_pair & operator=(std::pair<F2, S2>
const & that)
401 noexcept(std::is_nothrow_assignable<F &, F2 const &>::value &&
402 std::is_nothrow_assignable<S &, S2 const &>::value)
404 this->first = that.first;
405 this->second = that.second;
408 template(
typename F2,
typename S2)(
409 requires assignable_from<F &, F2> AND assignable_from<S &, S2>)
411 noexcept(std::is_nothrow_assignable<F &, F2>::value &&
412 std::is_nothrow_assignable<S &, S2>::value)
414 this->first =
static_cast<F2 &&
>(that.first);
415 this->second =
static_cast<S2 &&
>(that.second);
419 template(
typename F2,
typename S2)(
420 requires assignable_from<F const &, F2 &> AND
421 assignable_from<S const &, S2 &>)
422 common_pair const & operator=(std::pair<F2, S2> & that)
const
423 noexcept(std::is_nothrow_assignable<F const &, F2 &>::value &&
424 std::is_nothrow_assignable<S const &, S2 &>::value)
426 this->first = that.first;
427 this->second = that.second;
430 template(
typename F2,
typename S2)(
431 requires assignable_from<F const &, F2 const &> AND
432 assignable_from<S const &, S2 const &>)
433 common_pair const & operator=(std::pair<F2, S2>
const & that)
const
434 noexcept(std::is_nothrow_assignable<F const &, F2 const &>::value &&
435 std::is_nothrow_assignable<S const &, S2 const &>::value)
437 this->first = that.first;
438 this->second = that.second;
441 template(
typename F2,
typename S2)(
442 requires assignable_from<F const &, F2> AND assignable_from<S const &, S2>)
443 common_pair const & operator=(std::pair<F2, S2> && that)
const
444 noexcept(std::is_nothrow_assignable<F const &, F2 &&>::value &&
445 std::is_nothrow_assignable<S const &, S2 &&>::value)
447 this->first =
static_cast<F2 &&
>(that.first);
448 this->second =
static_cast<S2 &&
>(that.second);
454 template(
typename F1,
typename S1,
typename F2,
typename S2)(
455 requires equality_comparable_with<F1, F2> AND equality_comparable_with<S1, S2>)
458 return a.first == b.first && a.second == b.second;
460 template(
typename F1,
typename S1,
typename F2,
typename S2)(
461 requires equality_comparable_with<F1, F2> AND equality_comparable_with<S1, S2>)
462 bool operator==(common_pair<F1, S1>
const & a, std::pair<F2, S2>
const & b)
464 return a.first == b.first && a.second == b.second;
466 template(
typename F1,
typename S1,
typename F2,
typename S2)(
467 requires equality_comparable_with<F1, F2> AND equality_comparable_with<S1, S2>)
468 bool operator==(std::pair<F1, S1>
const & a, common_pair<F2, S2>
const & b)
470 return a.first == b.first && a.second == b.second;
472 template(
typename F1,
typename S1,
typename F2,
typename S2)(
473 requires totally_ordered_with<F1, F2> AND totally_ordered_with<S1, S2>)
474 bool operator<(common_pair<F1, S1>
const & a, common_pair<F2, S2>
const & b)
476 return a.first < b.first || (!(b.first < a.first) && a.second < b.second);
478 template(
typename F1,
typename S1,
typename F2,
typename S2)(
479 requires totally_ordered_with<F1, F2> AND totally_ordered_with<S1, S2>)
480 bool operator<(std::pair<F1, S1>
const & a, common_pair<F2, S2>
const & b)
482 return a.first < b.first || (!(b.first < a.first) && a.second < b.second);
484 template(
typename F1,
typename S1,
typename F2,
typename S2)(
485 requires totally_ordered_with<F1, F2> AND totally_ordered_with<S1, S2>)
486 bool operator<(common_pair<F1, S1>
const & a, std::pair<F2, S2>
const & b)
488 return a.first < b.first || (!(b.first < a.first) && a.second < b.second);
490#define LOGICAL_OP(OP, CONCEPT, RET) \
491 template(typename F1, typename S1, typename F2, typename S2)( \
492 requires CONCEPT<F1, F2> AND CONCEPT<S1, S2>) \
493 bool operator OP(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b) \
497 template(typename F1, typename S1, typename F2, typename S2)( \
498 requires CONCEPT<F1, F2> AND CONCEPT<S1, S2>) \
499 bool operator OP(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b) \
503 template(typename F1, typename S1, typename F2, typename S2)( \
504 requires CONCEPT<F1, F2> AND CONCEPT<S1, S2>) \
505 bool operator OP(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b) \
510 LOGICAL_OP(!=, equality_comparable_with, !(a == b))
511 LOGICAL_OP(<=, totally_ordered_with, !(b < a))
512 LOGICAL_OP(>, totally_ordered_with, (b < a))
513 LOGICAL_OP(>=, totally_ordered_with, !(a < b))
518 template<
typename First,
typename Second,
typename F = bind_element_t<First>,
519 typename S = bind_element_t<Second>>
521 noexcept(std::is_nothrow_constructible<F, unwrap_reference_t<First>>::value &&
522 std::is_nothrow_constructible<F, unwrap_reference_t<Second>>::value)
524 return {unwrap_reference(
static_cast<First &&
>(f)),
525 unwrap_reference(
static_cast<Second &&
>(s))};
536 template<
typename,
typename,
typename,
typename =
void>
537 struct common_type_tuple_like
540 template<
template<
typename...>
class T0,
typename... Ts,
541 template<
typename...>
class T1,
typename... Us,
typename TupleLike>
542 struct common_type_tuple_like<T0<Ts...>, T1<Us...>, TupleLike,
543 meta::if_c<sizeof...(Ts) == sizeof...(Us)>>
545 meta::lazy::invoke<TupleLike, meta::lazy::_t<common_type<Ts, Us>>...>>
548 template<
typename,
typename,
typename,
typename =
void>
549 struct common_ref_tuple_like
552 template<
template<
typename...>
class T0,
typename... Ts,
553 template<
typename...>
class T1,
typename... Us,
typename TupleLike>
554 struct common_ref_tuple_like<T0<Ts...>, T1<Us...>, TupleLike,
555 meta::if_c<sizeof...(Ts) == sizeof...(Us)>>
557 TupleLike, meta::lazy::_t<common_reference<Ts, Us>>...>>
567 template<
typename F1,
typename S1,
typename F2,
typename S2>
569 : ranges::detail::common_type_tuple_like<
570 std::pair<F1, S1>, ranges::common_pair<F2, S2>,
571 meta::quote<ranges::common_pair>>
573 template<
typename F1,
typename S1,
typename F2,
typename S2>
574 struct common_type<ranges::common_pair<F1, S1>, std::pair<F2, S2>>
575 : ranges::detail::common_type_tuple_like<
576 ranges::common_pair<F1, S1>, std::pair<F2, S2>,
577 meta::quote<ranges::common_pair>>
579 template<
typename F1,
typename S1,
typename F2,
typename S2>
581 : ranges::detail::common_type_tuple_like<ranges::common_pair<F1, S1>,
582 ranges::common_pair<F2, S2>,
583 meta::quote<ranges::common_pair>>
586 template<
typename... Ts,
typename... Us>
587 struct common_type<ranges::common_tuple<Ts...>, std::tuple<Us...>>
588 : ranges::detail::common_type_tuple_like<
589 ranges::common_tuple<Ts...>, std::tuple<Us...>,
590 meta::quote<ranges::common_tuple>>
592 template<
typename... Ts,
typename... Us>
594 : ranges::detail::common_type_tuple_like<
595 std::tuple<Ts...>, ranges::common_tuple<Us...>,
596 meta::quote<ranges::common_tuple>>
598 template<
typename... Ts,
typename... Us>
600 : ranges::detail::common_type_tuple_like<ranges::common_tuple<Ts...>,
601 ranges::common_tuple<Us...>,
602 meta::quote<ranges::common_tuple>>
606 template<
typename F1,
typename S1,
typename F2,
typename S2,
607 template<
typename>
class Qual1,
template<
typename>
class Qual2>
608 struct basic_common_reference<ranges::common_pair<F1, S1>, std::pair<F2, S2>, Qual1,
610 : ranges::detail::common_ref_tuple_like<
611 ranges::common_pair<Qual1<F1>, Qual1<S1>>, std::pair<Qual2<F2>, Qual2<S2>>,
612 meta::quote<ranges::common_pair>>
614 template<
typename F1,
typename S1,
typename F2,
typename S2,
615 template<
typename>
class Qual1,
template<
typename>
class Qual2>
618 : ranges::detail::common_ref_tuple_like<
619 std::pair<Qual1<F1>, Qual1<S1>>, ranges::common_pair<Qual2<F2>, Qual2<S2>>,
620 meta::quote<ranges::common_pair>>
622 template<
typename F1,
typename S1,
typename F2,
typename S2,
623 template<
typename>
class Qual1,
template<
typename>
class Qual2>
624 struct basic_common_reference<ranges::common_pair<F1, S1>,
626 : ranges::detail::common_ref_tuple_like<ranges::common_pair<Qual1<F1>, Qual1<S1>>,
627 ranges::common_pair<Qual2<F2>, Qual2<S2>>,
628 meta::quote<ranges::common_pair>>
631 template<
typename... Ts,
typename... Us,
template<
typename>
class Qual1,
632 template<
typename>
class Qual2>
633 struct basic_common_reference<ranges::common_tuple<Ts...>, std::tuple<Us...>, Qual1,
635 : ranges::detail::common_ref_tuple_like<
636 ranges::common_tuple<Qual1<Ts>...>, std::tuple<Qual2<Us>...>,
637 meta::quote<ranges::common_tuple>>
639 template<
typename... Ts,
typename... Us,
template<
typename>
class Qual1,
640 template<
typename>
class Qual2>
643 : ranges::detail::common_ref_tuple_like<
644 std::tuple<Qual1<Ts>...>, ranges::common_tuple<Qual2<Us>...>,
645 meta::quote<ranges::common_tuple>>
647 template<
typename... Ts,
typename... Us,
template<
typename>
class Qual1,
648 template<
typename>
class Qual2>
649 struct basic_common_reference<ranges::common_tuple<Ts...>,
651 : ranges::detail::common_ref_tuple_like<ranges::common_tuple<Qual1<Ts>...>,
652 ranges::common_tuple<Qual2<Us>...>,
653 meta::quote<ranges::common_tuple>>
658RANGES_DIAGNOSTIC_PUSH
659RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
660RANGES_BEGIN_NAMESPACE_STD
661 template<
typename First,
typename Second>
663 : std::integral_constant<size_t, 2>
666 template<
typename First,
typename Second>
672 template<
typename First,
typename Second>
678 template<
typename... Ts>
680 : std::integral_constant<size_t, sizeof...(Ts)>
683 template<
size_t N,
typename... Ts>
685 : tuple_element<N, tuple<Ts...>>
688#if RANGES_CXX_VER > RANGES_CXX_STD_17
689RANGES_BEGIN_NAMESPACE_VERSION
690 template<
typename...>
694 template<
typename F1,
typename S1,
typename F2,
typename S2>
696 : ::ranges::detail::common_type_tuple_like<
700 template<
typename F1,
typename S1,
typename F2,
typename S2>
702 : ::ranges::detail::common_type_tuple_like<
703 ::ranges::common_pair<F1, S1>, std::pair<F2, S2>,
704 ::meta::quote<::ranges::common_pair>>
706 template<
typename F1,
typename S1,
typename F2,
typename S2>
708 : ::ranges::detail::common_type_tuple_like<::ranges::common_pair<F1, S1>,
709 ::ranges::common_pair<F2, S2>,
710 ::meta::quote<::ranges::common_pair>>
713 template<
typename... Ts,
typename... Us>
715 : ::ranges::detail::common_type_tuple_like<
716 ::ranges::common_tuple<Ts...>, std::tuple<Us...>,
717 ::meta::quote<::ranges::common_tuple>>
719 template<
typename... Ts,
typename... Us>
721 : ::ranges::detail::common_type_tuple_like<
722 std::tuple<Ts...>, ::ranges::common_tuple<Us...>,
723 ::meta::quote<::ranges::common_tuple>>
725 template<
typename... Ts,
typename... Us>
727 : ::ranges::detail::common_type_tuple_like<::ranges::common_tuple<Ts...>,
728 ::ranges::common_tuple<Us...>,
729 ::meta::quote<::ranges::common_tuple>>
732 template<
typename,
typename,
template<
typename>
class,
template<
typename>
class>
733 struct basic_common_reference;
736 template<
typename F1,
typename S1,
typename F2,
typename S2,
737 template<
typename>
class Qual1,
template<
typename>
class Qual2>
740 : ::ranges::detail::common_ref_tuple_like<
741 ::ranges::common_pair<Qual1<F1>, Qual1<S1>>, std::pair<Qual2<F2>, Qual2<S2>>,
742 ::meta::quote<::ranges::common_pair>>
744 template<
typename F1,
typename S1,
typename F2,
typename S2,
745 template<
typename>
class Qual1,
template<
typename>
class Qual2>
748 : ::ranges::detail::common_ref_tuple_like<
749 std::pair<Qual1<F1>, Qual1<S1>>, ::ranges::common_pair<Qual2<F2>, Qual2<S2>>,
750 ::meta::quote<::ranges::common_pair>>
752 template<
typename F1,
typename S1,
typename F2,
typename S2,
753 template<
typename>
class Qual1,
template<
typename>
class Qual2>
756 : ::ranges::detail::common_ref_tuple_like<::ranges::common_pair<Qual1<F1>, Qual1<S1>>,
757 ::ranges::common_pair<Qual2<F2>, Qual2<S2>>,
758 ::meta::quote<::ranges::common_pair>>
761 template<
typename... Ts,
typename... Us,
template<
typename>
class Qual1,
762 template<
typename>
class Qual2>
765 : ::ranges::detail::common_ref_tuple_like<
766 ::ranges::common_tuple<Qual1<Ts>...>, std::tuple<Qual2<Us>...>,
767 ::meta::quote<::ranges::common_tuple>>
769 template<
typename... Ts,
typename... Us,
template<
typename>
class Qual1,
770 template<
typename>
class Qual2>
773 : ::ranges::detail::common_ref_tuple_like<
774 std::tuple<Qual1<Ts>...>, ::ranges::common_tuple<Qual2<Us>...>,
775 ::meta::quote<::ranges::common_tuple>>
777 template<
typename... Ts,
typename... Us,
template<
typename>
class Qual1,
778 template<
typename>
class Qual2>
781 : ::ranges::detail::common_ref_tuple_like<::ranges::common_tuple<Qual1<Ts>...>,
782 ::ranges::common_tuple<Qual2<Us>...>,
783 ::meta::quote<::ranges::common_tuple>>
785RANGES_END_NAMESPACE_VERSION
787RANGES_END_NAMESPACE_STD
790#include <range/v3/detail/epilogue.hpp>
decltype(unwrap_reference(std::declval< T >())) unwrap_reference_t
Definition reference_wrapper.hpp:178
_t< detail::make_indices_< N, index_sequence< 0 >, detail::strategy_(1, N)> > make_index_sequence
Generate index_sequence containing integer constants [0,1,2,...,N-1].
Definition meta.hpp:473
list< F, S > pair
A list with exactly two elements.
Definition meta.hpp:2246
Definition common_tuple.hpp:313
Definition common_tuple.hpp:96
Definition common_tuple.hpp:517
Definition common_tuple.hpp:296