home | help 
std::common...son_category(3)  C++ Standard Libary std::common...son_category(3)

NAME
     std::common_comparison_category - std::common_comparison_category

Synopsis
	Defined in header <compare>
	template< class... Ts >

	struct common_comparison_category
	{				    (since C++20)
	    using type = /* see below */ ;

	};

	The class template std::common_comparison_category provides an alias (as
     the member
	typedef  type) for the strongest comparison category to which all of the
     template
	arguments Ts... can be converted.

	In detail, the common comparison type of a list of n types T[0]...T[n-1]
     is defined
	as follows:

	  * If any T[i] is not a comparison category  type  (std::partial_order-
     ing,
	    std::weak_ordering, std::strong_ordering), U is void.
	  * Otherwise, if at least one T[i] is std::partial_ordering, U is
	    std::partial_ordering.
	  *  Otherwise,  if  at  least	one  T[i]  is  std::weak_ordering,  U is
     std::weak_ordering.
	  * Otherwise (if every T[i] is std::strong_ordering, or if the list  is
     empty), U is
	    std::strong_ordering.

Template parameters
	...Ts - a possibly empty list of types

	Helper template

	template< class... Ts >
	using			common_comparison_category_t		       =
     (since C++20)
	common_comparison_category<Ts...>::type;

Member types
	Member type Definition
	type	    the strongest common comparison category (as defined above)

Possible implementation
	namespace detail
	{
	    template<unsigned int>
	    struct common_cmpcat_base	  { using type = void; };
	    template<>
	    struct common_cmpcat_base<0u> { using type	=  std::strong_ordering;
     };
	    template<>
	    struct  common_cmpcat_base<2u> { using type = std::partial_ordering;
     };
	    template<>
	    struct common_cmpcat_base<4u> { using type = std::weak_ordering; };
	    template<>
	    struct common_cmpcat_base<6u> { using type =  std::partial_ordering;
     };
	} // namespace detail

	template<class...Ts>
	struct common_comparison_category :
	    detail::common_cmpcat_base<(0u | ... |
		(std::is_same_v<Ts, std::strong_ordering>  ? 0u :
		 std::is_same_v<Ts, std::weak_ordering>    ? 4u :
		 std::is_same_v<Ts, std::partial_ordering> ? 2u : 1u)
	    )> {};

Example
	 This section is incomplete
	 Reason: no example

See also
	strong_ordering  the result type of 3-way comparison that supports all 6
     operators
	(C++20) 	 and is substitutable
			 (class)
	weak_ordering	 the result type of 3-way comparison that supports all 6
     operators
	(C++20) 	 and is not substitutable
			 (class)
	partial_ordering the result type of 3-way comparison that supports all 6
     operators,
	(C++20) 	 is not substitutable, and allows incomparable values
			 (class)

Category:
	  * Todo no example

http://cppreference.com 	   2024.06.10	   std::common...son_category(3)
home | help