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