Warning, /include/c++/v1/__cxx03/experimental/propagate_const is written in an unsupported language. File is not indexed.
0001 // -*- C++ -*-
0002 //===----------------------------------------------------------------------===//
0003 //
0004 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0005 // See https://llvm.org/LICENSE.txt for license information.
0006 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0007 //
0008 //===----------------------------------------------------------------------===//
0009
0010 #ifndef _LIBCPP___CXX03_EXPERIMENTAL_PROPAGATE_CONST
0011 #define _LIBCPP___CXX03_EXPERIMENTAL_PROPAGATE_CONST
0012
0013 /*
0014 propagate_const synopsis
0015
0016 namespace std { namespace experimental { inline namespace fundamentals_v2 {
0017
0018 // [propagate_const]
0019 template <class T> class propagate_const;
0020
0021 // [propagate_const.underlying], underlying pointer access
0022 constexpr const _Tp& get_underlying(const propagate_const<T>& pt) noexcept;
0023 constexpr T& get_underlying(propagate_const<T>& pt) noexcept;
0024
0025 // [propagate_const.relational], relational operators
0026 template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
0027 template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu);
0028 template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t);
0029 template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu);
0030 template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
0031 template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
0032 template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
0033 template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
0034 template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
0035 template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
0036 template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u);
0037 template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u);
0038 template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u);
0039 template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u);
0040 template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u);
0041 template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u);
0042 template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu);
0043 template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu);
0044 template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu);
0045 template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu);
0046 template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu);
0047 template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu);
0048
0049 // [propagate_const.algorithms], specialized algorithms
0050 template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below);
0051
0052 template <class T>
0053 class propagate_const
0054 {
0055
0056 public:
0057 typedef remove_reference_t<decltype(*declval<T&>())> element_type;
0058
0059 // [propagate_const.ctor], constructors
0060 constexpr propagate_const() = default;
0061 propagate_const(const propagate_const& p) = delete;
0062 constexpr propagate_const(propagate_const&& p) = default;
0063 template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below
0064 template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below
0065
0066 // [propagate_const.assignment], assignment
0067 propagate_const& operator=(const propagate_const& p) = delete;
0068 constexpr propagate_const& operator=(propagate_const&& p) = default;
0069 template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
0070 template <class U> constexpr propagate_const& operator=(U&& u); // see below
0071
0072 // [propagate_const.const_observers], const observers
0073 explicit constexpr operator bool() const;
0074 constexpr const element_type* operator->() const;
0075 constexpr operator const element_type*() const; // Not always defined
0076 constexpr const element_type& operator*() const;
0077 constexpr const element_type* get() const;
0078
0079 // [propagate_const.non_const_observers], non-const observers
0080 constexpr element_type* operator->();
0081 constexpr operator element_type*(); // Not always defined
0082 constexpr element_type& operator*();
0083 constexpr element_type* get();
0084
0085 // [propagate_const.modifiers], modifiers
0086 constexpr void swap(propagate_const& pt) noexcept(see below)
0087
0088 private:
0089 T t_; // exposition only
0090 };
0091
0092 } // namespace fundamentals_v2
0093 } // namespace experimental
0094
0095 // [propagate_const.hash], hash support
0096 template <class T> struct hash<experimental::propagate_const<T>>;
0097
0098 // [propagate_const.comparison_function_objects], comparison function objects
0099 template <class T> struct equal_to<experimental::propagate_const<T>>;
0100 template <class T> struct not_equal_to<experimental::propagate_const<T>>;
0101 template <class T> struct less<experimental::propagate_const<T>>;
0102 template <class T> struct greater<experimental::propagate_const<T>>;
0103 template <class T> struct less_equal<experimental::propagate_const<T>>;
0104 template <class T> struct greater_equal<experimental::propagate_const<T>>;
0105
0106 } // namespace std
0107
0108 */
0109
0110 #include <__cxx03/__functional/operations.h>
0111 #include <__cxx03/__fwd/functional.h>
0112 #include <__cxx03/__type_traits/conditional.h>
0113 #include <__cxx03/__type_traits/decay.h>
0114 #include <__cxx03/__type_traits/enable_if.h>
0115 #include <__cxx03/__type_traits/is_array.h>
0116 #include <__cxx03/__type_traits/is_constructible.h>
0117 #include <__cxx03/__type_traits/is_convertible.h>
0118 #include <__cxx03/__type_traits/is_function.h>
0119 #include <__cxx03/__type_traits/is_pointer.h>
0120 #include <__cxx03/__type_traits/is_reference.h>
0121 #include <__cxx03/__type_traits/is_same.h>
0122 #include <__cxx03/__type_traits/is_swappable.h>
0123 #include <__cxx03/__type_traits/remove_cv.h>
0124 #include <__cxx03/__type_traits/remove_pointer.h>
0125 #include <__cxx03/__type_traits/remove_reference.h>
0126 #include <__cxx03/__utility/declval.h>
0127 #include <__cxx03/__utility/forward.h>
0128 #include <__cxx03/__utility/move.h>
0129 #include <__cxx03/__utility/swap.h>
0130 #include <__cxx03/cstddef>
0131 #include <__cxx03/experimental/__config>
0132
0133 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
0134 # pragma GCC system_header
0135 #endif
0136
0137 _LIBCPP_PUSH_MACROS
0138 #include <__cxx03/__undef_macros>
0139
0140 #if _LIBCPP_STD_VER >= 14
0141
0142 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2
0143
0144 template <class _Tp>
0145 class propagate_const;
0146
0147 template <class _Up>
0148 inline _LIBCPP_HIDE_FROM_ABI constexpr const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
0149
0150 template <class _Up>
0151 inline _LIBCPP_HIDE_FROM_ABI constexpr _Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
0152
0153 template <class _Tp>
0154 class propagate_const {
0155 public:
0156 typedef remove_reference_t<decltype(*std::declval<_Tp&>())> element_type;
0157
0158 static_assert(!is_array<_Tp>::value, "Instantiation of propagate_const with an array type is ill-formed.");
0159 static_assert(!is_reference<_Tp>::value, "Instantiation of propagate_const with a reference type is ill-formed.");
0160 static_assert(!(is_pointer<_Tp>::value && is_function<__remove_pointer_t<_Tp> >::value),
0161 "Instantiation of propagate_const with a function-pointer type is ill-formed.");
0162 static_assert(!(is_pointer<_Tp>::value && is_same<__remove_cv_t<__remove_pointer_t<_Tp> >, void>::value),
0163 "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");
0164
0165 private:
0166 template <class _Up>
0167 static _LIBCPP_HIDE_FROM_ABI constexpr element_type* __get_pointer(_Up* __u) {
0168 return __u;
0169 }
0170
0171 template <class _Up>
0172 static _LIBCPP_HIDE_FROM_ABI constexpr element_type* __get_pointer(_Up& __u) {
0173 return __get_pointer(__u.get());
0174 }
0175
0176 template <class _Up>
0177 static _LIBCPP_HIDE_FROM_ABI constexpr const element_type* __get_pointer(const _Up* __u) {
0178 return __u;
0179 }
0180
0181 template <class _Up>
0182 static _LIBCPP_HIDE_FROM_ABI constexpr const element_type* __get_pointer(const _Up& __u) {
0183 return __get_pointer(__u.get());
0184 }
0185
0186 template <class _Up>
0187 struct __is_propagate_const : false_type {};
0188
0189 template <class _Up>
0190 struct __is_propagate_const<propagate_const<_Up>> : true_type {};
0191
0192 _Tp __t_;
0193
0194 public:
0195 template <class _Up>
0196 friend constexpr const _Up& experimental::fundamentals_v2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
0197 template <class _Up>
0198 friend constexpr _Up& experimental::fundamentals_v2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
0199
0200 _LIBCPP_HIDE_FROM_ABI constexpr propagate_const() = default;
0201
0202 propagate_const(const propagate_const&) = delete;
0203
0204 _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(propagate_const&&) = default;
0205
0206 template <class _Up,
0207 enable_if_t<!is_convertible<_Up, _Tp>::value && is_constructible<_Tp, _Up&&>::value, bool> = true>
0208 explicit _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(propagate_const<_Up>&& __pu)
0209 : __t_(std::move(experimental::get_underlying(__pu))) {}
0210
0211 template <class _Up,
0212 enable_if_t<is_convertible<_Up&&, _Tp>::value && is_constructible<_Tp, _Up&&>::value, bool> = false>
0213 _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(propagate_const<_Up>&& __pu)
0214 : __t_(std::move(experimental::get_underlying(__pu))) {}
0215
0216 template <class _Up,
0217 enable_if_t<!is_convertible<_Up&&, _Tp>::value && is_constructible<_Tp, _Up&&>::value &&
0218 !__is_propagate_const<decay_t<_Up>>::value,
0219 bool> = true>
0220 explicit _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(_Up&& __u) : __t_(std::forward<_Up>(__u)) {}
0221
0222 template <class _Up,
0223 enable_if_t<is_convertible<_Up&&, _Tp>::value && is_constructible<_Tp, _Up&&>::value &&
0224 !__is_propagate_const<decay_t<_Up>>::value,
0225 bool> = false>
0226 _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(_Up&& __u) : __t_(std::forward<_Up>(__u)) {}
0227
0228 propagate_const& operator=(const propagate_const&) = delete;
0229
0230 _LIBCPP_HIDE_FROM_ABI constexpr propagate_const& operator=(propagate_const&&) = default;
0231
0232 template <class _Up>
0233 _LIBCPP_HIDE_FROM_ABI constexpr propagate_const& operator=(propagate_const<_Up>&& __pu) {
0234 __t_ = std::move(experimental::get_underlying(__pu));
0235 return *this;
0236 }
0237
0238 template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>>
0239 _LIBCPP_HIDE_FROM_ABI constexpr propagate_const& operator=(_Up&& __u) {
0240 __t_ = std::forward<_Up>(__u);
0241 return *this;
0242 }
0243
0244 _LIBCPP_HIDE_FROM_ABI constexpr const element_type* get() const { return __get_pointer(__t_); }
0245
0246 _LIBCPP_HIDE_FROM_ABI constexpr element_type* get() { return __get_pointer(__t_); }
0247
0248 _LIBCPP_HIDE_FROM_ABI explicit constexpr operator bool() const { return get() != nullptr; }
0249
0250 _LIBCPP_HIDE_FROM_ABI constexpr const element_type* operator->() const { return get(); }
0251
0252 template <class _Dummy = _Tp, class _Up = enable_if_t<is_convertible< const _Dummy, const element_type*>::value>>
0253 _LIBCPP_HIDE_FROM_ABI constexpr operator const element_type*() const {
0254 return get();
0255 }
0256
0257 _LIBCPP_HIDE_FROM_ABI constexpr const element_type& operator*() const { return *get(); }
0258
0259 _LIBCPP_HIDE_FROM_ABI constexpr element_type* operator->() { return get(); }
0260
0261 template <class _Dummy = _Tp, class _Up = enable_if_t< is_convertible<_Dummy, element_type*>::value>>
0262 _LIBCPP_HIDE_FROM_ABI constexpr operator element_type*() {
0263 return get();
0264 }
0265
0266 _LIBCPP_HIDE_FROM_ABI constexpr element_type& operator*() { return *get(); }
0267
0268 _LIBCPP_HIDE_FROM_ABI constexpr void swap(propagate_const& __pt) noexcept(__is_nothrow_swappable_v<_Tp>) {
0269 using std::swap;
0270 swap(__t_, __pt.__t_);
0271 }
0272 };
0273
0274 template <class _Tp>
0275 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const propagate_const<_Tp>& __pt, nullptr_t) {
0276 return experimental::get_underlying(__pt) == nullptr;
0277 }
0278
0279 template <class _Tp>
0280 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(nullptr_t, const propagate_const<_Tp>& __pt) {
0281 return nullptr == experimental::get_underlying(__pt);
0282 }
0283
0284 template <class _Tp>
0285 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t) {
0286 return experimental::get_underlying(__pt) != nullptr;
0287 }
0288
0289 template <class _Tp>
0290 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt) {
0291 return nullptr != experimental::get_underlying(__pt);
0292 }
0293
0294 template <class _Tp, class _Up>
0295 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
0296 return experimental::get_underlying(__pt) == experimental::get_underlying(__pu);
0297 }
0298
0299 template <class _Tp, class _Up>
0300 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
0301 return experimental::get_underlying(__pt) != experimental::get_underlying(__pu);
0302 }
0303
0304 template <class _Tp, class _Up>
0305 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
0306 return experimental::get_underlying(__pt) < experimental::get_underlying(__pu);
0307 }
0308
0309 template <class _Tp, class _Up>
0310 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
0311 return experimental::get_underlying(__pt) > experimental::get_underlying(__pu);
0312 }
0313
0314 template <class _Tp, class _Up>
0315 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
0316 return experimental::get_underlying(__pt) <= experimental::get_underlying(__pu);
0317 }
0318
0319 template <class _Tp, class _Up>
0320 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
0321 return experimental::get_underlying(__pt) >= experimental::get_underlying(__pu);
0322 }
0323
0324 template <class _Tp, class _Up>
0325 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u) {
0326 return experimental::get_underlying(__pt) == __u;
0327 }
0328
0329 template <class _Tp, class _Up>
0330 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u) {
0331 return experimental::get_underlying(__pt) != __u;
0332 }
0333
0334 template <class _Tp, class _Up>
0335 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u) {
0336 return experimental::get_underlying(__pt) < __u;
0337 }
0338
0339 template <class _Tp, class _Up>
0340 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u) {
0341 return experimental::get_underlying(__pt) > __u;
0342 }
0343
0344 template <class _Tp, class _Up>
0345 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u) {
0346 return experimental::get_underlying(__pt) <= __u;
0347 }
0348
0349 template <class _Tp, class _Up>
0350 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u) {
0351 return experimental::get_underlying(__pt) >= __u;
0352 }
0353
0354 template <class _Tp, class _Up>
0355 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu) {
0356 return __t == experimental::get_underlying(__pu);
0357 }
0358
0359 template <class _Tp, class _Up>
0360 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu) {
0361 return __t != experimental::get_underlying(__pu);
0362 }
0363
0364 template <class _Tp, class _Up>
0365 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu) {
0366 return __t < experimental::get_underlying(__pu);
0367 }
0368
0369 template <class _Tp, class _Up>
0370 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu) {
0371 return __t > experimental::get_underlying(__pu);
0372 }
0373
0374 template <class _Tp, class _Up>
0375 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu) {
0376 return __t <= experimental::get_underlying(__pu);
0377 }
0378
0379 template <class _Tp, class _Up>
0380 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu) {
0381 return __t >= experimental::get_underlying(__pu);
0382 }
0383
0384 template <class _Tp>
0385 _LIBCPP_HIDE_FROM_ABI constexpr void
0386 swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) noexcept(__is_nothrow_swappable_v<_Tp>) {
0387 __pc1.swap(__pc2);
0388 }
0389
0390 template <class _Tp>
0391 constexpr const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT {
0392 return __pt.__t_;
0393 }
0394
0395 template <class _Tp>
0396 constexpr _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT {
0397 return __pt.__t_;
0398 }
0399
0400 _LIBCPP_END_NAMESPACE_LFTS_V2
0401
0402 _LIBCPP_BEGIN_NAMESPACE_STD
0403
0404 template <class _Tp>
0405 struct hash<experimental::propagate_const<_Tp>> {
0406 typedef size_t result_type;
0407 typedef experimental::propagate_const<_Tp> argument_type;
0408
0409 _LIBCPP_HIDE_FROM_ABI size_t operator()(const experimental::propagate_const<_Tp>& __pc1) const {
0410 return std::hash<_Tp>()(experimental::get_underlying(__pc1));
0411 }
0412 };
0413
0414 template <class _Tp>
0415 struct equal_to<experimental::propagate_const<_Tp>> {
0416 typedef experimental::propagate_const<_Tp> first_argument_type;
0417 typedef experimental::propagate_const<_Tp> second_argument_type;
0418
0419 _LIBCPP_HIDE_FROM_ABI bool
0420 operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
0421 return std::equal_to<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
0422 }
0423 };
0424
0425 template <class _Tp>
0426 struct not_equal_to<experimental::propagate_const<_Tp>> {
0427 typedef experimental::propagate_const<_Tp> first_argument_type;
0428 typedef experimental::propagate_const<_Tp> second_argument_type;
0429
0430 _LIBCPP_HIDE_FROM_ABI bool
0431 operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
0432 return std::not_equal_to<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
0433 }
0434 };
0435
0436 template <class _Tp>
0437 struct less<experimental::propagate_const<_Tp>> {
0438 typedef experimental::propagate_const<_Tp> first_argument_type;
0439 typedef experimental::propagate_const<_Tp> second_argument_type;
0440
0441 _LIBCPP_HIDE_FROM_ABI bool
0442 operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
0443 return std::less<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
0444 }
0445 };
0446
0447 template <class _Tp>
0448 struct greater<experimental::propagate_const<_Tp>> {
0449 typedef experimental::propagate_const<_Tp> first_argument_type;
0450 typedef experimental::propagate_const<_Tp> second_argument_type;
0451
0452 _LIBCPP_HIDE_FROM_ABI bool
0453 operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
0454 return std::greater<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
0455 }
0456 };
0457
0458 template <class _Tp>
0459 struct less_equal<experimental::propagate_const<_Tp>> {
0460 typedef experimental::propagate_const<_Tp> first_argument_type;
0461 typedef experimental::propagate_const<_Tp> second_argument_type;
0462
0463 _LIBCPP_HIDE_FROM_ABI bool
0464 operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
0465 return std::less_equal<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
0466 }
0467 };
0468
0469 template <class _Tp>
0470 struct greater_equal<experimental::propagate_const<_Tp>> {
0471 typedef experimental::propagate_const<_Tp> first_argument_type;
0472 typedef experimental::propagate_const<_Tp> second_argument_type;
0473
0474 _LIBCPP_HIDE_FROM_ABI bool
0475 operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
0476 return std::greater_equal<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
0477 }
0478 };
0479
0480 _LIBCPP_END_NAMESPACE_STD
0481
0482 #endif // _LIBCPP_STD_VER >= 14
0483
0484 _LIBCPP_POP_MACROS
0485
0486 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
0487 # include <__cxx03/type_traits>
0488 #endif
0489
0490 #endif // _LIBCPP___CXX03_EXPERIMENTAL_PROPAGATE_CONST
