libcxx/include/experimental/propagate_const

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
  11 #define _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
  12
  13 /*
  14     propagate_const synopsis
  15
  16     namespace std { namespace experimental { inline namespace fundamentals_v2 {
  17
  18     // [propagate_const]
  19     template <class T> class propagate_const;
  20
  21     // [propagate_const.underlying], underlying pointer access
  22     constexpr const _Tp& get_underlying(const propagate_const<T>& pt) noexcept;
  23     constexpr T& get_underlying(propagate_const<T>& pt) noexcept;
  24
  25     // [propagate_const.relational], relational operators
  26     template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
  27     template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu);
  28     template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t);
  29     template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu);
  30     template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
  31     template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
  32     template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
  33     template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
  34     template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
  35     template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
  36     template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u);
  37     template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u);
  38     template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u);
  39     template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u);
  40     template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u);
  41     template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u);
  42     template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu);
  43     template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu);
  44     template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu);
  45     template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu);
  46     template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu);
  47     template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu);
  48
  49     // [propagate_const.algorithms], specialized algorithms
  50     template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below);
  51
  52     template <class T>
  53     class propagate_const
  54     {
  55
  56     public:
  57       typedef remove_reference_t<decltype(*declval<T&>())> element_type;
  58
  59       // [propagate_const.ctor], constructors
  60       constexpr propagate_const() = default;
  61       propagate_const(const propagate_const& p) = delete;
  62       constexpr propagate_const(propagate_const&& p) = default;
  63       template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below
  64       template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below
  65
  66       // [propagate_const.assignment], assignment
  67       propagate_const& operator=(const propagate_const& p) = delete;
  68       constexpr propagate_const& operator=(propagate_const&& p) = default;
  69       template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
  70       template <class U> constexpr propagate_const& operator=(U&& u); // see below
  71
  72       // [propagate_const.const_observers], const observers
  73       explicit constexpr operator bool() const;
  74       constexpr const element_type* operator->() const;
  75       constexpr operator const element_type*() const; // Not always defined
  76       constexpr const element_type& operator*() const;
  77       constexpr const element_type* get() const;
  78
  79       // [propagate_const.non_const_observers], non-const observers
  80       constexpr element_type* operator->();
  81       constexpr operator element_type*(); // Not always defined
  82       constexpr element_type& operator*();
  83       constexpr element_type* get();
  84
  85       // [propagate_const.modifiers], modifiers
  86       constexpr void swap(propagate_const& pt) noexcept(see below)
  87
  88     private:
  89       T t_; // exposition only
  90     };
  91
  92   } // namespace fundamentals_v2
  93   } // namespace experimental
  94
  95   // [propagate_const.hash], hash support
  96   template <class T> struct hash<experimental::propagate_const<T>>;
  97
  98   // [propagate_const.comparison_function_objects], comparison function objects
  99   template <class T> struct equal_to<experimental::propagate_const<T>>;
 100   template <class T> struct not_equal_to<experimental::propagate_const<T>>;
 101   template <class T> struct less<experimental::propagate_const<T>>;
 102   template <class T> struct greater<experimental::propagate_const<T>>;
 103   template <class T> struct less_equal<experimental::propagate_const<T>>;
 104   template <class T> struct greater_equal<experimental::propagate_const<T>>;
 105
 106 } // namespace std
 107
 108 */
 109
 110 #include <__config>
 111 #include <__cstddef/nullptr_t.h>
 112 #include <__cstddef/size_t.h>
 113 #include <__functional/operations.h>
 114 #include <__fwd/functional.h>
 115 #include <__type_traits/conditional.h>
 116 #include <__type_traits/decay.h>
 117 #include <__type_traits/enable_if.h>
 118 #include <__type_traits/is_array.h>
 119 #include <__type_traits/is_constructible.h>
 120 #include <__type_traits/is_convertible.h>
 121 #include <__type_traits/is_function.h>
 122 #include <__type_traits/is_pointer.h>
 123 #include <__type_traits/is_reference.h>
 124 #include <__type_traits/is_same.h>
 125 #include <__type_traits/is_swappable.h>
 126 #include <__type_traits/remove_cv.h>
 127 #include <__type_traits/remove_pointer.h>
 128 #include <__type_traits/remove_reference.h>
 129 #include <__utility/declval.h>
 130 #include <__utility/forward.h>
 131 #include <__utility/move.h>
 132 #include <__utility/swap.h>
 133 #include <version>
 134
 135 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 136 #  pragma GCC system_header
 137 #endif
 138
 139 _LIBCPP_PUSH_MACROS
 140 #include <__undef_macros>
 141
 142 #if _LIBCPP_STD_VER >= 14
 143
 144 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2
 145
 146 template <class _Tp>
 147 class propagate_const;
 148
 149 template <class _Up>
 150 inline _LIBCPP_HIDE_FROM_ABI constexpr const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
 151
 152 template <class _Up>
 153 inline _LIBCPP_HIDE_FROM_ABI constexpr _Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
 154
 155 template <class _Tp>
 156 class propagate_const {
 157 public:
 158   typedef remove_reference_t<decltype(*std::declval<_Tp&>())> element_type;
 159
 160   static_assert(!is_array<_Tp>::value, "Instantiation of propagate_const with an array type is ill-formed.");
 161   static_assert(!is_reference<_Tp>::value, "Instantiation of propagate_const with a reference type is ill-formed.");
 162   static_assert(!(is_pointer<_Tp>::value && is_function<__remove_pointer_t<_Tp> >::value),
 163                 "Instantiation of propagate_const with a function-pointer type is ill-formed.");
 164   static_assert(!(is_pointer<_Tp>::value && is_same<__remove_cv_t<__remove_pointer_t<_Tp> >, void>::value),
 165                 "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");
 166
 167 private:
 168   template <class _Up>
 169   static _LIBCPP_HIDE_FROM_ABI constexpr element_type* __get_pointer(_Up* __u) {
 170     return __u;
 171   }
 172
 173   template <class _Up>
 174   static _LIBCPP_HIDE_FROM_ABI constexpr element_type* __get_pointer(_Up& __u) {
 175     return __get_pointer(__u.get());
 176   }
 177
 178   template <class _Up>
 179   static _LIBCPP_HIDE_FROM_ABI constexpr const element_type* __get_pointer(const _Up* __u) {
 180     return __u;
 181   }
 182
 183   template <class _Up>
 184   static _LIBCPP_HIDE_FROM_ABI constexpr const element_type* __get_pointer(const _Up& __u) {
 185     return __get_pointer(__u.get());
 186   }
 187
 188   template <class _Up>
 189   struct __is_propagate_const : false_type {};
 190
 191   template <class _Up>
 192   struct __is_propagate_const<propagate_const<_Up>> : true_type {};
 193
 194   _Tp __t_;
 195
 196 public:
 197   template <class _Up>
 198   friend constexpr const _Up& experimental::fundamentals_v2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
 199   template <class _Up>
 200   friend constexpr _Up& experimental::fundamentals_v2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
 201
 202   _LIBCPP_HIDE_FROM_ABI constexpr propagate_const() = default;
 203
 204   propagate_const(const propagate_const&) = delete;
 205
 206   _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(propagate_const&&) = default;
 207
 208   template <class _Up,
 209             enable_if_t<!is_convertible<_Up, _Tp>::value && is_constructible<_Tp, _Up&&>::value, bool> = true>
 210   explicit _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(propagate_const<_Up>&& __pu)
 211       : __t_(std::move(experimental::get_underlying(__pu))) {}
 212
 213   template <class _Up,
 214             enable_if_t<is_convertible<_Up&&, _Tp>::value && is_constructible<_Tp, _Up&&>::value, bool> = false>
 215   _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(propagate_const<_Up>&& __pu)
 216       : __t_(std::move(experimental::get_underlying(__pu))) {}
 217
 218   template <class _Up,
 219             enable_if_t<!is_convertible<_Up&&, _Tp>::value && is_constructible<_Tp, _Up&&>::value &&
 220                             !__is_propagate_const<decay_t<_Up>>::value,
 221                         bool> = true>
 222   explicit _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(_Up&& __u) : __t_(std::forward<_Up>(__u)) {}
 223
 224   template <class _Up,
 225             enable_if_t<is_convertible<_Up&&, _Tp>::value && is_constructible<_Tp, _Up&&>::value &&
 226                             !__is_propagate_const<decay_t<_Up>>::value,
 227                         bool> = false>
 228   _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(_Up&& __u) : __t_(std::forward<_Up>(__u)) {}
 229
 230   propagate_const& operator=(const propagate_const&) = delete;
 231
 232   _LIBCPP_HIDE_FROM_ABI constexpr propagate_const& operator=(propagate_const&&) = default;
 233
 234   template <class _Up>
 235   _LIBCPP_HIDE_FROM_ABI constexpr propagate_const& operator=(propagate_const<_Up>&& __pu) {
 236     __t_ = std::move(experimental::get_underlying(__pu));
 237     return *this;
 238   }
 239
 240   template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>>
 241   _LIBCPP_HIDE_FROM_ABI constexpr propagate_const& operator=(_Up&& __u) {
 242     __t_ = std::forward<_Up>(__u);
 243     return *this;
 244   }
 245
 246   _LIBCPP_HIDE_FROM_ABI constexpr const element_type* get() const { return __get_pointer(__t_); }
 247
 248   _LIBCPP_HIDE_FROM_ABI constexpr element_type* get() { return __get_pointer(__t_); }
 249
 250   _LIBCPP_HIDE_FROM_ABI explicit constexpr operator bool() const { return get() != nullptr; }
 251
 252   _LIBCPP_HIDE_FROM_ABI constexpr const element_type* operator->() const { return get(); }
 253
 254   template <class _Dummy = _Tp, class _Up = enable_if_t<is_convertible< const _Dummy, const element_type*>::value>>
 255   _LIBCPP_HIDE_FROM_ABI constexpr operator const element_type*() const {
 256     return get();
 257   }
 258
 259   _LIBCPP_HIDE_FROM_ABI constexpr const element_type& operator*() const { return *get(); }
 260
 261   _LIBCPP_HIDE_FROM_ABI constexpr element_type* operator->() { return get(); }
 262
 263   template <class _Dummy = _Tp, class _Up = enable_if_t< is_convertible<_Dummy, element_type*>::value>>
 264   _LIBCPP_HIDE_FROM_ABI constexpr operator element_type*() {
 265     return get();
 266   }
 267
 268   _LIBCPP_HIDE_FROM_ABI constexpr element_type& operator*() { return *get(); }
 269
 270   _LIBCPP_HIDE_FROM_ABI constexpr void swap(propagate_const& __pt) noexcept(__is_nothrow_swappable_v<_Tp>) {
 271     using std::swap;
 272     swap(__t_, __pt.__t_);
 273   }
 274 };
 275
 276 template <class _Tp>
 277 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const propagate_const<_Tp>& __pt, nullptr_t) {
 278   return experimental::get_underlying(__pt) == nullptr;
 279 }
 280
 281 template <class _Tp>
 282 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(nullptr_t, const propagate_const<_Tp>& __pt) {
 283   return nullptr == experimental::get_underlying(__pt);
 284 }
 285
 286 template <class _Tp>
 287 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t) {
 288   return experimental::get_underlying(__pt) != nullptr;
 289 }
 290
 291 template <class _Tp>
 292 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt) {
 293   return nullptr != experimental::get_underlying(__pt);
 294 }
 295
 296 template <class _Tp, class _Up>
 297 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
 298   return experimental::get_underlying(__pt) == experimental::get_underlying(__pu);
 299 }
 300
 301 template <class _Tp, class _Up>
 302 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
 303   return experimental::get_underlying(__pt) != experimental::get_underlying(__pu);
 304 }
 305
 306 template <class _Tp, class _Up>
 307 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
 308   return experimental::get_underlying(__pt) < experimental::get_underlying(__pu);
 309 }
 310
 311 template <class _Tp, class _Up>
 312 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
 313   return experimental::get_underlying(__pt) > experimental::get_underlying(__pu);
 314 }
 315
 316 template <class _Tp, class _Up>
 317 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
 318   return experimental::get_underlying(__pt) <= experimental::get_underlying(__pu);
 319 }
 320
 321 template <class _Tp, class _Up>
 322 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
 323   return experimental::get_underlying(__pt) >= experimental::get_underlying(__pu);
 324 }
 325
 326 template <class _Tp, class _Up>
 327 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u) {
 328   return experimental::get_underlying(__pt) == __u;
 329 }
 330
 331 template <class _Tp, class _Up>
 332 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u) {
 333   return experimental::get_underlying(__pt) != __u;
 334 }
 335
 336 template <class _Tp, class _Up>
 337 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u) {
 338   return experimental::get_underlying(__pt) < __u;
 339 }
 340
 341 template <class _Tp, class _Up>
 342 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u) {
 343   return experimental::get_underlying(__pt) > __u;
 344 }
 345
 346 template <class _Tp, class _Up>
 347 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u) {
 348   return experimental::get_underlying(__pt) <= __u;
 349 }
 350
 351 template <class _Tp, class _Up>
 352 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u) {
 353   return experimental::get_underlying(__pt) >= __u;
 354 }
 355
 356 template <class _Tp, class _Up>
 357 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu) {
 358   return __t == experimental::get_underlying(__pu);
 359 }
 360
 361 template <class _Tp, class _Up>
 362 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu) {
 363   return __t != experimental::get_underlying(__pu);
 364 }
 365
 366 template <class _Tp, class _Up>
 367 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu) {
 368   return __t < experimental::get_underlying(__pu);
 369 }
 370
 371 template <class _Tp, class _Up>
 372 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu) {
 373   return __t > experimental::get_underlying(__pu);
 374 }
 375
 376 template <class _Tp, class _Up>
 377 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu) {
 378   return __t <= experimental::get_underlying(__pu);
 379 }
 380
 381 template <class _Tp, class _Up>
 382 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu) {
 383   return __t >= experimental::get_underlying(__pu);
 384 }
 385
 386 template <class _Tp>
 387 _LIBCPP_HIDE_FROM_ABI constexpr void
 388 swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) noexcept(__is_nothrow_swappable_v<_Tp>) {
 389   __pc1.swap(__pc2);
 390 }
 391
 392 template <class _Tp>
 393 constexpr const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT {
 394   return __pt.__t_;
 395 }
 396
 397 template <class _Tp>
 398 constexpr _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT {
 399   return __pt.__t_;
 400 }
 401
 402 _LIBCPP_END_NAMESPACE_LFTS_V2
 403
 404 _LIBCPP_BEGIN_NAMESPACE_STD
 405
 406 template <class _Tp>
 407 struct hash<experimental::propagate_const<_Tp>> {
 408   typedef size_t result_type;
 409   typedef experimental::propagate_const<_Tp> argument_type;
 410
 411   _LIBCPP_HIDE_FROM_ABI size_t operator()(const experimental::propagate_const<_Tp>& __pc1) const {
 412     return std::hash<_Tp>()(experimental::get_underlying(__pc1));
 413   }
 414 };
 415
 416 template <class _Tp>
 417 struct equal_to<experimental::propagate_const<_Tp>> {
 418   typedef experimental::propagate_const<_Tp> first_argument_type;
 419   typedef experimental::propagate_const<_Tp> second_argument_type;
 420
 421   _LIBCPP_HIDE_FROM_ABI bool
 422   operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
 423     return std::equal_to<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
 424   }
 425 };
 426
 427 template <class _Tp>
 428 struct not_equal_to<experimental::propagate_const<_Tp>> {
 429   typedef experimental::propagate_const<_Tp> first_argument_type;
 430   typedef experimental::propagate_const<_Tp> second_argument_type;
 431
 432   _LIBCPP_HIDE_FROM_ABI bool
 433   operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
 434     return std::not_equal_to<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
 435   }
 436 };
 437
 438 template <class _Tp>
 439 struct less<experimental::propagate_const<_Tp>> {
 440   typedef experimental::propagate_const<_Tp> first_argument_type;
 441   typedef experimental::propagate_const<_Tp> second_argument_type;
 442
 443   _LIBCPP_HIDE_FROM_ABI bool
 444   operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
 445     return std::less<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
 446   }
 447 };
 448
 449 template <class _Tp>
 450 struct greater<experimental::propagate_const<_Tp>> {
 451   typedef experimental::propagate_const<_Tp> first_argument_type;
 452   typedef experimental::propagate_const<_Tp> second_argument_type;
 453
 454   _LIBCPP_HIDE_FROM_ABI bool
 455   operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
 456     return std::greater<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
 457   }
 458 };
 459
 460 template <class _Tp>
 461 struct less_equal<experimental::propagate_const<_Tp>> {
 462   typedef experimental::propagate_const<_Tp> first_argument_type;
 463   typedef experimental::propagate_const<_Tp> second_argument_type;
 464
 465   _LIBCPP_HIDE_FROM_ABI bool
 466   operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
 467     return std::less_equal<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
 468   }
 469 };
 470
 471 template <class _Tp>
 472 struct greater_equal<experimental::propagate_const<_Tp>> {
 473   typedef experimental::propagate_const<_Tp> first_argument_type;
 474   typedef experimental::propagate_const<_Tp> second_argument_type;
 475
 476   _LIBCPP_HIDE_FROM_ABI bool
 477   operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
 478     return std::greater_equal<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
 479   }
 480 };
 481
 482 _LIBCPP_END_NAMESPACE_STD
 483
 484 #endif // _LIBCPP_STD_VER >= 14
 485
 486 _LIBCPP_POP_MACROS
 487
 488 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 489 #  include <cstddef>
 490 #  include <type_traits>
 491 #endif
 492
 493 #endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST