// -*- C++ -*- //===----------------------------------------------------------------------===// // // 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 propagate_const; // [propagate_const.underlying], underlying pointer access constexpr const _Tp& get_underlying(const propagate_const& pt) noexcept; constexpr T& get_underlying(propagate_const& pt) noexcept; // [propagate_const.relational], relational operators template constexpr bool operator==(const propagate_const& pt, nullptr_t); template constexpr bool operator==(nullptr_t, const propagate_const& pu); template constexpr bool operator!=(const propagate_const& pt, nullptr_t); template constexpr bool operator!=(nullptr_t, const propagate_const& pu); template constexpr bool operator==(const propagate_const& pt, const propagate_const<_Up>& pu); template constexpr bool operator!=(const propagate_const& pt, const propagate_const<_Up>& pu); template constexpr bool operator<(const propagate_const& pt, const propagate_const<_Up>& pu); template constexpr bool operator>(const propagate_const& pt, const propagate_const<_Up>& pu); template constexpr bool operator<=(const propagate_const& pt, const propagate_const<_Up>& pu); template constexpr bool operator>=(const propagate_const& pt, const propagate_const<_Up>& pu); template constexpr bool operator==(const propagate_const& pt, const _Up& u); template constexpr bool operator!=(const propagate_const& pt, const _Up& u); template constexpr bool operator<(const propagate_const& pt, const _Up& u); template constexpr bool operator>(const propagate_const& pt, const _Up& u); template constexpr bool operator<=(const propagate_const& pt, const _Up& u); template constexpr bool operator>=(const propagate_const& pt, const _Up& u); template constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu); template constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu); template constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu); template constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu); template constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu); template constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu); // [propagate_const.algorithms], specialized algorithms template constexpr void swap(propagate_const& pt, propagate_const& pu) noexcept(see below); template class propagate_const { public: typedef remove_reference_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 EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below template 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 constexpr propagate_const& operator=(propagate_const<_Up>&& pu); template 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 struct hash>; // [propagate_const.comparison_function_objects], comparison function objects template struct equal_to>; template struct not_equal_to>; template struct less>; template struct greater>; template struct less_equal>; template struct greater_equal>; } // namespace std */ #include <__assert> // all public C++ headers provide the assertion handler #include <__functional/operations.h> #include <__fwd/hash.h> #include <__type_traits/conditional.h> #include <__type_traits/decay.h> #include <__type_traits/enable_if.h> #include <__type_traits/is_array.h> #include <__type_traits/is_constructible.h> #include <__type_traits/is_convertible.h> #include <__type_traits/is_function.h> #include <__type_traits/is_pointer.h> #include <__type_traits/is_reference.h> #include <__type_traits/is_same.h> #include <__type_traits/is_swappable.h> #include <__type_traits/remove_cv.h> #include <__type_traits/remove_pointer.h> #include <__type_traits/remove_reference.h> #include <__utility/declval.h> #include <__utility/forward.h> #include <__utility/move.h> #include <__utility/swap.h> #include #include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header #endif _LIBCPP_PUSH_MACROS #include <__undef_macros> #if _LIBCPP_STD_VER >= 14 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 template class propagate_const; template inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT; template inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT; template class propagate_const { public: typedef remove_reference_t())> 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<__remove_pointer_t<_Tp> >::value), "Instantiation of propagate_const with a function-pointer type is ill-formed."); static_assert(!(is_pointer<_Tp>::value && is_same<__remove_cv_t<__remove_pointer_t<_Tp> >, void>::value), "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed."); private: template static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u) { return __u; } template static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up& __u) { return __get_pointer(__u.get()); } template static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up* __u) { return __u; } template static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up& __u) { return __get_pointer(__u.get()); } template struct __is_propagate_const : false_type {}; template struct __is_propagate_const> : true_type {}; _Tp __t_; public: template friend _LIBCPP_CONSTEXPR const _Up& experimental::fundamentals_v2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT; template friend _LIBCPP_CONSTEXPR _Up& experimental::fundamentals_v2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const() = default; propagate_const(const propagate_const&) = delete; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const(propagate_const&&) = default; template ::value && is_constructible<_Tp, _Up&&>::value, bool> = true> explicit _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu) : __t_(std::move(experimental::get_underlying(__pu))) {} template ::value && is_constructible<_Tp, _Up&&>::value, bool> = false> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu) : __t_(std::move(experimental::get_underlying(__pu))) {} template ::value && is_constructible<_Tp, _Up&&>::value && !__is_propagate_const>::value, bool> = true> explicit _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const(_Up&& __u) : __t_(std::forward<_Up>(__u)) {} template ::value && is_constructible<_Tp, _Up&&>::value && !__is_propagate_const>::value, bool> = false> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const(_Up&& __u) : __t_(std::forward<_Up>(__u)) {} propagate_const& operator=(const propagate_const&) = delete; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) = default; template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu) { __t_ = std::move(experimental::get_underlying(__pu)); return *this; } template >::value>> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u) { __t_ = std::forward<_Up>(__u); return *this; } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type* get() const { return __get_pointer(__t_); } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type* get() { return __get_pointer(__t_); } _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR operator bool() const { return get() != nullptr; } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type* operator->() const { return get(); } template ::value>> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR operator const element_type*() const { return get(); } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type& operator*() const { return *get(); } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type* operator->() { return get(); } template ::value>> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR operator element_type*() { return get(); } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type& operator*() { return *get(); } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) { using std::swap; swap(__t_, __pt.__t_); } }; template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t) { return experimental::get_underlying(__pt) == nullptr; } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt) { return nullptr == experimental::get_underlying(__pt); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t) { return experimental::get_underlying(__pt) != nullptr; } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt) { return nullptr != experimental::get_underlying(__pt); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return experimental::get_underlying(__pt) == experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return experimental::get_underlying(__pt) != experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return experimental::get_underlying(__pt) < experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return experimental::get_underlying(__pt) > experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return experimental::get_underlying(__pt) <= experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return experimental::get_underlying(__pt) >= experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u) { return experimental::get_underlying(__pt) == __u; } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u) { return experimental::get_underlying(__pt) != __u; } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u) { return experimental::get_underlying(__pt) < __u; } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u) { return experimental::get_underlying(__pt) > __u; } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u) { return experimental::get_underlying(__pt) <= __u; } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u) { return experimental::get_underlying(__pt) >= __u; } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t == experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t != experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t < experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t > experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t <= experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t >= experimental::get_underlying(__pu); } template _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) { __pc1.swap(__pc2); } template _LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT { return __pt.__t_; } template _LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT { return __pt.__t_; } _LIBCPP_END_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_STD template struct hash> { typedef size_t result_type; typedef experimental::propagate_const<_Tp> argument_type; _LIBCPP_HIDE_FROM_ABI size_t operator()(const experimental::propagate_const<_Tp>& __pc1) const { return std::hash<_Tp>()(experimental::get_underlying(__pc1)); } }; template struct equal_to> { typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const { return std::equal_to<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2)); } }; template struct not_equal_to> { typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const { return std::not_equal_to<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2)); } }; template struct less> { typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const { return std::less<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2)); } }; template struct greater> { typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const { return std::greater<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2)); } }; template struct less_equal> { typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const { return std::less_equal<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2)); } }; template struct greater_equal> { typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const { return std::greater_equal<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2)); } }; _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_STD_VER >= 14 _LIBCPP_POP_MACROS #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 # include #endif #endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST