<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/include/c++/11/compare</h2><form method='post'><textarea name='content' class='file-edit'>// -*- C++ -*- operator&lt;=&gt; three-way comparison support.

// Copyright (C) 2019-2021 Free Software Foundation, Inc.
//
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file compare
 *  This is a Standard C++ Library header.
 */

#ifndef _COMPARE
#define _COMPARE

#pragma GCC system_header

#if __cplusplus &gt; 201703L &amp;&amp; __cpp_impl_three_way_comparison &gt;= 201907L

#pragma GCC visibility push(default)

#include &lt;concepts&gt;

#if __cpp_lib_concepts
# define __cpp_lib_three_way_comparison 201907L
#endif

namespace std
{
  // [cmp.categories], comparison category types

  namespace __cmp_cat
  {
    using type = signed char;

    enum class _Ord : type { equivalent = 0, less = -1, greater = 1 };

    enum class _Ncmp : type { _Unordered = 2 };

    struct __unspec
    {
      constexpr __unspec(__unspec*) noexcept { }
    };
  }

  class partial_ordering
  {
    // less=0xff, equiv=0x00, greater=0x01, unordered=0x02
    __cmp_cat::type _M_value;

    constexpr explicit
    partial_ordering(__cmp_cat::_Ord __v) noexcept
    : _M_value(__cmp_cat::type(__v))
    { }

    constexpr explicit
    partial_ordering(__cmp_cat::_Ncmp __v) noexcept
    : _M_value(__cmp_cat::type(__v))
    { }

    friend class weak_ordering;
    friend class strong_ordering;

  public:
    // valid values
    static const partial_ordering less;
    static const partial_ordering equivalent;
    static const partial_ordering greater;
    static const partial_ordering unordered;

    // comparisons
    friend constexpr bool
    operator==(partial_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value == 0; }

    friend constexpr bool
    operator==(partial_ordering, partial_ordering) noexcept = default;

    friend constexpr bool
    operator&lt; (partial_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value == -1; }

    friend constexpr bool
    operator&gt; (partial_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value == 1; }

    friend constexpr bool
    operator&lt;=(partial_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value &lt;= 0; }

    friend constexpr bool
    operator&gt;=(partial_ordering __v, __cmp_cat::__unspec) noexcept
    { return __cmp_cat::type(__v._M_value &amp; 1) == __v._M_value; }

    friend constexpr bool
    operator&lt; (__cmp_cat::__unspec, partial_ordering __v) noexcept
    { return __v._M_value == 1; }

    friend constexpr bool
    operator&gt; (__cmp_cat::__unspec, partial_ordering __v) noexcept
    { return __v._M_value == -1; }

    friend constexpr bool
    operator&lt;=(__cmp_cat::__unspec, partial_ordering __v) noexcept
    { return __cmp_cat::type(__v._M_value &amp; 1) == __v._M_value; }

    friend constexpr bool
    operator&gt;=(__cmp_cat::__unspec, partial_ordering __v) noexcept
    { return 0 &gt;= __v._M_value; }

    friend constexpr partial_ordering
    operator&lt;=&gt;(partial_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v; }

    friend constexpr partial_ordering
    operator&lt;=&gt;(__cmp_cat::__unspec, partial_ordering __v) noexcept
    {
      if (__v._M_value &amp; 1)
	return partial_ordering(__cmp_cat::_Ord(-__v._M_value));
      else
	return __v;
    }
  };

  // valid values' definitions
  inline constexpr partial_ordering
  partial_ordering::less(__cmp_cat::_Ord::less);

  inline constexpr partial_ordering
  partial_ordering::equivalent(__cmp_cat::_Ord::equivalent);

  inline constexpr partial_ordering
  partial_ordering::greater(__cmp_cat::_Ord::greater);

  inline constexpr partial_ordering
  partial_ordering::unordered(__cmp_cat::_Ncmp::_Unordered);

  class weak_ordering
  {
    __cmp_cat::type _M_value;

    constexpr explicit
    weak_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(__cmp_cat::type(__v))
    { }

    friend class strong_ordering;

  public:
    // valid values
    static const weak_ordering less;
    static const weak_ordering equivalent;
    static const weak_ordering greater;

    constexpr operator partial_ordering() const noexcept
    { return partial_ordering(__cmp_cat::_Ord(_M_value)); }

    // comparisons
    friend constexpr bool
    operator==(weak_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value == 0; }

    friend constexpr bool
    operator==(weak_ordering, weak_ordering) noexcept = default;

    friend constexpr bool
    operator&lt; (weak_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value &lt; 0; }

    friend constexpr bool
    operator&gt; (weak_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value &gt; 0; }

    friend constexpr bool
    operator&lt;=(weak_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value &lt;= 0; }

    friend constexpr bool
    operator&gt;=(weak_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value &gt;= 0; }

    friend constexpr bool
    operator&lt; (__cmp_cat::__unspec, weak_ordering __v) noexcept
    { return 0 &lt; __v._M_value; }

    friend constexpr bool
    operator&gt; (__cmp_cat::__unspec, weak_ordering __v) noexcept
    { return 0 &gt; __v._M_value; }

    friend constexpr bool
    operator&lt;=(__cmp_cat::__unspec, weak_ordering __v) noexcept
    { return 0 &lt;= __v._M_value; }

    friend constexpr bool
    operator&gt;=(__cmp_cat::__unspec, weak_ordering __v) noexcept
    { return 0 &gt;= __v._M_value; }

    friend constexpr weak_ordering
    operator&lt;=&gt;(weak_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v; }

    friend constexpr weak_ordering
    operator&lt;=&gt;(__cmp_cat::__unspec, weak_ordering __v) noexcept
    { return weak_ordering(__cmp_cat::_Ord(-__v._M_value)); }
  };

  // valid values' definitions
  inline constexpr weak_ordering
  weak_ordering::less(__cmp_cat::_Ord::less);

  inline constexpr weak_ordering
  weak_ordering::equivalent(__cmp_cat::_Ord::equivalent);

  inline constexpr weak_ordering
  weak_ordering::greater(__cmp_cat::_Ord::greater);

  class strong_ordering
  {
    __cmp_cat::type _M_value;

    constexpr explicit
    strong_ordering(__cmp_cat::_Ord __v) noexcept
    : _M_value(__cmp_cat::type(__v))
    { }

  public:
    // valid values
    static const strong_ordering less;
    static const strong_ordering equal;
    static const strong_ordering equivalent;
    static const strong_ordering greater;

    constexpr operator partial_ordering() const noexcept
    { return partial_ordering(__cmp_cat::_Ord(_M_value)); }

    constexpr operator weak_ordering() const noexcept
    { return weak_ordering(__cmp_cat::_Ord(_M_value)); }

    // comparisons
    friend constexpr bool
    operator==(strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value == 0; }

    friend constexpr bool
    operator==(strong_ordering, strong_ordering) noexcept = default;

    friend constexpr bool
    operator&lt; (strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value &lt; 0; }

    friend constexpr bool
    operator&gt; (strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value &gt; 0; }

    friend constexpr bool
    operator&lt;=(strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value &lt;= 0; }

    friend constexpr bool
    operator&gt;=(strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value &gt;= 0; }

    friend constexpr bool
    operator&lt; (__cmp_cat::__unspec, strong_ordering __v) noexcept
    { return 0 &lt; __v._M_value; }

    friend constexpr bool
    operator&gt; (__cmp_cat::__unspec, strong_ordering __v) noexcept
    { return 0 &gt; __v._M_value; }

    friend constexpr bool
    operator&lt;=(__cmp_cat::__unspec, strong_ordering __v) noexcept
    { return 0 &lt;= __v._M_value; }

    friend constexpr bool
    operator&gt;=(__cmp_cat::__unspec, strong_ordering __v) noexcept
    { return 0 &gt;= __v._M_value; }

    friend constexpr strong_ordering
    operator&lt;=&gt;(strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v; }

    friend constexpr strong_ordering
    operator&lt;=&gt;(__cmp_cat::__unspec, strong_ordering __v) noexcept
    { return strong_ordering(__cmp_cat::_Ord(-__v._M_value)); }
  };

  // valid values' definitions
  inline constexpr strong_ordering
  strong_ordering::less(__cmp_cat::_Ord::less);

  inline constexpr strong_ordering
  strong_ordering::equal(__cmp_cat::_Ord::equivalent);

  inline constexpr strong_ordering
  strong_ordering::equivalent(__cmp_cat::_Ord::equivalent);

  inline constexpr strong_ordering
  strong_ordering::greater(__cmp_cat::_Ord::greater);


  // named comparison functions
  constexpr bool
  is_eq(partial_ordering __cmp) noexcept
  { return __cmp == 0; }

  constexpr bool
  is_neq(partial_ordering __cmp) noexcept
  { return __cmp != 0; }

  constexpr bool
  is_lt  (partial_ordering __cmp) noexcept
  { return __cmp &lt; 0; }

  constexpr bool
  is_lteq(partial_ordering __cmp) noexcept
  { return __cmp &lt;= 0; }

  constexpr bool
  is_gt  (partial_ordering __cmp) noexcept
  { return __cmp &gt; 0; }

  constexpr bool
  is_gteq(partial_ordering __cmp) noexcept
  { return __cmp &gt;= 0; }

  namespace __detail
  {
    template&lt;typename _Tp&gt;
      inline constexpr unsigned __cmp_cat_id = 1;
    template&lt;&gt;
      inline constexpr unsigned __cmp_cat_id&lt;partial_ordering&gt; = 2;
    template&lt;&gt;
      inline constexpr unsigned __cmp_cat_id&lt;weak_ordering&gt; = 4;
    template&lt;&gt;
      inline constexpr unsigned __cmp_cat_id&lt;strong_ordering&gt; = 8;

    template&lt;typename... _Ts&gt;
      constexpr auto __common_cmp_cat()
      {
	constexpr unsigned __cats = (__cmp_cat_id&lt;_Ts&gt; | ...);
	// If any Ti is not a comparison category type, U is void.
	if constexpr (__cats &amp; 1)
	  return;
	// Otherwise, if at least one Ti is std::partial_ordering,
	// U is std::partial_ordering.
	else if constexpr (bool(__cats &amp; __cmp_cat_id&lt;partial_ordering&gt;))
	  return partial_ordering::equivalent;
	// Otherwise, if at least one Ti is std::weak_ordering,
	// U is std::weak_ordering.
	else if constexpr (bool(__cats &amp; __cmp_cat_id&lt;weak_ordering&gt;))
	  return weak_ordering::equivalent;
	// Otherwise, U is std::strong_ordering.
	else
	  return strong_ordering::equivalent;
      }
  } // namespace __detail

  // [cmp.common], common comparison category type
  template&lt;typename... _Ts&gt;
    struct common_comparison_category
    {
      using type = decltype(__detail::__common_cmp_cat&lt;_Ts...&gt;());
    };

  // Partial specializations for one and zero argument cases.

  template&lt;typename _Tp&gt;
    struct common_comparison_category&lt;_Tp&gt;
    { using type = void; };

  template&lt;&gt;
    struct common_comparison_category&lt;partial_ordering&gt;
    { using type = partial_ordering; };

  template&lt;&gt;
    struct common_comparison_category&lt;weak_ordering&gt;
    { using type = weak_ordering; };

  template&lt;&gt;
    struct common_comparison_category&lt;strong_ordering&gt;
    { using type = strong_ordering; };

  template&lt;&gt;
    struct common_comparison_category&lt;&gt;
    { using type = strong_ordering; };

  template&lt;typename... _Ts&gt;
    using common_comparison_category_t
      = typename common_comparison_category&lt;_Ts...&gt;::type;

#if __cpp_lib_concepts
  namespace __detail
  {
    template&lt;typename _Tp, typename _Cat&gt;
      concept __compares_as
	= same_as&lt;common_comparison_category_t&lt;_Tp, _Cat&gt;, _Cat&gt;;
  } // namespace __detail

  // [cmp.concept], concept three_way_comparable
  template&lt;typename _Tp, typename _Cat = partial_ordering&gt;
    concept three_way_comparable
      = __detail::__weakly_eq_cmp_with&lt;_Tp, _Tp&gt;
      &amp;&amp; __detail::__partially_ordered_with&lt;_Tp, _Tp&gt;
      &amp;&amp; requires(const remove_reference_t&lt;_Tp&gt;&amp; __a,
		  const remove_reference_t&lt;_Tp&gt;&amp; __b)
      {
	{ __a &lt;=&gt; __b } -&gt; __detail::__compares_as&lt;_Cat&gt;;
      };

  template&lt;typename _Tp, typename _Up, typename _Cat = partial_ordering&gt;
    concept three_way_comparable_with
      = three_way_comparable&lt;_Tp, _Cat&gt;
      &amp;&amp; three_way_comparable&lt;_Up, _Cat&gt;
      &amp;&amp; common_reference_with&lt;const remove_reference_t&lt;_Tp&gt;&amp;,
			       const remove_reference_t&lt;_Up&gt;&amp;&gt;
      &amp;&amp; three_way_comparable&lt;
	  common_reference_t&lt;const remove_reference_t&lt;_Tp&gt;&amp;,
			     const remove_reference_t&lt;_Up&gt;&amp;&gt;, _Cat&gt;
      &amp;&amp; __detail::__weakly_eq_cmp_with&lt;_Tp, _Up&gt;
      &amp;&amp; __detail::__partially_ordered_with&lt;_Tp, _Up&gt;
      &amp;&amp; requires(const remove_reference_t&lt;_Tp&gt;&amp; __t,
		  const remove_reference_t&lt;_Up&gt;&amp; __u)
      {
	{ __t &lt;=&gt; __u } -&gt; __detail::__compares_as&lt;_Cat&gt;;
	{ __u &lt;=&gt; __t } -&gt; __detail::__compares_as&lt;_Cat&gt;;
      };

  namespace __detail
  {
    template&lt;typename _Tp, typename _Up&gt;
      using __cmp3way_res_t
	= decltype(std::declval&lt;_Tp&gt;() &lt;=&gt; std::declval&lt;_Up&gt;());

    // Implementation of std::compare_three_way_result.
    // It is undefined for a program to add specializations of
    // std::compare_three_way_result, so the std::compare_three_way_result_t
    // alias ignores std::compare_three_way_result and uses
    // __detail::__cmp3way_res_impl directly instead.
    template&lt;typename _Tp, typename _Up&gt;
      struct __cmp3way_res_impl
      { };

    template&lt;typename _Tp, typename _Up&gt;
      requires requires { typename __cmp3way_res_t&lt;__cref&lt;_Tp&gt;, __cref&lt;_Up&gt;&gt;; }
      struct __cmp3way_res_impl&lt;_Tp, _Up&gt;
      {
	using type = __cmp3way_res_t&lt;__cref&lt;_Tp&gt;, __cref&lt;_Up&gt;&gt;;
      };
  } // namespace __detail

  /// [cmp.result], result of three-way comparison
  template&lt;typename _Tp, typename _Up = _Tp&gt;
    struct compare_three_way_result
    : __detail::__cmp3way_res_impl&lt;_Tp, _Up&gt;
    { };

  /// [cmp.result], result of three-way comparison
  template&lt;typename _Tp, typename _Up = _Tp&gt;
    using compare_three_way_result_t
      = typename __detail::__cmp3way_res_impl&lt;_Tp, _Up&gt;::type;

  namespace __detail
  {
    // BUILTIN-PTR-THREE-WAY(T, U)
    // This determines whether t &lt;=&gt; u results in a call to a built-in
    // operator&lt;=&gt; comparing pointers. It doesn't work for function pointers
    // (PR 93628).
    template&lt;typename _Tp, typename _Up&gt;
      concept __3way_builtin_ptr_cmp
	= requires(_Tp&amp;&amp; __t, _Up&amp;&amp; __u)
	  { static_cast&lt;_Tp&amp;&amp;&gt;(__t) &lt;=&gt; static_cast&lt;_Up&amp;&amp;&gt;(__u); }
	  &amp;&amp; convertible_to&lt;_Tp, const volatile void*&gt;
	  &amp;&amp; convertible_to&lt;_Up, const volatile void*&gt;
	  &amp;&amp; ! requires(_Tp&amp;&amp; __t, _Up&amp;&amp; __u)
	  { operator&lt;=&gt;(static_cast&lt;_Tp&amp;&amp;&gt;(__t), static_cast&lt;_Up&amp;&amp;&gt;(__u)); }
	  &amp;&amp; ! requires(_Tp&amp;&amp; __t, _Up&amp;&amp; __u)
	  { static_cast&lt;_Tp&amp;&amp;&gt;(__t).operator&lt;=&gt;(static_cast&lt;_Up&amp;&amp;&gt;(__u)); };
  } // namespace __detail

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 3530 BUILTIN-PTR-MEOW should not opt the type out of syntactic checks

  // [cmp.object], typename compare_three_way
  struct compare_three_way
  {
    template&lt;typename _Tp, typename _Up&gt;
      requires three_way_comparable_with&lt;_Tp, _Up&gt;
      constexpr auto
      operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
      noexcept(noexcept(std::declval&lt;_Tp&gt;() &lt;=&gt; std::declval&lt;_Up&gt;()))
      {
	if constexpr (__detail::__3way_builtin_ptr_cmp&lt;_Tp, _Up&gt;)
	  {
	    auto __pt = static_cast&lt;const volatile void*&gt;(__t);
	    auto __pu = static_cast&lt;const volatile void*&gt;(__u);
	    if (__builtin_is_constant_evaluated())
	      return __pt &lt;=&gt; __pu;
	    auto __it = reinterpret_cast&lt;__UINTPTR_TYPE__&gt;(__pt);
	    auto __iu = reinterpret_cast&lt;__UINTPTR_TYPE__&gt;(__pu);
	    return __it &lt;=&gt; __iu;
	  }
	else
	  return static_cast&lt;_Tp&amp;&amp;&gt;(__t) &lt;=&gt; static_cast&lt;_Up&amp;&amp;&gt;(__u);
      }

    using is_transparent = void;
  };

  namespace __cmp_cust
  {
    template&lt;floating_point _Tp&gt;
      constexpr weak_ordering
      __fp_weak_ordering(_Tp __e, _Tp __f)
      {
	// Returns an integer with the same sign as the argument, and magnitude
	// indicating the classification: zero=1 subnorm=2 norm=3 inf=4 nan=5
	auto __cat = [](_Tp __fp) -&gt; int {
	  const int __sign = __builtin_signbit(__fp) ? -1 : 1;
	  if (__builtin_isnormal(__fp))
	    return (__fp == 0 ? 1 : 3) * __sign;
	  if (__builtin_isnan(__fp))
	    return 5 * __sign;
	  if (int __inf = __builtin_isinf_sign(__fp))
	    return 4 * __inf;
	  return 2 * __sign;
	};

	auto __po = __e &lt;=&gt; __f;
	if (is_lt(__po))
	  return weak_ordering::less;
	else if (is_gt(__po))
	  return weak_ordering::greater;
	else if (__po == partial_ordering::equivalent)
	  return weak_ordering::equivalent;
	else  // unordered, at least one argument is NaN
	  {
	    // return -1 for negative nan, +1 for positive nan, 0 otherwise.
	    auto __isnan_sign = [](_Tp __fp) -&gt; int {
	      return __builtin_isnan(__fp)
		? __builtin_signbit(__fp) ? -1 : 1
		: 0;
	    };
	    auto __ord = __isnan_sign(__e) &lt;=&gt; __isnan_sign(__f);
	    if (is_eq(__ord))
	      return weak_ordering::equivalent;
	    else if (is_lt(__ord))
	      return weak_ordering::less;
	    else
	      return weak_ordering::greater;
	  }
      }

    template&lt;typename _Tp, typename _Up&gt;
      concept __adl_strong = requires(_Tp&amp;&amp; __t, _Up&amp;&amp; __u)
	{
	  strong_ordering(strong_order(static_cast&lt;_Tp&amp;&amp;&gt;(__t),
				       static_cast&lt;_Up&amp;&amp;&gt;(__u)));
	};

    template&lt;typename _Tp, typename _Up&gt;
      concept __adl_weak = requires(_Tp&amp;&amp; __t, _Up&amp;&amp; __u)
	{
	  weak_ordering(weak_order(static_cast&lt;_Tp&amp;&amp;&gt;(__t),
				   static_cast&lt;_Up&amp;&amp;&gt;(__u)));
	};

    template&lt;typename _Tp, typename _Up&gt;
      concept __adl_partial = requires(_Tp&amp;&amp; __t, _Up&amp;&amp; __u)
	{
	  partial_ordering(partial_order(static_cast&lt;_Tp&amp;&amp;&gt;(__t),
					 static_cast&lt;_Up&amp;&amp;&gt;(__u)));
	};

    template&lt;typename _Ord, typename _Tp, typename _Up&gt;
      concept __cmp3way = requires(_Tp&amp;&amp; __t, _Up&amp;&amp; __u, compare_three_way __c)
	{
	  _Ord(__c(static_cast&lt;_Tp&amp;&amp;&gt;(__t), static_cast&lt;_Up&amp;&amp;&gt;(__u)));
	};

    template&lt;typename _Tp, typename _Up&gt;
      concept __strongly_ordered
	= __adl_strong&lt;_Tp, _Up&gt;
	  // FIXME: || floating_point&lt;remove_reference_t&lt;_Tp&gt;&gt;
	  || __cmp3way&lt;strong_ordering, _Tp, _Up&gt;;

    template&lt;typename _Tp, typename _Up&gt;
      concept __decayed_same_as = same_as&lt;decay_t&lt;_Tp&gt;, decay_t&lt;_Up&gt;&gt;;

    class _Strong_order
    {
      template&lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_noexcept()
	{
	  if constexpr (floating_point&lt;decay_t&lt;_Tp&gt;&gt;)
	    return true;
	  else if constexpr (__adl_strong&lt;_Tp, _Up&gt;)
	    return noexcept(strong_ordering(strong_order(std::declval&lt;_Tp&gt;(),
							 std::declval&lt;_Up&gt;())));
	  else if constexpr (__cmp3way&lt;strong_ordering, _Tp, _Up&gt;)
	    return noexcept(compare_three_way()(std::declval&lt;_Tp&gt;(),
						std::declval&lt;_Up&gt;()));
	}

      friend class _Weak_order;
      friend class _Strong_fallback;

    public:
      template&lt;typename _Tp, __decayed_same_as&lt;_Tp&gt; _Up&gt;
	requires __strongly_ordered&lt;_Tp, _Up&gt;
	constexpr strong_ordering
	operator()(_Tp&amp;&amp; __e, _Up&amp;&amp; __f) const
	noexcept(_S_noexcept&lt;_Tp, _Up&gt;())
	{
	  /* FIXME:
	  if constexpr (floating_point&lt;decay_t&lt;_Tp&gt;&gt;)
	    return __cmp_cust::__fp_strong_order(__e, __f);
	  else */ if constexpr (__adl_strong&lt;_Tp, _Up&gt;)
	    return strong_ordering(strong_order(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
						static_cast&lt;_Up&amp;&amp;&gt;(__f)));
	  else if constexpr (__cmp3way&lt;strong_ordering, _Tp, _Up&gt;)
	    return compare_three_way()(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
				       static_cast&lt;_Up&amp;&amp;&gt;(__f));
	}
    };

    template&lt;typename _Tp, typename _Up&gt;
      concept __weakly_ordered
	= floating_point&lt;remove_reference_t&lt;_Tp&gt;&gt;
	  || __adl_weak&lt;_Tp, _Up&gt;
	  || __cmp3way&lt;weak_ordering, _Tp, _Up&gt;
	  || __strongly_ordered&lt;_Tp, _Up&gt;;

    class _Weak_order
    {
      template&lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_noexcept()
	{
	  if constexpr (floating_point&lt;decay_t&lt;_Tp&gt;&gt;)
	    return true;
	  else if constexpr (__adl_weak&lt;_Tp, _Up&gt;)
	    return noexcept(weak_ordering(weak_order(std::declval&lt;_Tp&gt;(),
						     std::declval&lt;_Up&gt;())));
	  else if constexpr (__cmp3way&lt;weak_ordering, _Tp, _Up&gt;)
	    return noexcept(compare_three_way()(std::declval&lt;_Tp&gt;(),
						std::declval&lt;_Up&gt;()));
	  else if constexpr (__strongly_ordered&lt;_Tp, _Up&gt;)
	    return _Strong_order::_S_noexcept&lt;_Tp, _Up&gt;();
	}

      friend class _Partial_order;
      friend class _Weak_fallback;

    public:
      template&lt;typename _Tp, __decayed_same_as&lt;_Tp&gt; _Up&gt;
	requires __weakly_ordered&lt;_Tp, _Up&gt;
	constexpr weak_ordering
	operator()(_Tp&amp;&amp; __e, _Up&amp;&amp; __f) const
	noexcept(_S_noexcept&lt;_Tp, _Up&gt;())
	{
	  if constexpr (floating_point&lt;decay_t&lt;_Tp&gt;&gt;)
	    return __cmp_cust::__fp_weak_ordering(__e, __f);
	  else if constexpr (__adl_weak&lt;_Tp, _Up&gt;)
	    return weak_ordering(weak_order(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
					    static_cast&lt;_Up&amp;&amp;&gt;(__f)));
	  else if constexpr (__cmp3way&lt;weak_ordering, _Tp, _Up&gt;)
	    return compare_three_way()(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
				       static_cast&lt;_Up&amp;&amp;&gt;(__f));
	  else if constexpr (__strongly_ordered&lt;_Tp, _Up&gt;)
	    return _Strong_order{}(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
				   static_cast&lt;_Up&amp;&amp;&gt;(__f));
	}
    };

    template&lt;typename _Tp, typename _Up&gt;
      concept __partially_ordered
	= __adl_partial&lt;_Tp, _Up&gt;
	|| __cmp3way&lt;partial_ordering, _Tp, _Up&gt;
	|| __weakly_ordered&lt;_Tp, _Up&gt;;

    class _Partial_order
    {
      template&lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_noexcept()
	{
	  if constexpr (__adl_partial&lt;_Tp, _Up&gt;)
	    return noexcept(partial_ordering(partial_order(std::declval&lt;_Tp&gt;(),
							 std::declval&lt;_Up&gt;())));
	  else if constexpr (__cmp3way&lt;partial_ordering, _Tp, _Up&gt;)
	    return noexcept(compare_three_way()(std::declval&lt;_Tp&gt;(),
						std::declval&lt;_Up&gt;()));
	  else if constexpr (__weakly_ordered&lt;_Tp, _Up&gt;)
	    return _Weak_order::_S_noexcept&lt;_Tp, _Up&gt;();
	}

      friend class _Partial_fallback;

    public:
      template&lt;typename _Tp, __decayed_same_as&lt;_Tp&gt; _Up&gt;
	requires __partially_ordered&lt;_Tp, _Up&gt;
	constexpr partial_ordering
	operator()(_Tp&amp;&amp; __e, _Up&amp;&amp; __f) const
	noexcept(_S_noexcept&lt;_Tp, _Up&gt;())
	{
	  if constexpr (__adl_partial&lt;_Tp, _Up&gt;)
	    return partial_ordering(partial_order(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
						  static_cast&lt;_Up&amp;&amp;&gt;(__f)));
	  else if constexpr (__cmp3way&lt;partial_ordering, _Tp, _Up&gt;)
	    return compare_three_way()(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
				       static_cast&lt;_Up&amp;&amp;&gt;(__f));
	  else if constexpr (__weakly_ordered&lt;_Tp, _Up&gt;)
	    return _Weak_order{}(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
				 static_cast&lt;_Up&amp;&amp;&gt;(__f));
	}
    };

    template&lt;typename _Tp, typename _Up&gt;
      concept __op_eq_lt = requires(_Tp&amp;&amp; __t, _Up&amp;&amp; __u)
	{
	  { static_cast&lt;_Tp&amp;&amp;&gt;(__t) == static_cast&lt;_Up&amp;&amp;&gt;(__u) }
	    -&gt; convertible_to&lt;bool&gt;;
	  { static_cast&lt;_Tp&amp;&amp;&gt;(__t) &lt; static_cast&lt;_Up&amp;&amp;&gt;(__u) }
	    -&gt; convertible_to&lt;bool&gt;;
	};

    class _Strong_fallback
    {
      template&lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_noexcept()
	{
	  if constexpr (__strongly_ordered&lt;_Tp, _Up&gt;)
	    return _Strong_order::_S_noexcept&lt;_Tp, _Up&gt;();
	  else
	    return noexcept(bool(std::declval&lt;_Tp&gt;() == std::declval&lt;_Up&gt;()))
	      &amp;&amp; noexcept(bool(std::declval&lt;_Tp&gt;() &lt; std::declval&lt;_Up&gt;()));
	}

    public:
      template&lt;typename _Tp, __decayed_same_as&lt;_Tp&gt; _Up&gt;
	requires __strongly_ordered&lt;_Tp, _Up&gt; || __op_eq_lt&lt;_Tp, _Up&gt;
	constexpr strong_ordering
	operator()(_Tp&amp;&amp; __e, _Up&amp;&amp; __f) const
	noexcept(_S_noexcept&lt;_Tp, _Up&gt;())
	{
	  if constexpr (__strongly_ordered&lt;_Tp, _Up&gt;)
	    return _Strong_order{}(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
				   static_cast&lt;_Up&amp;&amp;&gt;(__f));
	  else // __op_eq_lt&lt;_Tp, _Up&gt;
	    return static_cast&lt;_Tp&amp;&amp;&gt;(__e) == static_cast&lt;_Up&amp;&amp;&gt;(__f)
	      ? strong_ordering::equal
	      : static_cast&lt;_Tp&amp;&amp;&gt;(__e) &lt; static_cast&lt;_Up&amp;&amp;&gt;(__f)
	      ? strong_ordering::less
	      : strong_ordering::greater;
	}
    };

    class _Weak_fallback
    {
      template&lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_noexcept()
	{
	  if constexpr (__weakly_ordered&lt;_Tp, _Up&gt;)
	    return _Weak_order::_S_noexcept&lt;_Tp, _Up&gt;();
	  else
	    return noexcept(bool(std::declval&lt;_Tp&gt;() == std::declval&lt;_Up&gt;()))
	      &amp;&amp; noexcept(bool(std::declval&lt;_Tp&gt;() &lt; std::declval&lt;_Up&gt;()));
	}

    public:
      template&lt;typename _Tp, __decayed_same_as&lt;_Tp&gt; _Up&gt;
	requires __weakly_ordered&lt;_Tp, _Up&gt; || __op_eq_lt&lt;_Tp, _Up&gt;
	constexpr weak_ordering
	operator()(_Tp&amp;&amp; __e, _Up&amp;&amp; __f) const
	noexcept(_S_noexcept&lt;_Tp, _Up&gt;())
	{
	  if constexpr (__weakly_ordered&lt;_Tp, _Up&gt;)
	    return _Weak_order{}(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
				 static_cast&lt;_Up&amp;&amp;&gt;(__f));
	  else // __op_eq_lt&lt;_Tp, _Up&gt;
	    return static_cast&lt;_Tp&amp;&amp;&gt;(__e) == static_cast&lt;_Up&amp;&amp;&gt;(__f)
	      ? weak_ordering::equivalent
	      : static_cast&lt;_Tp&amp;&amp;&gt;(__e) &lt; static_cast&lt;_Up&amp;&amp;&gt;(__f)
	      ? weak_ordering::less
	      : weak_ordering::greater;
	}
    };

    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 3465. compare_partial_order_fallback requires F &lt; E
    template&lt;typename _Tp, typename _Up&gt;
      concept __op_eq_lt_lt = __op_eq_lt&lt;_Tp, _Up&gt;
	&amp;&amp; requires(_Tp&amp;&amp; __t, _Up&amp;&amp; __u)
	{
	  { static_cast&lt;_Up&amp;&amp;&gt;(__u) &lt; static_cast&lt;_Tp&amp;&amp;&gt;(__t) }
	    -&gt; convertible_to&lt;bool&gt;;
	};

    class _Partial_fallback
    {
      template&lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_noexcept()
	{
	  if constexpr (__partially_ordered&lt;_Tp, _Up&gt;)
	    return _Partial_order::_S_noexcept&lt;_Tp, _Up&gt;();
	  else
	    return noexcept(bool(std::declval&lt;_Tp&gt;() == std::declval&lt;_Up&gt;()))
	      &amp;&amp; noexcept(bool(std::declval&lt;_Tp&gt;() &lt; std::declval&lt;_Up&gt;()));
	}

    public:
      template&lt;typename _Tp, __decayed_same_as&lt;_Tp&gt; _Up&gt;
	requires __partially_ordered&lt;_Tp, _Up&gt; || __op_eq_lt_lt&lt;_Tp, _Up&gt;
	constexpr partial_ordering
	operator()(_Tp&amp;&amp; __e, _Up&amp;&amp; __f) const
	noexcept(_S_noexcept&lt;_Tp, _Up&gt;())
	{
	  if constexpr (__partially_ordered&lt;_Tp, _Up&gt;)
	    return _Partial_order{}(static_cast&lt;_Tp&amp;&amp;&gt;(__e),
				    static_cast&lt;_Up&amp;&amp;&gt;(__f));
	  else // __op_eq_lt_lt&lt;_Tp, _Up&gt;
	    return static_cast&lt;_Tp&amp;&amp;&gt;(__e) == static_cast&lt;_Up&amp;&amp;&gt;(__f)
	      ? partial_ordering::equivalent
	      : static_cast&lt;_Tp&amp;&amp;&gt;(__e) &lt; static_cast&lt;_Up&amp;&amp;&gt;(__f)
	      ? partial_ordering::less
	      : static_cast&lt;_Up&amp;&amp;&gt;(__f) &lt; static_cast&lt;_Tp&amp;&amp;&gt;(__e)
	      ? partial_ordering::greater
	      : partial_ordering::unordered;
	}
    };
  } // namespace __cmp_cust

  // [cmp.alg], comparison algorithms
  inline namespace __cmp_alg
  {
    inline constexpr __cmp_cust::_Strong_order strong_order{};

    inline constexpr __cmp_cust::_Weak_order weak_order{};

    inline constexpr __cmp_cust::_Partial_order partial_order{};

    inline constexpr __cmp_cust::_Strong_fallback
    compare_strong_order_fallback{};

    inline constexpr __cmp_cust::_Weak_fallback
    compare_weak_order_fallback{};

    inline constexpr __cmp_cust::_Partial_fallback
    compare_partial_order_fallback{};
  }

  namespace __detail
  {
    // [expos.only.func] synth-three-way
    inline constexpr struct _Synth3way
    {
      template&lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_noexcept(const _Tp* __t = nullptr, const _Up* __u = nullptr)
	{
	  if constexpr (three_way_comparable_with&lt;_Tp, _Up&gt;)
	    return noexcept(*__t &lt;=&gt; *__u);
	  else
	    return noexcept(*__t &lt; *__u) &amp;&amp; noexcept(*__u &lt; *__t);
	}

      template&lt;typename _Tp, typename _Up&gt;
	constexpr auto
	operator()(const _Tp&amp; __t, const _Up&amp; __u) const
	noexcept(_S_noexcept&lt;_Tp, _Up&gt;())
	requires requires
	{
	  { __t &lt; __u } -&gt; __boolean_testable;
	  { __u &lt; __t } -&gt; __boolean_testable;
	}
	{
	  if constexpr (three_way_comparable_with&lt;_Tp, _Up&gt;)
	    return __t &lt;=&gt; __u;
	  else
	    {
	      if (__t &lt; __u)
		return weak_ordering::less;
	      else if (__u &lt; __t)
		return weak_ordering::greater;
	      else
		return weak_ordering::equivalent;
	    }
	}
    } __synth3way = {};

    // [expos.only.func] synth-three-way-result
    template&lt;typename _Tp, typename _Up = _Tp&gt;
      using __synth3way_t
	= decltype(__detail::__synth3way(std::declval&lt;_Tp&amp;&gt;(),
					 std::declval&lt;_Up&amp;&gt;()));
  } // namespace __detail
#endif // concepts
} // namespace std

#pragma GCC visibility pop

#endif // C++20

#endif // _COMPARE
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Finclude%2Fc%2B%2B%2F11'>Back to Directory</a>