Range-v3
Range algorithms, views, and actions for the Standard Library
common_tuple.hpp File Reference

Classes

struct  ranges::common_pair< F, S >
 
struct  ranges::common_tuple< Ts >
 
struct  ranges::make_common_pair_fn
 
struct  ranges::make_common_tuple_fn
 
struct  std::__1::basic_common_reference< typename, typename, class, class >
 
struct  std::__1::basic_common_reference< std::pair< F1, S1 >, ::ranges::common_pair< F2, S2 >, Qual1, Qual2 >
 
struct  std::__1::basic_common_reference< std::tuple< Ts... >, ::ranges::common_tuple< Us... >, Qual1, Qual2 >
 
struct  std::__1::basic_common_reference<::ranges::common_pair< F1, S1 >, ::ranges::common_pair< F2, S2 >, Qual1, Qual2 >
 
struct  std::__1::basic_common_reference<::ranges::common_pair< F1, S1 >, std::pair< F2, S2 >, Qual1, Qual2 >
 
struct  std::__1::basic_common_reference<::ranges::common_tuple< Ts... >, ::ranges::common_tuple< Us... >, Qual1, Qual2 >
 
struct  std::__1::basic_common_reference<::ranges::common_tuple< Ts... >, std::tuple< Us... >, Qual1, Qual2 >
 
struct  std::__1::common_type<... >
 
struct  std::__1::common_type< std::pair< F1, S1 >, ::ranges::common_pair< F2, S2 > >
 
struct  std::__1::common_type< std::tuple< Ts... >, ::ranges::common_tuple< Us... > >
 
struct  std::__1::common_type<::ranges::common_pair< F1, S1 >, ::ranges::common_pair< F2, S2 > >
 
struct  std::__1::common_type<::ranges::common_pair< F1, S1 >, std::pair< F2, S2 > >
 
struct  std::__1::common_type<::ranges::common_tuple< Ts... >, ::ranges::common_tuple< Us... > >
 
struct  std::__1::common_type<::ranges::common_tuple< Ts... >, std::tuple< Us... > >
 
struct  std::__1::tuple_element< 0, ::ranges::common_pair< First, Second > >
 
struct  std::__1::tuple_element< 1, ::ranges::common_pair< First, Second > >
 
struct  std::__1::tuple_element< N, ::ranges::common_tuple< Ts... > >
 
struct  std::__1::tuple_size<::ranges::common_pair< First, Second > >
 
struct  std::__1::tuple_size<::ranges::common_tuple< Ts... > >
 

Functions

template<typename F1 , typename S1 , typename F2 , typename S2 >
requires equality_comparable_with< F1, F2 > &&equality_comparable_with< S1, S2 > bool ranges::operator!= (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires equality_comparable_with< F1, F2 > &&equality_comparable_with< S1, S2 > bool ranges::operator!= (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< equality_comparable_with< Ts, Us >... > bool ranges::operator!= (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< equality_comparable_with< Ts, Us >... > bool ranges::operator!= (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires equality_comparable_with< F1, F2 > &&equality_comparable_with< S1, S2 > bool ranges::operator!= (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< equality_comparable_with< Ts, Us >... > bool ranges::operator!= (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator< (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator< (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator< (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator< (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator< (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator< (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires totally_ordered_with< F1, F2 > &&totally_ordered_with< S1, S2 > bool ranges::operator<= (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires totally_ordered_with< F1, F2 > &&totally_ordered_with< S1, S2 > bool ranges::operator<= (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator<= (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator<= (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires totally_ordered_with< F1, F2 > &&totally_ordered_with< S1, S2 > bool ranges::operator<= (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator<= (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator== (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator== (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< equality_comparable_with< Ts, Us >... > bool ranges::operator== (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< equality_comparable_with< Ts, Us >... > bool ranges::operator== (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator== (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< equality_comparable_with< Ts, Us >... > bool ranges::operator== (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires totally_ordered_with< F1, F2 > &&totally_ordered_with< S1, S2 > bool ranges::operator> (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires totally_ordered_with< F1, F2 > &&totally_ordered_with< S1, S2 > bool ranges::operator> (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator> (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator> (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires totally_ordered_with< F1, F2 > &&totally_ordered_with< S1, S2 > bool ranges::operator> (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator> (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires totally_ordered_with< F1, F2 > &&totally_ordered_with< S1, S2 > bool ranges::operator>= (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires totally_ordered_with< F1, F2 > &&totally_ordered_with< S1, S2 > bool ranges::operator>= (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator>= (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator>= (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
 
template<typename F1 , typename S1 , typename F2 , typename S2 >
requires totally_ordered_with< F1, F2 > &&totally_ordered_with< S1, S2 > bool ranges::operator>= (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
 
template<typename... Ts, typename... Us>
requires and_v< totally_ordered_with< Ts, Us >... > bool ranges::operator>= (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
 

Variables

constexpr make_common_pair_fn ranges::make_common_pair {}
 
constexpr make_common_tuple_fn ranges::make_common_tuple {}
 

Function Documentation

◆ operator<() [1/3]

template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator< ( common_pair< F1, S1 > const &  a,
common_pair< F2, S2 > const &  b 
)
Precondition
requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2>

◆ operator<() [2/3]

template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator< ( common_pair< F1, S1 > const &  a,
std::pair< F2, S2 > const &  b 
)
Precondition
requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2>

◆ operator<() [3/3]

template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator< ( std::pair< F1, S1 > const &  a,
common_pair< F2, S2 > const &  b 
)
Precondition
requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2>

◆ operator==() [1/3]

template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator== ( common_pair< F1, S1 > const &  a,
common_pair< F2, S2 > const &  b 
)
Precondition
requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2>

◆ operator==() [2/3]

template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator== ( common_pair< F1, S1 > const &  a,
std::pair< F2, S2 > const &  b 
)
Precondition
requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2>

◆ operator==() [3/3]

template<typename F1 , typename S1 , typename F2 , typename S2 >
bool ranges::operator== ( std::pair< F1, S1 > const &  a,
common_pair< F2, S2 > const &  b 
)
Precondition
requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2>