include/experimental/propagate_const - third_party/libcxx - Git at Google

 // -*- C++ -*-
 //===------------------------ propagate_const -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #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)
 {
   __pc1.swap(__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
	// -- C++ --
	//===------------------------ propagate_const -----------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#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)
	{
	__pc1.swap(__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