A std::tuple implementation that incorporates most changes from C++23's standard library. More...

#include <seqan3/utility/tuple/common_tuple.hpp>

Inheritance diagram for seqan3::common_tuple< Types >:

Public Member Functions
Default constructors and assignments.
	common_tuple ()=default
	Defaulted.

	common_tuple (common_tuple const &)=default
	Defaulted.

common_tuple &	operator= (common_tuple const &)=default
	Defaulted.

	~common_tuple ()=default

Construct from arguments.
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes &> && ...)
constexpr	common_tuple (UTypes &... other)
	Constructs from arguments.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
constexpr	common_tuple (UTypes const &... other)
	Constructs from arguments.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes> && ...)
constexpr	common_tuple (UTypes &&... other)
	Constructs from arguments.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
constexpr	common_tuple (UTypes const &&... other)
	Constructs from arguments.

Construct from common_tuple.
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes &> && ...)
constexpr	common_tuple (common_tuple< UTypes... > &other)
	Constructs from common_tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
constexpr	common_tuple (common_tuple< UTypes... > const &other)
	Constructs from common_tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes> && ...)
constexpr	common_tuple (common_tuple< UTypes... > &&other)
	Constructs from common_tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
constexpr	common_tuple (common_tuple< UTypes... > const &&other)
	Constructs from common_tuple.

Construct from common_pair.
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes &> && ...)
constexpr	common_tuple (common_pair< UTypes... > &other)
	Constructs from common_pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
constexpr	common_tuple (common_pair< UTypes... > const &other)
	Constructs from common_pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes> && ...)
constexpr	common_tuple (common_pair< UTypes... > &&other)
	Constructs from common_pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
constexpr	common_tuple (common_pair< UTypes... > const &&other)
	Constructs from common_pair.

Construct from std::tuple.
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes &> && ...)
constexpr	common_tuple (std::tuple< UTypes... > &other)
	Constructs from std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
constexpr	common_tuple (std::tuple< UTypes... > const &other)
	Constructs from std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes> && ...)
constexpr	common_tuple (std::tuple< UTypes... > &&other)
	Constructs from std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
constexpr	common_tuple (std::tuple< UTypes... > const &&other)
	Constructs from std::tuple.

Construct from std::pair.
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes &> && ...)
constexpr	common_tuple (std::pair< UTypes... > &other)
	Constructs from std::pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
constexpr	common_tuple (std::pair< UTypes... > const &other)
	Constructs from std::pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes> && ...)
constexpr	common_tuple (std::pair< UTypes... > &&other)
	Constructs from std::pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<Types, UTypes const> && ...)
constexpr	common_tuple (std::pair< UTypes... > const &&other)
	Constructs from std::pair.

Assign from common_tuple.
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes &> && ...)
constexpr common_tuple &	operator= (common_tuple< UTypes... > &other)
	Assigns from common_tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
constexpr common_tuple &	operator= (common_tuple< UTypes... > const &other)
	Assigns from common_tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes> && ...)
constexpr common_tuple &	operator= (common_tuple< UTypes... > &&other)
	Assigns from common_tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
constexpr common_tuple &	operator= (common_tuple< UTypes... > const &&other)
	Assigns from common_tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes &> && ...)
constexpr common_tuple const &	operator= (common_tuple< UTypes... > &other) const
	Assigns from common_tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
constexpr common_tuple const &	operator= (common_tuple< UTypes... > const &other) const
	Assigns from common_tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes> && ...)
constexpr common_tuple const &	operator= (common_tuple< UTypes... > &&other) const
	Assigns from common_tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
constexpr common_tuple const &	operator= (common_tuple< UTypes... > const &&other) const
	Assigns from common_tuple.

Assign from common_pair.
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes &> && ...)
constexpr common_tuple &	operator= (common_pair< UTypes... > &other)
	Assigns from common_pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
constexpr common_tuple &	operator= (common_pair< UTypes... > const &other)
	Assigns from common_pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes> && ...)
constexpr common_tuple &	operator= (common_pair< UTypes... > &&other)
	Assigns from common_pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
constexpr common_tuple &	operator= (common_pair< UTypes... > const &&other)
	Assigns from common_pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes &> && ...)
constexpr common_tuple const &	operator= (common_pair< UTypes... > &other) const
	Assigns from common_pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
constexpr common_tuple const &	operator= (common_pair< UTypes... > const &other) const
	Assigns from common_pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes> && ...)
constexpr common_tuple const &	operator= (common_pair< UTypes... > &&other) const
	Assigns from common_pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
constexpr common_tuple const &	operator= (common_pair< UTypes... > const &&other) const
	Assigns from common_pair.

Assign from std::tuple.
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes &> && ...)
constexpr common_tuple &	operator= (std::tuple< UTypes... > &other)
	Assigns from std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
constexpr common_tuple &	operator= (std::tuple< UTypes... > const &other)
	Assigns from std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes> && ...)
constexpr common_tuple &	operator= (std::tuple< UTypes... > &&other)
	Assigns from std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
constexpr common_tuple &	operator= (std::tuple< UTypes... > const &&other)
	Assigns from std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes &> && ...)
constexpr common_tuple const &	operator= (std::tuple< UTypes... > &other) const
	Assigns from std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
constexpr common_tuple const &	operator= (std::tuple< UTypes... > const &other) const
	Assigns from std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes> && ...)
constexpr common_tuple const &	operator= (std::tuple< UTypes... > &&other) const
	Assigns from std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
constexpr common_tuple const &	operator= (std::tuple< UTypes... > const &&other) const
	Assigns from std::tuple.

Assign from std::pair.
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes &> && ...)
constexpr common_tuple &	operator= (std::pair< UTypes... > &other)
	Assigns from std::pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
constexpr common_tuple &	operator= (std::pair< UTypes... > const &other)
	Assigns from std::pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes> && ...)
constexpr common_tuple &	operator= (std::pair< UTypes... > &&other)
	Assigns from std::pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types, UTypes const> && ...)
constexpr common_tuple &	operator= (std::pair< UTypes... > const &&other)
	Assigns from std::pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes &> && ...)
constexpr common_tuple const &	operator= (std::pair< UTypes... > &other) const
	Assigns from std::pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
constexpr common_tuple const &	operator= (std::pair< UTypes... > const &other) const
	Assigns from std::pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes> && ...)
constexpr common_tuple const &	operator= (std::pair< UTypes... > &&other) const
	Assigns from std::pair.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_assignable_v<Types const, UTypes const> && ...)
constexpr common_tuple const &	operator= (std::pair< UTypes... > const &&other) const
	Assigns from std::pair.

Conversion to std::tuple.
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<UTypes, Types &> && ...)
	operator std::tuple< UTypes... > () &
	Converts to std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<UTypes, Types const> && ...)
	operator std::tuple< UTypes... > () const &
	Converts to std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<UTypes, Types> && ...)
	operator std::tuple< UTypes... > () &&
	Converts to std::tuple.

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && (std::is_constructible_v<UTypes, Types const> && ...)
	operator std::tuple< UTypes... > () const &&
	Converts to std::tuple.

Public Member Functions inherited from std::tuple< Types... >
T	operator= (T... args)

T	swap (T... args)

T	tuple (T... args)

Friends
Comparison operators (common_tuple)
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); }
constexpr friend bool	operator== (common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
	Checks whether `lhs` and `rhs` are equal. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); }
constexpr friend bool	operator!= (common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
	Checks whether `lhs` and `rhs` are unequal. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }
constexpr friend bool	operator< (common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
	Checks whether `lhs` is less than `rhs`. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }
constexpr friend bool	operator<= (common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
	Checks whether `lhs` is less than or equal to `rhs`. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }
constexpr friend bool	operator> (common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
	Checks whether `lhs` is greater than `rhs`. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }
constexpr friend bool	operator>= (common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
	Checks whether `lhs` is greater than or equal to `rhs`. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::three_way_comparable_with<Types, UTypes> && ...); }
constexpr friend auto	operator<=> (common_tuple const &lhs, common_tuple< UTypes... > const &rhs)
	Performs a three-way comparison between `lhs` and `rhs` More...

Comparison operators (std::tuple)
template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); }
constexpr friend bool	operator== (common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
	Checks whether `lhs` and `rhs` are equal. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); }
constexpr friend bool	operator!= (common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
	Checks whether `lhs` and `rhs` are unequal. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }
constexpr friend bool	operator< (common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
	Checks whether `lhs` is less than `rhs`. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }
constexpr friend bool	operator<= (common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
	Checks whether `lhs` is less than or equal to `rhs`. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }
constexpr friend bool	operator> (common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
	Checks whether `lhs` is greater than `rhs`. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }
constexpr friend bool	operator>= (common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
	Checks whether `lhs` is greater than or equal to `rhs`. More...

template<class... UTypes> requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::three_way_comparable_with<Types, UTypes> && ...); }
constexpr friend auto	operator<=> (common_tuple const &lhs, std::tuple< UTypes... > const &rhs)
	Performs a three-way comparison between `lhs` and `rhs` More...

Detailed Description

template<class... Types>
class seqan3::common_tuple< Types >

A std::tuple implementation that incorporates most changes from C++23's standard library.

Constructor & Destructor Documentation

◆ ~common_tuple()

template<class... Types>

seqan3::common_tuple< Types >::~common_tuple ( )

default

Defaulted.

Friends And Related Function Documentation

◆ operator!= [1/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); }

constexpr friend bool operator!=	(	common_tuple< Types > const &	lhs,
		common_tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs and rhs are unequal.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A common_tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator!= [2/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); }

constexpr friend bool operator!=	(	common_tuple< Types > const &	lhs,
		std::tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs and rhs are unequal.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A std::tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator< [1/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }

constexpr friend bool operator<	(	common_tuple< Types > const &	lhs,
		common_tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs is less than rhs.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A common_tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator< [2/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }

constexpr friend bool operator<	(	common_tuple< Types > const &	lhs,
		std::tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs is less than rhs.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A std::tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator<= [1/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }

constexpr friend bool operator<=	(	common_tuple< Types > const &	lhs,
		common_tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs is less than or equal to rhs.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A common_tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator<= [2/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }

constexpr friend bool operator<=	(	common_tuple< Types > const &	lhs,
		std::tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs is less than or equal to rhs.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A std::tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator<=> [1/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::three_way_comparable_with<Types, UTypes> && ...); }

constexpr friend auto operator<=>	(	common_tuple< Types > const &	lhs,
		common_tuple< UTypes... > const &	rhs
	)

friend

Performs a three-way comparison between lhs and rhs

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A common_tuple with possibly different element types.

Returns: An ordering indicating the result of the comparison.

◆ operator<=> [2/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::three_way_comparable_with<Types, UTypes> && ...); }

constexpr friend auto operator<=>	(	common_tuple< Types > const &	lhs,
		std::tuple< UTypes... > const &	rhs
	)

friend

Performs a three-way comparison between lhs and rhs

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A std::tuple with possibly different element types.

Returns: An ordering indicating the result of the comparison.

◆ operator== [1/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); }

constexpr friend bool operator==	(	common_tuple< Types > const &	lhs,
		common_tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs and rhs are equal.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A common_tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator== [2/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::equality_comparable_with<Types, UTypes> && ...); }

constexpr friend bool operator==	(	common_tuple< Types > const &	lhs,
		std::tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs and rhs are equal.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A std::tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator> [1/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }

constexpr friend bool operator>	(	common_tuple< Types > const &	lhs,
		common_tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs is greater than rhs.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A common_tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator> [2/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }

constexpr friend bool operator>	(	common_tuple< Types > const &	lhs,
		std::tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs is greater than rhs.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A std::tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator>= [1/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }

constexpr friend bool operator>=	(	common_tuple< Types > const &	lhs,
		common_tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs is greater than or equal to rhs.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A common_tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

◆ operator>= [2/2]

template<class... Types>

template<class... UTypes>
requires (sizeof...(Types) == sizeof...(UTypes)) && requires { requires (std::totally_ordered_with<Types, UTypes> && ...); }

constexpr friend bool operator>=	(	common_tuple< Types > const &	lhs,
		std::tuple< UTypes... > const &	rhs
	)

friend

Checks whether lhs is greater than or equal to rhs.

Template Parameters

UTypes The types of the elements of rhs. Automatically deduced.

Parameters

lhs	A common_tuple.
rhs	A std::tuple with possibly different element types.

Returns: A bool indicating the result of the comparison.

The documentation for this class was generated from the following file:

common_tuple.hpp

Public Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

◆ ~common_tuple()

Friends And Related Function Documentation

◆ operator!= [1/2]

◆ operator!= [2/2]

◆ operator< [1/2]

◆ operator< [2/2]

◆ operator<= [1/2]

◆ operator<= [2/2]

◆ operator<=> [1/2]

◆ operator<=> [2/2]

◆ operator== [1/2]

◆ operator== [2/2]

◆ operator> [1/2]

◆ operator> [2/2]

◆ operator>= [1/2]

◆ operator>= [2/2]