1// -*- C++ -*-
2//===------------------------ propagate_const -----------------------------===//
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    propagate_const synopsis
14
15    namespace std { namespace experimental { inline namespace fundamentals_v2 {
16
17    // [propagate_const]
18    template <class T> class propagate_const;
19
20    // [propagate_const.underlying], underlying pointer access
21    constexpr const _Tp& _VSTD_LFTS_V2::get_underlying(const propagate_const<T>& pt) noexcept;
22    constexpr T& _VSTD_LFTS_V2::get_underlying(propagate_const<T>& pt) noexcept;
23
24    // [propagate_const.relational], relational operators
25    template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
26    template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu);
27    template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t);
28    template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu);
29    template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& 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 _Up& u);
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 _Tp& t, const propagate_const<_Up>& pu);
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
48    // [propagate_const.algorithms], specialized algorithms
49    template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below);
50
51    template <class T>
52    class propagate_const
53    {
54
55    public:
56      typedef remove_reference_t<decltype(*declval<T&>())> element_type;
57
58      // [propagate_const.ctor], constructors
59      constexpr propagate_const() = default;
60      propagate_const(const propagate_const& p) = delete;
61      constexpr propagate_const(propagate_const&& p) = default;
62      template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below
63      template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below
64
65      // [propagate_const.assignment], assignment
66      propagate_const& operator=(const propagate_const& p) = delete;
67      constexpr propagate_const& operator=(propagate_const&& p) = default;
68      template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
69      template <class U> constexpr propagate_const& operator=(U&& u); // see below
70
71      // [propagate_const.const_observers], const observers
72      explicit constexpr operator bool() const;
73      constexpr const element_type* operator->() const;
74      constexpr operator const element_type*() const; // Not always defined
75      constexpr const element_type& operator*() const;
76      constexpr const element_type* get() const;
77
78      // [propagate_const.non_const_observers], non-const observers
79      constexpr element_type* operator->();
80      constexpr operator element_type*(); // Not always defined
81      constexpr element_type& operator*();
82      constexpr element_type* get();
83
84      // [propagate_const.modifiers], modifiers
85      constexpr void swap(propagate_const& pt) noexcept(see below)
86
87    private:
88      T t_; // exposition only
89    };
90
91  } // namespace fundamentals_v2
92  } // namespace experimental
93
94  // [propagate_const.hash], hash support
95  template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
96
97  // [propagate_const.comparison_function_objects], comparison function objects
98  template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
99  template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
100  template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
101  template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
102  template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
103  template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
104
105} // namespace std
106
107*/
108
109#include <experimental/__config>
110#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
111#pragma GCC system_header
112#endif
113
114#if _LIBCPP_STD_VER > 11
115
116#include <type_traits>
117#include <utility>
118#include <functional>
119
120_LIBCPP_BEGIN_NAMESPACE_LFTS_V2
121
122
123template <class _Tp>
124class propagate_const;
125
126template <class _Up>
127inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
128const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
129
130template <class _Up>
131inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
132_Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
133
134template <class _Tp>
135class propagate_const
136{
137public:
138  typedef remove_reference_t<decltype(*_VSTD::declval<_Tp&>())> element_type;
139
140  static_assert(!is_array<_Tp>::value,
141      "Instantiation of propagate_const with an array type is ill-formed.");
142  static_assert(!is_reference<_Tp>::value,
143      "Instantiation of propagate_const with a reference type is ill-formed.");
144  static_assert(!(is_pointer<_Tp>::value && is_function<typename remove_pointer<_Tp>::type>::value),
145      "Instantiation of propagate_const with a function-pointer type is ill-formed.");
146  static_assert(!(is_pointer<_Tp>::value && is_same<typename remove_cv<typename remove_pointer<_Tp>::type>::type, void>::value),
147      "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");
148
149private:
150  template <class _Up>
151  static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u)
152  {
153    return __u;
154  }
155
156  template <class _Up>
157  static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up& __u)
158  {
159    return __get_pointer(__u.get());
160  }
161
162  template <class _Up>
163  static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up* __u)
164  {
165    return __u;
166  }
167
168  template <class _Up>
169  static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up& __u)
170  {
171    return __get_pointer(__u.get());
172  }
173
174  template <class _Up>
175  struct __is_propagate_const : false_type
176  {
177  };
178
179  template <class _Up>
180  struct __is_propagate_const<propagate_const<_Up>> : true_type
181  {
182  };
183
184  _Tp __t_;
185
186public:
187
188  template <class _Up> friend _LIBCPP_CONSTEXPR const _Up& ::_VSTD_LFTS_V2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
189  template <class _Up> friend _LIBCPP_CONSTEXPR _Up& ::_VSTD_LFTS_V2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
190
191  _LIBCPP_CONSTEXPR propagate_const() = default;
192
193  propagate_const(const propagate_const&) = delete;
194
195  _LIBCPP_CONSTEXPR propagate_const(propagate_const&&) = default;
196
197  template <class _Up, enable_if_t<!is_convertible<_Up, _Tp>::value &&
198                                 is_constructible<_Tp, _Up&&>::value,bool> = true>
199  explicit _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
200      : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
201  {
202  }
203
204  template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
205                                 is_constructible<_Tp, _Up&&>::value,bool> = false>
206  _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
207      : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
208  {
209  }
210
211  template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
212                                 is_constructible<_Tp, _Up&&>::value &&
213                                 !__is_propagate_const<decay_t<_Up>>::value,bool> = true>
214  explicit _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
215      : __t_(std::forward<_Up>(__u))
216  {
217  }
218
219  template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
220                                 is_constructible<_Tp, _Up&&>::value &&
221                                 !__is_propagate_const<decay_t<_Up>>::value,bool> = false>
222  _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
223      : __t_(std::forward<_Up>(__u))
224  {
225  }
226
227  propagate_const& operator=(const propagate_const&) = delete;
228
229  _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) = default;
230
231  template <class _Up>
232  _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu)
233  {
234    __t_ = std::move(_VSTD_LFTS_V2::get_underlying(__pu));
235    return *this;
236  }
237
238  template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>>
239  _LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u)
240  {
241    __t_ = std::forward<_Up>(__u);
242    return *this;
243  }
244
245  _LIBCPP_CONSTEXPR const element_type* get() const
246  {
247    return __get_pointer(__t_);
248  }
249
250  _LIBCPP_CONSTEXPR element_type* get()
251  {
252    return __get_pointer(__t_);
253  }
254
255  explicit _LIBCPP_CONSTEXPR operator bool() const
256  {
257    return get() != nullptr;
258  }
259
260  _LIBCPP_CONSTEXPR const element_type* operator->() const
261  {
262    return get();
263  }
264
265  template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible<
266                                  const _Tp_, const element_type *>::value>>
267  _LIBCPP_CONSTEXPR operator const element_type *() const {
268    return get();
269  }
270
271  _LIBCPP_CONSTEXPR const element_type& operator*() const
272  {
273    return *get();
274  }
275
276  _LIBCPP_CONSTEXPR element_type* operator->()
277  {
278    return get();
279  }
280
281  template <class _Tp_ = _Tp, class _Up = enable_if_t<
282                                  is_convertible<_Tp_, element_type *>::value>>
283  _LIBCPP_CONSTEXPR operator element_type *() {
284    return get();
285  }
286
287  _LIBCPP_CONSTEXPR element_type& operator*()
288  {
289    return *get();
290  }
291
292  _LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
293  {
294    using _VSTD::swap;
295    swap(__t_, __pt.__t_);
296  }
297};
298
299
300template <class _Tp>
301_LIBCPP_INLINE_VISIBILITY
302_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t)
303{
304  return _VSTD_LFTS_V2::get_underlying(__pt) == nullptr;
305}
306
307template <class _Tp>
308_LIBCPP_INLINE_VISIBILITY
309_LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt)
310{
311  return nullptr == _VSTD_LFTS_V2::get_underlying(__pt);
312}
313
314template <class _Tp>
315_LIBCPP_INLINE_VISIBILITY
316_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t)
317{
318  return _VSTD_LFTS_V2::get_underlying(__pt) != nullptr;
319}
320
321template <class _Tp>
322_LIBCPP_INLINE_VISIBILITY
323_LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt)
324{
325  return nullptr != _VSTD_LFTS_V2::get_underlying(__pt);
326}
327
328template <class _Tp, class _Up>
329_LIBCPP_INLINE_VISIBILITY
330_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt,
331                          const propagate_const<_Up>& __pu)
332{
333  return _VSTD_LFTS_V2::get_underlying(__pt) == _VSTD_LFTS_V2::get_underlying(__pu);
334}
335
336template <class _Tp, class _Up>
337_LIBCPP_INLINE_VISIBILITY
338_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt,
339                          const propagate_const<_Up>& __pu)
340{
341  return _VSTD_LFTS_V2::get_underlying(__pt) != _VSTD_LFTS_V2::get_underlying(__pu);
342}
343
344template <class _Tp, class _Up>
345_LIBCPP_INLINE_VISIBILITY
346_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt,
347                         const propagate_const<_Up>& __pu)
348{
349  return _VSTD_LFTS_V2::get_underlying(__pt) < _VSTD_LFTS_V2::get_underlying(__pu);
350}
351
352template <class _Tp, class _Up>
353_LIBCPP_INLINE_VISIBILITY
354_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt,
355                         const propagate_const<_Up>& __pu)
356{
357  return _VSTD_LFTS_V2::get_underlying(__pt) > _VSTD_LFTS_V2::get_underlying(__pu);
358}
359
360template <class _Tp, class _Up>
361_LIBCPP_INLINE_VISIBILITY
362_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt,
363                          const propagate_const<_Up>& __pu)
364{
365  return _VSTD_LFTS_V2::get_underlying(__pt) <= _VSTD_LFTS_V2::get_underlying(__pu);
366}
367
368template <class _Tp, class _Up>
369_LIBCPP_INLINE_VISIBILITY
370_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt,
371                          const propagate_const<_Up>& __pu)
372{
373  return _VSTD_LFTS_V2::get_underlying(__pt) >= _VSTD_LFTS_V2::get_underlying(__pu);
374}
375
376template <class _Tp, class _Up>
377_LIBCPP_INLINE_VISIBILITY
378_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u)
379{
380  return _VSTD_LFTS_V2::get_underlying(__pt) == __u;
381}
382
383template <class _Tp, class _Up>
384_LIBCPP_INLINE_VISIBILITY
385_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u)
386{
387  return _VSTD_LFTS_V2::get_underlying(__pt) != __u;
388}
389
390template <class _Tp, class _Up>
391_LIBCPP_INLINE_VISIBILITY
392_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u)
393{
394  return _VSTD_LFTS_V2::get_underlying(__pt) < __u;
395}
396
397template <class _Tp, class _Up>
398_LIBCPP_INLINE_VISIBILITY
399_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u)
400{
401  return _VSTD_LFTS_V2::get_underlying(__pt) > __u;
402}
403
404template <class _Tp, class _Up>
405_LIBCPP_INLINE_VISIBILITY
406_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u)
407{
408  return _VSTD_LFTS_V2::get_underlying(__pt) <= __u;
409}
410
411template <class _Tp, class _Up>
412_LIBCPP_INLINE_VISIBILITY
413_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u)
414{
415  return _VSTD_LFTS_V2::get_underlying(__pt) >= __u;
416}
417
418
419template <class _Tp, class _Up>
420_LIBCPP_INLINE_VISIBILITY
421_LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu)
422{
423  return __t == _VSTD_LFTS_V2::get_underlying(__pu);
424}
425
426template <class _Tp, class _Up>
427_LIBCPP_INLINE_VISIBILITY
428_LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu)
429{
430  return __t != _VSTD_LFTS_V2::get_underlying(__pu);
431}
432
433template <class _Tp, class _Up>
434_LIBCPP_INLINE_VISIBILITY
435_LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu)
436{
437  return __t < _VSTD_LFTS_V2::get_underlying(__pu);
438}
439
440template <class _Tp, class _Up>
441_LIBCPP_INLINE_VISIBILITY
442_LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu)
443{
444  return __t > _VSTD_LFTS_V2::get_underlying(__pu);
445}
446
447template <class _Tp, class _Up>
448_LIBCPP_INLINE_VISIBILITY
449_LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu)
450{
451  return __t <= _VSTD_LFTS_V2::get_underlying(__pu);
452}
453
454template <class _Tp, class _Up>
455_LIBCPP_INLINE_VISIBILITY
456_LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu)
457{
458  return __t >= _VSTD_LFTS_V2::get_underlying(__pu);
459}
460
461template <class _Tp>
462_LIBCPP_INLINE_VISIBILITY
463_LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
464{
465  __pc1.swap(__pc2);
466}
467
468template <class _Tp>
469_LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT
470{
471  return __pt.__t_;
472}
473
474template <class _Tp>
475_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT
476{
477  return __pt.__t_;
478}
479
480_LIBCPP_END_NAMESPACE_LFTS_V2
481
482_LIBCPP_BEGIN_NAMESPACE_STD
483
484template <class _Tp>
485struct hash<experimental::fundamentals_v2::propagate_const<_Tp>>
486{
487  typedef size_t result_type;
488  typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type;
489
490  size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const
491  {
492    return std::hash<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1));
493  }
494};
495
496template <class _Tp>
497struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
498{
499  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
500  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
501
502  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
503      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
504  {
505    return std::equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
506  }
507};
508
509template <class _Tp>
510struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
511{
512  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
513  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
514
515  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
516      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
517  {
518    return std::not_equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
519  }
520};
521
522template <class _Tp>
523struct less<experimental::fundamentals_v2::propagate_const<_Tp>>
524{
525  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
526  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
527
528  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
529      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
530  {
531    return std::less<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
532  }
533};
534
535template <class _Tp>
536struct greater<experimental::fundamentals_v2::propagate_const<_Tp>>
537{
538  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
539  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
540
541  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
542      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
543  {
544    return std::greater<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
545  }
546};
547
548template <class _Tp>
549struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
550{
551  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
552  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
553
554  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
555      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
556  {
557    return std::less_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
558  }
559};
560
561template <class _Tp>
562struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
563{
564  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
565  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
566
567  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
568      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
569  {
570    return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
571  }
572};
573
574_LIBCPP_END_NAMESPACE_STD
575
576#endif // _LIBCPP_STD_VER > 11
577#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
578