Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/13/experimental/propagate_const
$ cat -n /usr/include/c++/13/experimental/propagate_const 1 // <experimental/propagate_const> -*- C++ -*- 2 3 // Copyright (C) 2015-2023 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file experimental/propagate_const 26 * This is a TS C++ Library header. 27 * @ingroup libfund-ts 28 */ 29 30 #ifndef _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST 31 #define _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST 1 32 33 #pragma GCC system_header 34 35 #include <bits/requires_hosted.h> // experimental is currently omitted 36 37 #if __cplusplus >= 201402L 38 39 #include <type_traits> 40 #include <bits/functional_hash.h> 41 #include <bits/move.h> 42 #include <bits/stl_function.h> 43 #include <experimental/bits/lfts_config.h> 44 45 namespace std _GLIBCXX_VISIBILITY(default) 46 { 47 _GLIBCXX_BEGIN_NAMESPACE_VERSION 48 49 namespace experimental 50 { 51 inline namespace fundamentals_v2 52 { 53 template<typename _Tp> 54 using __propagate_const_elem_type 55 = remove_reference_t<decltype(*std::declval<_Tp&>())>; 56 57 template<typename _Tp, 58 typename _Elem = __propagate_const_elem_type<_Tp>, 59 bool = is_convertible<const _Tp, const _Elem*>::value> 60 struct __propagate_const_conversion_c 61 { }; 62 63 template<typename _Tp, typename _Elem> 64 struct __propagate_const_conversion_c<_Tp, _Elem, true> 65 { 66 constexpr operator const _Elem*() const; 67 }; 68 69 template<typename _Tp, 70 typename _Elem = __propagate_const_elem_type<_Tp>, 71 bool = is_convertible<_Tp, _Elem*>::value> 72 struct __propagate_const_conversion_nc 73 { }; 74 75 template<typename _Tp, typename _Elem> 76 struct __propagate_const_conversion_nc<_Tp, _Elem, true> 77 { 78 constexpr operator _Elem*(); 79 }; 80 81 // Base class of propagate_const<T> when T is a class type. 82 template <typename _Tp> 83 struct __propagate_const_conversions 84 : __propagate_const_conversion_c<_Tp>, __propagate_const_conversion_nc<_Tp> 85 { }; 86 87 // Base class of propagate_const<T> when T is a pointer type. 88 template<typename _Tp> 89 struct __propagate_const_conversions<_Tp*> 90 { 91 constexpr operator const _Tp*() const noexcept; 92 constexpr operator _Tp*() noexcept; 93 }; 94 95 /** 96 * @defgroup propagate_const Const-propagating wrapper 97 * @ingroup libfund-ts 98 * 99 * A const-propagating wrapper that propagates const to pointer-like members, 100 * as described in n4388 "A Proposal to Add a Const-Propagating Wrapper 101 * to the Standard Library". 102 * 103 * @{ 104 */ 105 106 /// Const-propagating wrapper. 107 template <typename _Tp> 108 class propagate_const : public __propagate_const_conversions<_Tp> 109 { 110 public: 111 using element_type = __propagate_const_elem_type<_Tp>; 112 113 private: 114 template <typename _Up> 115 struct __is_propagate_const : false_type 116 { }; 117 118 template <typename _Up> 119 struct __is_propagate_const<propagate_const<_Up>> : true_type 120 { }; 121 122 template <typename _Up> 123 friend constexpr const _Up& 124 get_underlying(const propagate_const<_Up>& __pt) noexcept; 125 template <typename _Up> 126 friend constexpr _Up& 127 get_underlying(propagate_const<_Up>& __pt) noexcept; 128 129 template <typename _Up> 130 static constexpr element_type* 131 __to_raw_pointer(_Up* __u) 132 { return __u; } 133 134 template <typename _Up> 135 static constexpr element_type* 136 __to_raw_pointer(_Up& __u) 137 { return __u.get(); } 138 139 template <typename _Up> 140 static constexpr const element_type* 141 __to_raw_pointer(const _Up* __u) 142 { return __u; } 143 144 template <typename _Up> 145 static constexpr const element_type* 146 __to_raw_pointer(const _Up& __u) 147 { return __u.get(); } 148 149 public: 150 static_assert(__and_<is_object<typename remove_pointer<_Tp>::type>, 151 __not_<is_array<_Tp>>, 152 __or_<is_class<_Tp>, is_pointer<_Tp>>>::value, 153 "propagate_const requires a class or a pointer to an" 154 " object type"); 155 156 // [propagate_const.ctor], constructors 157 constexpr propagate_const() = default; 158 propagate_const(const propagate_const& __p) = delete; 159 constexpr propagate_const(propagate_const&& __p) = default; 160 161 template <typename _Up, typename 162 enable_if<__and_<is_constructible<_Tp, _Up&&>, 163 is_convertible<_Up&&, _Tp>>::value, bool 164 >::type=true> 165 constexpr propagate_const(propagate_const<_Up>&& __pu) 166 : _M_t(std::move(get_underlying(__pu))) 167 {} 168 169 template <typename _Up, typename 170 enable_if<__and_<is_constructible<_Tp, _Up&&>, 171 __not_<is_convertible<_Up&&, _Tp>>>::value, 172 bool>::type=false> 173 constexpr explicit propagate_const(propagate_const<_Up>&& __pu) 174 : _M_t(std::move(get_underlying(__pu))) 175 {} 176 177 template <typename _Up, typename 178 enable_if<__and_<is_constructible<_Tp, _Up&&>, 179 is_convertible<_Up&&, _Tp>, 180 __not_<__is_propagate_const< 181 typename decay<_Up>::type>> 182 >::value, bool>::type=true> 183 constexpr propagate_const(_Up&& __u) 184 : _M_t(std::forward<_Up>(__u)) 185 {} 186 187 template <typename _Up, typename 188 enable_if<__and_<is_constructible<_Tp, _Up&&>, 189 __not_<is_convertible<_Up&&, _Tp>>, 190 __not_<__is_propagate_const< 191 typename decay<_Up>::type>> 192 >::value, bool>::type=false> 193 constexpr explicit propagate_const(_Up&& __u) 194 : _M_t(std::forward<_Up>(__u)) 195 {} 196 197 // [propagate_const.assignment], assignment 198 propagate_const& operator=(const propagate_const& __p) = delete; 199 constexpr propagate_const& operator=(propagate_const&& __p) = default; 200 201 template <typename _Up, typename = 202 typename enable_if<is_convertible<_Up&&, _Tp>::value>::type> 203 constexpr propagate_const& operator=(propagate_const<_Up>&& __pu) 204 { 205 _M_t = std::move(get_underlying(__pu)); 206 return *this; 207 } 208 209 template <typename _Up, typename = 210 typename enable_if<__and_<is_convertible<_Up&&, _Tp>, 211 __not_<__is_propagate_const< 212 typename decay<_Up>::type>> 213 >::value>::type> 214 constexpr propagate_const& operator=(_Up&& __u) 215 { 216 _M_t = std::forward<_Up>(__u); 217 return *this; 218 } 219 220 // [propagate_const.const_observers], const observers 221 explicit constexpr operator bool() const 222 { 223 return bool(_M_t); 224 } 225 226 constexpr const element_type* operator->() const 227 { 228 return get(); 229 } 230 231 constexpr const element_type& operator*() const 232 { 233 return *get(); 234 } 235 236 constexpr const element_type* get() const 237 { 238 return __to_raw_pointer(_M_t); 239 } 240 241 // [propagate_const.non_const_observers], non-const observers 242 constexpr element_type* operator->() 243 { 244 return get(); 245 } 246 247 constexpr element_type& operator*() 248 { 249 return *get(); 250 } 251 252 constexpr element_type* get() 253 { 254 return __to_raw_pointer(_M_t); 255 } 256 257 // [propagate_const.modifiers], modifiers 258 constexpr void 259 swap(propagate_const& __pt) noexcept(__is_nothrow_swappable<_Tp>::value) 260 { 261 using std::swap; 262 swap(_M_t, get_underlying(__pt)); 263 } 264 265 private: 266 _Tp _M_t; 267 }; 268 269 // [propagate_const.relational], relational operators 270 template <typename _Tp> 271 constexpr bool 272 operator==(const propagate_const<_Tp>& __pt, nullptr_t) 273 { 274 return get_underlying(__pt) == nullptr; 275 } 276 277 template <typename _Tp> 278 constexpr bool 279 operator==(nullptr_t, const propagate_const<_Tp>& __pu) 280 { 281 return nullptr == get_underlying(__pu); 282 } 283 284 template <typename _Tp> 285 constexpr bool 286 operator!=(const propagate_const<_Tp>& __pt, nullptr_t) 287 { 288 return get_underlying(__pt) != nullptr; 289 } 290 291 template <typename _Tp> 292 constexpr bool operator!=(nullptr_t, const propagate_const<_Tp>& __pu) 293 { 294 return nullptr != get_underlying(__pu); 295 } 296 297 template <typename _Tp, typename _Up> 298 constexpr bool 299 operator==(const propagate_const<_Tp>& __pt, 300 const propagate_const<_Up>& __pu) 301 { 302 return get_underlying(__pt) == get_underlying(__pu); 303 } 304 305 template <typename _Tp, typename _Up> 306 constexpr bool 307 operator!=(const propagate_const<_Tp>& __pt, 308 const propagate_const<_Up>& __pu) 309 { 310 return get_underlying(__pt) != get_underlying(__pu); 311 } 312 313 template <typename _Tp, typename _Up> 314 constexpr bool 315 operator<(const propagate_const<_Tp>& __pt, 316 const propagate_const<_Up>& __pu) 317 { 318 return get_underlying(__pt) < get_underlying(__pu); 319 } 320 321 template <typename _Tp, typename _Up> 322 constexpr bool 323 operator>(const propagate_const<_Tp>& __pt, 324 const propagate_const<_Up>& __pu) 325 { 326 return get_underlying(__pt) > get_underlying(__pu); 327 } 328 329 template <typename _Tp, typename _Up> 330 constexpr bool 331 operator<=(const propagate_const<_Tp>& __pt, 332 const propagate_const<_Up>& __pu) 333 { 334 return get_underlying(__pt) <= get_underlying(__pu); 335 } 336 337 template <typename _Tp, typename _Up> 338 constexpr bool 339 operator>=(const propagate_const<_Tp>& __pt, 340 const propagate_const<_Up>& __pu) 341 { 342 return get_underlying(__pt) >= get_underlying(__pu); 343 } 344 345 template <typename _Tp, typename _Up> 346 constexpr bool 347 operator==(const propagate_const<_Tp>& __pt, const _Up& __u) 348 { 349 return get_underlying(__pt) == __u; 350 } 351 352 template <typename _Tp, typename _Up> 353 constexpr bool 354 operator!=(const propagate_const<_Tp>& __pt, const _Up& __u) 355 { 356 return get_underlying(__pt) != __u; 357 } 358 359 template <typename _Tp, typename _Up> 360 constexpr bool 361 operator<(const propagate_const<_Tp>& __pt, const _Up& __u) 362 { 363 return get_underlying(__pt) < __u; 364 } 365 366 template <typename _Tp, typename _Up> 367 constexpr bool 368 operator>(const propagate_const<_Tp>& __pt, const _Up& __u) 369 { 370 return get_underlying(__pt) > __u; 371 } 372 373 template <typename _Tp, typename _Up> 374 constexpr bool 375 operator<=(const propagate_const<_Tp>& __pt, const _Up& __u) 376 { 377 return get_underlying(__pt) <= __u; 378 } 379 380 template <typename _Tp, typename _Up> 381 constexpr bool 382 operator>=(const propagate_const<_Tp>& __pt, const _Up& __u) 383 { 384 return get_underlying(__pt) >= __u; 385 } 386 387 template <typename _Tp, typename _Up> 388 constexpr bool 389 operator==(const _Tp& __t, const propagate_const<_Up>& __pu) 390 { 391 return __t == get_underlying(__pu); 392 } 393 394 template <typename _Tp, typename _Up> 395 constexpr bool 396 operator!=(const _Tp& __t, const propagate_const<_Up>& __pu) 397 { 398 return __t != get_underlying(__pu); 399 } 400 401 template <typename _Tp, typename _Up> 402 constexpr bool 403 operator<(const _Tp& __t, const propagate_const<_Up>& __pu) 404 { 405 return __t < get_underlying(__pu); 406 } 407 408 template <typename _Tp, typename _Up> 409 constexpr bool 410 operator>(const _Tp& __t, const propagate_const<_Up>& __pu) 411 { 412 return __t > get_underlying(__pu); 413 } 414 415 template <typename _Tp, typename _Up> 416 constexpr bool 417 operator<=(const _Tp& __t, const propagate_const<_Up>& __pu) 418 { 419 return __t <= get_underlying(__pu); 420 } 421 422 template <typename _Tp, typename _Up> 423 constexpr bool 424 operator>=(const _Tp& __t, const propagate_const<_Up>& __pu) 425 { 426 return __t >= get_underlying(__pu); 427 } 428 429 // [propagate_const.algorithms], specialized algorithms 430 // _GLIBCXX_RESOLVE_LIB_DEFECTS 431 // 3413. propagate_const's swap [...] needs to be constrained and use a trait 432 template <typename _Tp> 433 constexpr enable_if_t<__is_swappable<_Tp>::value, void> 434 swap(propagate_const<_Tp>& __pt, propagate_const<_Tp>& __pt2) 435 noexcept(__is_nothrow_swappable<_Tp>::value) 436 { 437 __pt.swap(__pt2); 438 } 439 440 // [propagate_const.underlying], underlying pointer access 441 template <typename _Tp> 442 constexpr const _Tp& 443 get_underlying(const propagate_const<_Tp>& __pt) noexcept 444 { 445 return __pt._M_t; 446 } 447 448 template <typename _Tp> 449 constexpr _Tp& 450 get_underlying(propagate_const<_Tp>& __pt) noexcept 451 { 452 return __pt._M_t; 453 } 454 455 template<typename _Tp> 456 constexpr 457 __propagate_const_conversions<_Tp*>::operator const _Tp*() const noexcept 458 { return static_cast<const propagate_const<_Tp*>*>(this)->get(); } 459 460 template<typename _Tp> 461 constexpr 462 __propagate_const_conversions<_Tp*>::operator _Tp*() noexcept 463 { return static_cast<propagate_const<_Tp*>*>(this)->get(); } 464 465 template<typename _Tp, typename _Elem> 466 constexpr 467 __propagate_const_conversion_c<_Tp, _Elem, true>:: 468 operator const _Elem*() const 469 { return static_cast<const propagate_const<_Tp>*>(this)->get(); } 470 471 template<typename _Tp, typename _Elem> 472 constexpr 473 __propagate_const_conversion_nc<_Tp, _Elem, true>:: 474 operator _Elem*() 475 { return static_cast<propagate_const<_Tp>*>(this)->get(); } 476 477 /// @} group propagate_const 478 } // namespace fundamentals_v2 479 } // namespace experimental 480 481 // [propagate_const.hash], hash support 482 template <typename _Tp> 483 struct hash<experimental::propagate_const<_Tp>> 484 { 485 using result_type = size_t; 486 using argument_type = experimental::propagate_const<_Tp>; 487 488 size_t 489 operator()(const experimental::propagate_const<_Tp>& __t) const 490 noexcept(noexcept(hash<_Tp>{}(get_underlying(__t)))) 491 { 492 return hash<_Tp>{}(get_underlying(__t)); 493 } 494 }; 495 496 // [propagate_const.comparison_function_objects], comparison function objects 497 template <typename _Tp> 498 struct equal_to<experimental::propagate_const<_Tp>> 499 { 500 constexpr bool 501 operator()(const experimental::propagate_const<_Tp>& __x, 502 const experimental::propagate_const<_Tp>& __y) const 503 { 504 return equal_to<_Tp>{}(get_underlying(__x), get_underlying(__y)); 505 } 506 507 typedef experimental::propagate_const<_Tp> first_argument_type; 508 typedef experimental::propagate_const<_Tp> second_argument_type; 509 typedef bool result_type; 510 }; 511 512 template <typename _Tp> 513 struct not_equal_to<experimental::propagate_const<_Tp>> 514 { 515 constexpr bool 516 operator()(const experimental::propagate_const<_Tp>& __x, 517 const experimental::propagate_const<_Tp>& __y) const 518 { 519 return not_equal_to<_Tp>{}(get_underlying(__x), get_underlying(__y)); 520 } 521 522 typedef experimental::propagate_const<_Tp> first_argument_type; 523 typedef experimental::propagate_const<_Tp> second_argument_type; 524 typedef bool result_type; 525 }; 526 527 template <typename _Tp> 528 struct less<experimental::propagate_const<_Tp>> 529 { 530 constexpr bool 531 operator()(const experimental::propagate_const<_Tp>& __x, 532 const experimental::propagate_const<_Tp>& __y) const 533 { 534 return less<_Tp>{}(get_underlying(__x), get_underlying(__y)); 535 } 536 537 typedef experimental::propagate_const<_Tp> first_argument_type; 538 typedef experimental::propagate_const<_Tp> second_argument_type; 539 typedef bool result_type; 540 }; 541 542 template <typename _Tp> 543 struct greater<experimental::propagate_const<_Tp>> 544 { 545 constexpr bool 546 operator()(const experimental::propagate_const<_Tp>& __x, 547 const experimental::propagate_const<_Tp>& __y) const 548 { 549 return greater<_Tp>{}(get_underlying(__x), get_underlying(__y)); 550 } 551 552 typedef experimental::propagate_const<_Tp> first_argument_type; 553 typedef experimental::propagate_const<_Tp> second_argument_type; 554 typedef bool result_type; 555 }; 556 557 template <typename _Tp> 558 struct less_equal<experimental::propagate_const<_Tp>> 559 { 560 constexpr bool 561 operator()(const experimental::propagate_const<_Tp>& __x, 562 const experimental::propagate_const<_Tp>& __y) const 563 { 564 return less_equal<_Tp>{}(get_underlying(__x), get_underlying(__y)); 565 } 566 567 typedef experimental::propagate_const<_Tp> first_argument_type; 568 typedef experimental::propagate_const<_Tp> second_argument_type; 569 typedef bool result_type; 570 }; 571 572 template <typename _Tp> 573 struct greater_equal<experimental::propagate_const<_Tp>> 574 { 575 constexpr bool 576 operator()(const experimental::propagate_const<_Tp>& __x, 577 const experimental::propagate_const<_Tp>& __y) const 578 { 579 return greater_equal<_Tp>{}(get_underlying(__x), get_underlying(__y)); 580 } 581 582 typedef experimental::propagate_const<_Tp> first_argument_type; 583 typedef experimental::propagate_const<_Tp> second_argument_type; 584 typedef bool result_type; 585 }; 586 587 _GLIBCXX_END_NAMESPACE_VERSION 588 } // namespace std 589 590 #endif // C++14 591 592 #endif // _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
