summaryrefslogtreecommitdiff
path: root/data/iphoneos-sdk/v1/experimental/propagate_const
diff options
context:
space:
mode:
authorMCApollo <34170230+MCApollo@users.noreply.github.com>2019-04-24 20:58:12 -0500
committerMCApollo <34170230+MCApollo@users.noreply.github.com>2019-04-24 20:58:12 -0500
commita12a0f8a5ab9cce38d815e83474656bf504d96dc (patch)
tree4ddff6b7a27819c46577b2a172961393677e34e6 /data/iphoneos-sdk/v1/experimental/propagate_const
parent70c8b04b525b7ed4af0689ebf2b2ad540c95ec11 (diff)
Proposed package to replace iphoneos-sys.
Diffstat (limited to 'data/iphoneos-sdk/v1/experimental/propagate_const')
-rwxr-xr-xdata/iphoneos-sdk/v1/experimental/propagate_const580
1 files changed, 580 insertions, 0 deletions
diff --git a/data/iphoneos-sdk/v1/experimental/propagate_const b/data/iphoneos-sdk/v1/experimental/propagate_const
new file mode 100755
index 000000000..e7f7e9fc6
--- /dev/null
+++ b/data/iphoneos-sdk/v1/experimental/propagate_const
@@ -0,0 +1,580 @@
+// -*- C++ -*-
+//===------------------------ propagate_const -----------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
+#define _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
+/*
+ propagate_const synopsis
+
+ namespace std { namespace experimental { inline namespace fundamentals_v2 {
+
+ // [propagate_const]
+ template <class T> class propagate_const;
+
+ // [propagate_const.underlying], underlying pointer access
+ constexpr const _Tp& _VSTD_LFTS_V2::get_underlying(const propagate_const<T>& pt) noexcept;
+ constexpr T& _VSTD_LFTS_V2::get_underlying(propagate_const<T>& pt) noexcept;
+
+ // [propagate_const.relational], relational operators
+ template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
+ template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu);
+ template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t);
+ template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu);
+ template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u);
+ template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u);
+ template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u);
+ template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u);
+ template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u);
+ template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u);
+ template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu);
+ template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu);
+
+ // [propagate_const.algorithms], specialized algorithms
+ template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below);
+
+ template <class T>
+ class propagate_const
+ {
+
+ public:
+ typedef remove_reference_t<decltype(*declval<T&>())> element_type;
+
+ // [propagate_const.ctor], constructors
+ constexpr propagate_const() = default;
+ propagate_const(const propagate_const& p) = delete;
+ constexpr propagate_const(propagate_const&& p) = default;
+ template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below
+ template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below
+
+ // [propagate_const.assignment], assignment
+ propagate_const& operator=(const propagate_const& p) = delete;
+ constexpr propagate_const& operator=(propagate_const&& p) = default;
+ template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
+ template <class U> constexpr propagate_const& operator=(U&& u); // see below
+
+ // [propagate_const.const_observers], const observers
+ explicit constexpr operator bool() const;
+ constexpr const element_type* operator->() const;
+ constexpr operator const element_type*() const; // Not always defined
+ constexpr const element_type& operator*() const;
+ constexpr const element_type* get() const;
+
+ // [propagate_const.non_const_observers], non-const observers
+ constexpr element_type* operator->();
+ constexpr operator element_type*(); // Not always defined
+ constexpr element_type& operator*();
+ constexpr element_type* get();
+
+ // [propagate_const.modifiers], modifiers
+ constexpr void swap(propagate_const& pt) noexcept(see below)
+
+ private:
+ T t_; // exposition only
+ };
+
+ } // namespace fundamentals_v2
+ } // namespace experimental
+
+ // [propagate_const.hash], hash support
+ template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
+
+ // [propagate_const.comparison_function_objects], comparison function objects
+ template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+ template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+ template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
+ template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
+ template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
+ template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
+
+} // namespace std
+
+*/
+
+#include <experimental/__config>
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 11
+
+#include <type_traits>
+#include <utility>
+#include <functional>
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_V2
+
+
+template <class _Tp>
+class propagate_const;
+
+template <class _Up>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
+
+template <class _Up>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+_Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
+
+template <class _Tp>
+class propagate_const
+{
+public:
+ typedef remove_reference_t<decltype(*_VSTD::declval<_Tp&>())> element_type;
+
+ static_assert(!is_array<_Tp>::value,
+ "Instantiation of propagate_const with an array type is ill-formed.");
+ static_assert(!is_reference<_Tp>::value,
+ "Instantiation of propagate_const with a reference type is ill-formed.");
+ static_assert(!(is_pointer<_Tp>::value && is_function<typename remove_pointer<_Tp>::type>::value),
+ "Instantiation of propagate_const with a function-pointer type is ill-formed.");
+ static_assert(!(is_pointer<_Tp>::value && is_same<typename remove_cv<typename remove_pointer<_Tp>::type>::type, void>::value),
+ "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");
+
+private:
+ template <class _Up>
+ static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u)
+ {
+ return __u;
+ }
+
+ template <class _Up>
+ static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up& __u)
+ {
+ return __get_pointer(__u.get());
+ }
+
+ template <class _Up>
+ static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up* __u)
+ {
+ return __u;
+ }
+
+ template <class _Up>
+ static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up& __u)
+ {
+ return __get_pointer(__u.get());
+ }
+
+ template <class _Up>
+ struct __is_propagate_const : false_type
+ {
+ };
+
+ template <class _Up>
+ struct __is_propagate_const<propagate_const<_Up>> : true_type
+ {
+ };
+
+ _Tp __t_;
+
+public:
+
+ template <class _Up> friend _LIBCPP_CONSTEXPR const _Up& ::_VSTD_LFTS_V2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
+ template <class _Up> friend _LIBCPP_CONSTEXPR _Up& ::_VSTD_LFTS_V2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
+
+ _LIBCPP_CONSTEXPR propagate_const() = default;
+
+ propagate_const(const propagate_const&) = delete;
+
+ _LIBCPP_CONSTEXPR propagate_const(propagate_const&&) = default;
+
+ template <class _Up, enable_if_t<!is_convertible<_Up, _Tp>::value &&
+ is_constructible<_Tp, _Up&&>::value,bool> = true>
+ explicit _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
+ : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
+ {
+ }
+
+ template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
+ is_constructible<_Tp, _Up&&>::value,bool> = false>
+ _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
+ : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
+ {
+ }
+
+ template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
+ is_constructible<_Tp, _Up&&>::value &&
+ !__is_propagate_const<decay_t<_Up>>::value,bool> = true>
+ explicit _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
+ : __t_(std::forward<_Up>(__u))
+ {
+ }
+
+ template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
+ is_constructible<_Tp, _Up&&>::value &&
+ !__is_propagate_const<decay_t<_Up>>::value,bool> = false>
+ _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
+ : __t_(std::forward<_Up>(__u))
+ {
+ }
+
+ propagate_const& operator=(const propagate_const&) = delete;
+
+ _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) = default;
+
+ template <class _Up>
+ _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu)
+ {
+ __t_ = std::move(_VSTD_LFTS_V2::get_underlying(__pu));
+ return *this;
+ }
+
+ template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>>
+ _LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u)
+ {
+ __t_ = std::forward<_Up>(__u);
+ return *this;
+ }
+
+ _LIBCPP_CONSTEXPR const element_type* get() const
+ {
+ return __get_pointer(__t_);
+ }
+
+ _LIBCPP_CONSTEXPR element_type* get()
+ {
+ return __get_pointer(__t_);
+ }
+
+ explicit _LIBCPP_CONSTEXPR operator bool() const
+ {
+ return get() != nullptr;
+ }
+
+ _LIBCPP_CONSTEXPR const element_type* operator->() const
+ {
+ return get();
+ }
+
+ template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible<
+ const _Tp_, const element_type *>::value>>
+ _LIBCPP_CONSTEXPR operator const element_type *() const {
+ return get();
+ }
+
+ _LIBCPP_CONSTEXPR const element_type& operator*() const
+ {
+ return *get();
+ }
+
+ _LIBCPP_CONSTEXPR element_type* operator->()
+ {
+ return get();
+ }
+
+ template <class _Tp_ = _Tp, class _Up = enable_if_t<
+ is_convertible<_Tp_, element_type *>::value>>
+ _LIBCPP_CONSTEXPR operator element_type *() {
+ return get();
+ }
+
+ _LIBCPP_CONSTEXPR element_type& operator*()
+ {
+ return *get();
+ }
+
+ _LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+ {
+ using _VSTD::swap;
+ swap(__t_, __pt.__t_);
+ }
+};
+
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) == nullptr;
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt)
+{
+ return nullptr == _VSTD_LFTS_V2::get_underlying(__pt);
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) != nullptr;
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt)
+{
+ return nullptr != _VSTD_LFTS_V2::get_underlying(__pt);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt,
+ const propagate_const<_Up>& __pu)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) == _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt,
+ const propagate_const<_Up>& __pu)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) != _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt,
+ const propagate_const<_Up>& __pu)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) < _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt,
+ const propagate_const<_Up>& __pu)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) > _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt,
+ const propagate_const<_Up>& __pu)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) <= _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt,
+ const propagate_const<_Up>& __pu)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) >= _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) == __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) != __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) < __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) > __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) <= __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+ return _VSTD_LFTS_V2::get_underlying(__pt) >= __u;
+}
+
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+ return __t == _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+ return __t != _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+ return __t < _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+ return __t > _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+ return __t <= _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+ return __t >= _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+{
+ using _VSTD::swap;
+ swap(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+}
+
+template <class _Tp>
+_LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT
+{
+ return __pt.__t_;
+}
+
+template <class _Tp>
+_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT
+{
+ return __pt.__t_;
+}
+
+_LIBCPP_END_NAMESPACE_LFTS_V2
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct hash<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+ typedef size_t result_type;
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type;
+
+ size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const
+ {
+ return std::hash<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1));
+ }
+};
+
+template <class _Tp>
+struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+ bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+ const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+ {
+ return std::equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+ }
+};
+
+template <class _Tp>
+struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+ bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+ const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+ {
+ return std::not_equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+ }
+};
+
+template <class _Tp>
+struct less<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+ bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+ const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+ {
+ return std::less<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+ }
+};
+
+template <class _Tp>
+struct greater<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+ bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+ const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+ {
+ return std::greater<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+ }
+};
+
+template <class _Tp>
+struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+ bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+ const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+ {
+ return std::less_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+ }
+};
+
+template <class _Tp>
+struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+ typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+ bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+ const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+ {
+ return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+ }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 11
+#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
+