common_tuple.hpp File Reference

Classes
struct	ranges::common_pair< F, S >
struct	ranges::common_tuple< Ts >
struct	ranges::make_common_tuple_fn
struct	tuple_element< 0, ::ranges::common_pair< First, Second > >
struct	tuple_element< 1, ::ranges::common_pair< First, Second > >
struct	tuple_element< N, ::ranges::common_tuple< Ts... > >
struct	tuple_size<::ranges::common_pair< First, Second > >
struct	tuple_size<::ranges::common_tuple< Ts... > >

Macros
#define	LOGICAL_OP(OP, CONCEPT)
#define	LOGICAL_OP(OP, CONCEPT, RET)

Functions
	ranges::b< a)) template< typename... Ts, typename... Us > requires and_v< totally_ordered_with< Ts, Us >... > bool 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, 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... 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... Ts, typename... Us> requires and_v< totally_ordered_with <Ts, Us>...>
bool	ranges::operator<= (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
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... 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 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... 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... 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... 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)
typename Us bool	ranges::operator>= (common_tuple< Ts... > const &a, std::tuple< Us... > 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
	ranges::a == b)) template< typename... Ts, typename... Us > requires and_v< totally_ordered_with <Ts
	ranges::b< a)) template< typename... Ts, typename... Us > requires and_v< totally_ordered_with< Ts, Us >... > bool operator> = (common_tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a.base() >= b.base(); } template< typename... Ts, typename... Us > requires and_v< totally_ordered_with <Ts, Us>...> bool operator >= (std::tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a >= b.base(); } template< typename... Ts
constexpr make_common_tuple_fn	ranges::make_common_tuple {}

Macro Definition Documentation

LOGICAL_OP [1/2]

#define LOGICAL_OP	(		OP,
			CONCEPT
	)

Value:

    template(typename... Ts, typename... Us)(                                      \
        requires and_v<CONCEPT<Ts, Us>...>)                                        \
    bool operator OP(common_tuple<Ts...> const & a, common_tuple<Us...> const & b) \
    {                                                                              \
        return a.base() OP b.base();                                               \
    }                                                                              \
    template(typename... Ts, typename... Us)(                                      \
        requires and_v<CONCEPT<Ts, Us>...>)                                        \
    bool operator OP(std::tuple<Ts...> const & a, common_tuple<Us...> const & b)   \
    {                                                                              \
        return a OP b.base();                                                      \
    }                                                                              \
    template(typename... Ts, typename... Us)(                                      \
        requires and_v<CONCEPT<Ts, Us>...>)                                        \
    bool operator OP(common_tuple<Ts...> const & a, std::tuple<Us...> const & b)   \
    {                                                                              \
        return a.base() OP b;                                                      \
    }                                                                              \

LOGICAL_OP [2/2]

#define LOGICAL_OP	(		OP,
			CONCEPT,
			RET
	)

Value:

    template(typename F1, typename S1, typename F2, typename S2)(                  \
        requires CONCEPT<F1, F2> AND CONCEPT<S1, S2>)                              \
    bool operator OP(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b) \
    {                                                                              \
        return RET;                                                                \
    }                                                                              \
    template(typename F1, typename S1, typename F2, typename S2)(                  \
        requires CONCEPT<F1, F2> AND CONCEPT<S1, S2>)                              \
    bool operator OP(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b)   \
    {                                                                              \
        return RET;                                                                \
    }                                                                              \
    template(typename F1, typename S1, typename F2, typename S2)(                  \
        requires CONCEPT<F1, F2> AND CONCEPT<S1, S2>)                              \
    bool operator OP(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b)   \
    {                                                                              \
        return RET;                                                                \
    }                                                                              \