1 // <optional> -*- C++ -*- 2 3 // Copyright (C) 2013-2022 Free Software Foundation, Inc. 4 // Copyright The GNU Toolchain Authors. 5 // 6 // This file is part of the GNU ISO C++ Library. This library is free 7 // software; you can redistribute it and/or modify it under the 8 // terms of the GNU General Public License as published by the 9 // Free Software Foundation; either version 3, or (at your option) 10 // any later version. 11 12 // This library is distributed in the hope that it will be useful, 13 // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 // GNU General Public License for more details. 16 17 // Under Section 7 of GPL version 3, you are granted additional 18 // permissions described in the GCC Runtime Library Exception, version 19 // 3.1, as published by the Free Software Foundation. 20 21 // You should have received a copy of the GNU General Public License and 22 // a copy of the GCC Runtime Library Exception along with this program; 23 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 24 // <http://www.gnu.org/licenses/>. 25 26 /** @file include/optional 27 * This is a Standard C++ Library header. 28 */ 29 30 #ifndef _GLIBCXX_OPTIONAL 31 #define _GLIBCXX_OPTIONAL 1 32 33 #pragma GCC system_header 34 35 #if __cplusplus >= 201703L 36 37 #include <type_traits> 38 #include <exception> 39 #include <new> 40 #include <initializer_list> 41 #include <bits/enable_special_members.h> 42 #include <bits/exception_defines.h> 43 #include <bits/functional_hash.h> 44 #include <bits/stl_construct.h> // _Construct 45 #include <bits/utility.h> // in_place_t 46 #if __cplusplus > 201703L 47 # include <compare> 48 # include <bits/invoke.h> // std::__invoke 49 #endif 50 #if __cplusplus > 202002L 51 # include <concepts> 52 #endif 53 54 namespace std _GLIBCXX_VISIBILITY(default) 55 { 56 _GLIBCXX_BEGIN_NAMESPACE_VERSION 57 58 /** 59 * @addtogroup utilities 60 * @{ 61 */ 62 63 #if __cplusplus > 202002L && __cpp_lib_concepts 64 # define __cpp_lib_optional 202110L 65 #elif __cplusplus >= 202002L 66 # define __cpp_lib_optional 202106L 67 #else 68 # define __cpp_lib_optional 201606L 69 #endif 70 71 template<typename _Tp> 72 class optional; 73 74 /// Tag type to disengage optional objects. 75 struct nullopt_t 76 { 77 // Do not user-declare default constructor at all for 78 // optional_value = {} syntax to work. 79 // nullopt_t() = delete; 80 81 // Used for constructing nullopt. 82 enum class _Construct { _Token }; 83 84 // Must be constexpr for nullopt_t to be literal. 85 explicit constexpr nullopt_t(_Construct) noexcept { } 86 }; 87 88 /// Tag to disengage optional objects. 89 inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token }; 90 91 template<typename _Fn> struct _Optional_func { _Fn& _M_f; }; 92 93 /** 94 * @brief Exception class thrown when a disengaged optional object is 95 * dereferenced. 96 * @ingroup exceptions 97 */ 98 class bad_optional_access : public exception 99 { 100 public: 101 bad_optional_access() = default; 102 virtual ~bad_optional_access() = default; 103 104 const char* what() const noexcept override 105 { return "bad optional access"; } 106 }; 107 108 // XXX Does not belong here. 109 [[__noreturn__]] inline void 110 __throw_bad_optional_access() 111 { _GLIBCXX_THROW_OR_ABORT(bad_optional_access()); } 112 113 // This class template manages construction/destruction of 114 // the contained value for a std::optional. 115 template <typename _Tp> 116 struct _Optional_payload_base 117 { 118 using _Stored_type = remove_const_t<_Tp>; 119 120 _Optional_payload_base() = default; 121 ~_Optional_payload_base() = default; 122 123 template<typename... _Args> 124 constexpr 125 _Optional_payload_base(in_place_t __tag, _Args&&... __args) 126 : _M_payload(__tag, std::forward<_Args>(__args)...), 127 _M_engaged(true) 128 { } 129 130 template<typename _Up, typename... _Args> 131 constexpr 132 _Optional_payload_base(std::initializer_list<_Up> __il, 133 _Args&&... __args) 134 : _M_payload(__il, std::forward<_Args>(__args)...), 135 _M_engaged(true) 136 { } 137 138 // Constructor used by _Optional_base copy constructor when the 139 // contained value is not trivially copy constructible. 140 constexpr 141 _Optional_payload_base(bool __engaged, 142 const _Optional_payload_base& __other) 143 { 144 if (__other._M_engaged) 145 this->_M_construct(__other._M_get()); 146 } 147 148 // Constructor used by _Optional_base move constructor when the 149 // contained value is not trivially move constructible. 150 constexpr 151 _Optional_payload_base(bool __engaged, 152 _Optional_payload_base&& __other) 153 { 154 if (__other._M_engaged) 155 this->_M_construct(std::move(__other._M_get())); 156 } 157 158 // Copy constructor is only used to when the contained value is 159 // trivially copy constructible. 160 _Optional_payload_base(const _Optional_payload_base&) = default; 161 162 // Move constructor is only used to when the contained value is 163 // trivially copy constructible. 164 _Optional_payload_base(_Optional_payload_base&&) = default; 165 166 _Optional_payload_base& 167 operator=(const _Optional_payload_base&) = default; 168 169 _Optional_payload_base& 170 operator=(_Optional_payload_base&&) = default; 171 172 // used to perform non-trivial copy assignment. 173 constexpr void 174 _M_copy_assign(const _Optional_payload_base& __other) 175 { 176 if (this->_M_engaged && __other._M_engaged) 177 this->_M_get() = __other._M_get(); 178 else 179 { 180 if (__other._M_engaged) 181 this->_M_construct(__other._M_get()); 182 else 183 this->_M_reset(); 184 } 185 } 186 187 // used to perform non-trivial move assignment. 188 constexpr void 189 _M_move_assign(_Optional_payload_base&& __other) 190 noexcept(__and_v<is_nothrow_move_constructible<_Tp>, 191 is_nothrow_move_assignable<_Tp>>) 192 { 193 if (this->_M_engaged && __other._M_engaged) 194 this->_M_get() = std::move(__other._M_get()); 195 else 196 { 197 if (__other._M_engaged) 198 this->_M_construct(std::move(__other._M_get())); 199 else 200 this->_M_reset(); 201 } 202 } 203 204 struct _Empty_byte { }; 205 206 template<typename _Up, bool = is_trivially_destructible_v<_Up>> 207 union _Storage 208 { 209 constexpr _Storage() noexcept : _M_empty() { } 210 211 template<typename... _Args> 212 constexpr 213 _Storage(in_place_t, _Args&&... __args) 214 : _M_value(std::forward<_Args>(__args)...) 215 { } 216 217 template<typename _Vp, typename... _Args> 218 constexpr 219 _Storage(std::initializer_list<_Vp> __il, _Args&&... __args) 220 : _M_value(__il, std::forward<_Args>(__args)...) 221 { } 222 223 #if __cplusplus >= 202002L 224 template<typename _Fn, typename _Arg> 225 constexpr 226 _Storage(_Optional_func<_Fn> __f, _Arg&& __arg) 227 : _M_value(std::__invoke(std::forward<_Fn>(__f._M_f), 228 std::forward<_Arg>(__arg))) 229 { } 230 #endif 231 232 _Empty_byte _M_empty; 233 _Up _M_value; 234 }; 235 236 template<typename _Up> 237 union _Storage<_Up, false> 238 { 239 constexpr _Storage() noexcept : _M_empty() { } 240 241 template<typename... _Args> 242 constexpr 243 _Storage(in_place_t, _Args&&... __args) 244 : _M_value(std::forward<_Args>(__args)...) 245 { } 246 247 template<typename _Vp, typename... _Args> 248 constexpr 249 _Storage(std::initializer_list<_Vp> __il, _Args&&... __args) 250 : _M_value(__il, std::forward<_Args>(__args)...) 251 { } 252 253 #if __cplusplus >= 202002L 254 template<typename _Fn, typename _Arg> 255 constexpr 256 _Storage(_Optional_func<_Fn> __f, _Arg&& __arg) 257 : _M_value(std::__invoke(std::forward<_Fn>(__f._M_f), 258 std::forward<_Arg>(__arg))) 259 { } 260 #endif 261 262 // User-provided destructor is needed when _Up has non-trivial dtor. 263 _GLIBCXX20_CONSTEXPR ~_Storage() { } 264 265 _Empty_byte _M_empty; 266 _Up _M_value; 267 }; 268 269 _Storage<_Stored_type> _M_payload; 270 271 bool _M_engaged = false; 272 273 template<typename... _Args> 274 constexpr void 275 _M_construct(_Args&&... __args) 276 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>) 277 { 278 std::_Construct(std::__addressof(this->_M_payload._M_value), 279 std::forward<_Args>(__args)...); 280 this->_M_engaged = true; 281 } 282 283 constexpr void 284 _M_destroy() noexcept 285 { 286 _M_engaged = false; 287 _M_payload._M_value.~_Stored_type(); 288 } 289 290 #if __cplusplus >= 202002L 291 template<typename _Fn, typename _Up> 292 constexpr void 293 _M_apply(_Optional_func<_Fn> __f, _Up&& __x) 294 { 295 std::construct_at(std::__addressof(this->_M_payload), 296 __f, std::forward<_Up>(__x)); 297 _M_engaged = true; 298 } 299 #endif 300 301 // The _M_get() operations have _M_engaged as a precondition. 302 // They exist to access the contained value with the appropriate 303 // const-qualification, because _M_payload has had the const removed. 304 305 constexpr _Tp& 306 _M_get() noexcept 307 { return this->_M_payload._M_value; } 308 309 constexpr const _Tp& 310 _M_get() const noexcept 311 { return this->_M_payload._M_value; } 312 313 // _M_reset is a 'safe' operation with no precondition. 314 constexpr void 315 _M_reset() noexcept 316 { 317 if (this->_M_engaged) 318 _M_destroy(); 319 } 320 }; 321 322 // Class template that manages the payload for optionals. 323 template <typename _Tp, 324 bool /*_HasTrivialDestructor*/ = 325 is_trivially_destructible_v<_Tp>, 326 bool /*_HasTrivialCopy */ = 327 is_trivially_copy_assignable_v<_Tp> 328 && is_trivially_copy_constructible_v<_Tp>, 329 bool /*_HasTrivialMove */ = 330 is_trivially_move_assignable_v<_Tp> 331 && is_trivially_move_constructible_v<_Tp>> 332 struct _Optional_payload; 333 334 // Payload for potentially-constexpr optionals (trivial copy/move/destroy). 335 template <typename _Tp> 336 struct _Optional_payload<_Tp, true, true, true> 337 : _Optional_payload_base<_Tp> 338 { 339 using _Optional_payload_base<_Tp>::_Optional_payload_base; 340 341 _Optional_payload() = default; 342 }; 343 344 // Payload for optionals with non-trivial copy construction/assignment. 345 template <typename _Tp> 346 struct _Optional_payload<_Tp, true, false, true> 347 : _Optional_payload_base<_Tp> 348 { 349 using _Optional_payload_base<_Tp>::_Optional_payload_base; 350 351 _Optional_payload() = default; 352 ~_Optional_payload() = default; 353 _Optional_payload(const _Optional_payload&) = default; 354 _Optional_payload(_Optional_payload&&) = default; 355 _Optional_payload& operator=(_Optional_payload&&) = default; 356 357 // Non-trivial copy assignment. 358 constexpr 359 _Optional_payload& 360 operator=(const _Optional_payload& __other) 361 { 362 this->_M_copy_assign(__other); 363 return *this; 364 } 365 }; 366 367 // Payload for optionals with non-trivial move construction/assignment. 368 template <typename _Tp> 369 struct _Optional_payload<_Tp, true, true, false> 370 : _Optional_payload_base<_Tp> 371 { 372 using _Optional_payload_base<_Tp>::_Optional_payload_base; 373 374 _Optional_payload() = default; 375 ~_Optional_payload() = default; 376 _Optional_payload(const _Optional_payload&) = default; 377 _Optional_payload(_Optional_payload&&) = default; 378 _Optional_payload& operator=(const _Optional_payload&) = default; 379 380 // Non-trivial move assignment. 381 constexpr 382 _Optional_payload& 383 operator=(_Optional_payload&& __other) 384 noexcept(__and_v<is_nothrow_move_constructible<_Tp>, 385 is_nothrow_move_assignable<_Tp>>) 386 { 387 this->_M_move_assign(std::move(__other)); 388 return *this; 389 } 390 }; 391 392 // Payload for optionals with non-trivial copy and move assignment. 393 template <typename _Tp> 394 struct _Optional_payload<_Tp, true, false, false> 395 : _Optional_payload_base<_Tp> 396 { 397 using _Optional_payload_base<_Tp>::_Optional_payload_base; 398 399 _Optional_payload() = default; 400 ~_Optional_payload() = default; 401 _Optional_payload(const _Optional_payload&) = default; 402 _Optional_payload(_Optional_payload&&) = default; 403 404 // Non-trivial copy assignment. 405 constexpr 406 _Optional_payload& 407 operator=(const _Optional_payload& __other) 408 { 409 this->_M_copy_assign(__other); 410 return *this; 411 } 412 413 // Non-trivial move assignment. 414 constexpr 415 _Optional_payload& 416 operator=(_Optional_payload&& __other) 417 noexcept(__and_v<is_nothrow_move_constructible<_Tp>, 418 is_nothrow_move_assignable<_Tp>>) 419 { 420 this->_M_move_assign(std::move(__other)); 421 return *this; 422 } 423 }; 424 425 // Payload for optionals with non-trivial destructors. 426 template <typename _Tp, bool _Copy, bool _Move> 427 struct _Optional_payload<_Tp, false, _Copy, _Move> 428 : _Optional_payload<_Tp, true, false, false> 429 { 430 // Base class implements all the constructors and assignment operators: 431 using _Optional_payload<_Tp, true, false, false>::_Optional_payload; 432 _Optional_payload() = default; 433 _Optional_payload(const _Optional_payload&) = default; 434 _Optional_payload(_Optional_payload&&) = default; 435 _Optional_payload& operator=(const _Optional_payload&) = default; 436 _Optional_payload& operator=(_Optional_payload&&) = default; 437 438 // Destructor needs to destroy the contained value: 439 _GLIBCXX20_CONSTEXPR ~_Optional_payload() { this->_M_reset(); } 440 }; 441 442 // Common base class for _Optional_base<T> to avoid repeating these 443 // member functions in each specialization. 444 template<typename _Tp, typename _Dp> 445 class _Optional_base_impl 446 { 447 protected: 448 using _Stored_type = remove_const_t<_Tp>; 449 450 // The _M_construct operation has !_M_engaged as a precondition 451 // while _M_destruct has _M_engaged as a precondition. 452 template<typename... _Args> 453 constexpr void 454 _M_construct(_Args&&... __args) 455 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>) 456 { 457 static_cast<_Dp*>(this)->_M_payload._M_construct( 458 std::forward<_Args>(__args)...); 459 } 460 461 constexpr void 462 _M_destruct() noexcept 463 { static_cast<_Dp*>(this)->_M_payload._M_destroy(); } 464 465 // _M_reset is a 'safe' operation with no precondition. 466 constexpr void 467 _M_reset() noexcept 468 { static_cast<_Dp*>(this)->_M_payload._M_reset(); } 469 470 constexpr bool _M_is_engaged() const noexcept 471 { return static_cast<const _Dp*>(this)->_M_payload._M_engaged; } 472 473 // The _M_get operations have _M_engaged as a precondition. 474 constexpr _Tp& 475 _M_get() noexcept 476 { 477 __glibcxx_assert(this->_M_is_engaged()); 478 return static_cast<_Dp*>(this)->_M_payload._M_get(); 479 } 480 481 constexpr const _Tp& 482 _M_get() const noexcept 483 { 484 __glibcxx_assert(this->_M_is_engaged()); 485 return static_cast<const _Dp*>(this)->_M_payload._M_get(); 486 } 487 }; 488 489 /** 490 * @brief Class template that provides copy/move constructors of optional. 491 * 492 * Such a separate base class template is necessary in order to 493 * conditionally make copy/move constructors trivial. 494 * 495 * When the contained value is trivially copy/move constructible, 496 * the copy/move constructors of _Optional_base will invoke the 497 * trivial copy/move constructor of _Optional_payload. Otherwise, 498 * they will invoke _Optional_payload(bool, const _Optional_payload&) 499 * or _Optional_payload(bool, _Optional_payload&&) to initialize 500 * the contained value, if copying/moving an engaged optional. 501 * 502 * Whether the other special members are trivial is determined by the 503 * _Optional_payload<_Tp> specialization used for the _M_payload member. 504 * 505 * @see optional, _Enable_special_members 506 */ 507 template<typename _Tp, 508 bool = is_trivially_copy_constructible_v<_Tp>, 509 bool = is_trivially_move_constructible_v<_Tp>> 510 struct _Optional_base 511 : _Optional_base_impl<_Tp, _Optional_base<_Tp>> 512 { 513 // Constructors for disengaged optionals. 514 constexpr _Optional_base() = default; 515 516 // Constructors for engaged optionals. 517 template<typename... _Args, 518 enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false> 519 constexpr explicit 520 _Optional_base(in_place_t, _Args&&... __args) 521 : _M_payload(in_place, std::forward<_Args>(__args)...) 522 { } 523 524 template<typename _Up, typename... _Args, 525 enable_if_t<is_constructible_v<_Tp, 526 initializer_list<_Up>&, 527 _Args...>, bool> = false> 528 constexpr explicit 529 _Optional_base(in_place_t, 530 initializer_list<_Up> __il, 531 _Args&&... __args) 532 : _M_payload(in_place, __il, std::forward<_Args>(__args)...) 533 { } 534 535 // Copy and move constructors. 536 constexpr 537 _Optional_base(const _Optional_base& __other) 538 : _M_payload(__other._M_payload._M_engaged, __other._M_payload) 539 { } 540 541 constexpr 542 _Optional_base(_Optional_base&& __other) 543 noexcept(is_nothrow_move_constructible_v<_Tp>) 544 : _M_payload(__other._M_payload._M_engaged, 545 std::move(__other._M_payload)) 546 { } 547 548 // Assignment operators. 549 _Optional_base& operator=(const _Optional_base&) = default; 550 _Optional_base& operator=(_Optional_base&&) = default; 551 552 _Optional_payload<_Tp> _M_payload; 553 }; 554 555 template<typename _Tp> 556 struct _Optional_base<_Tp, false, true> 557 : _Optional_base_impl<_Tp, _Optional_base<_Tp>> 558 { 559 // Constructors for disengaged optionals. 560 constexpr _Optional_base() = default; 561 562 // Constructors for engaged optionals. 563 template<typename... _Args, 564 enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false> 565 constexpr explicit 566 _Optional_base(in_place_t, _Args&&... __args) 567 : _M_payload(in_place, std::forward<_Args>(__args)...) 568 { } 569 570 template<typename _Up, typename... _Args, 571 enable_if_t<is_constructible_v<_Tp, 572 initializer_list<_Up>&, 573 _Args...>, bool> = false> 574 constexpr explicit 575 _Optional_base(in_place_t, 576 initializer_list<_Up> __il, 577 _Args... __args) 578 : _M_payload(in_place, __il, std::forward<_Args>(__args)...) 579 { } 580 581 // Copy and move constructors. 582 constexpr _Optional_base(const _Optional_base& __other) 583 : _M_payload(__other._M_payload._M_engaged, __other._M_payload) 584 { } 585 586 constexpr _Optional_base(_Optional_base&& __other) = default; 587 588 // Assignment operators. 589 _Optional_base& operator=(const _Optional_base&) = default; 590 _Optional_base& operator=(_Optional_base&&) = default; 591 592 _Optional_payload<_Tp> _M_payload; 593 }; 594 595 template<typename _Tp> 596 struct _Optional_base<_Tp, true, false> 597 : _Optional_base_impl<_Tp, _Optional_base<_Tp>> 598 { 599 // Constructors for disengaged optionals. 600 constexpr _Optional_base() = default; 601 602 // Constructors for engaged optionals. 603 template<typename... _Args, 604 enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false> 605 constexpr explicit 606 _Optional_base(in_place_t, _Args&&... __args) 607 : _M_payload(in_place, std::forward<_Args>(__args)...) 608 { } 609 610 template<typename _Up, typename... _Args, 611 enable_if_t<is_constructible_v<_Tp, 612 initializer_list<_Up>&, 613 _Args...>, bool> = false> 614 constexpr explicit 615 _Optional_base(in_place_t, 616 initializer_list<_Up> __il, 617 _Args&&... __args) 618 : _M_payload(in_place, __il, std::forward<_Args>(__args)...) 619 { } 620 621 // Copy and move constructors. 622 constexpr _Optional_base(const _Optional_base& __other) = default; 623 624 constexpr 625 _Optional_base(_Optional_base&& __other) 626 noexcept(is_nothrow_move_constructible_v<_Tp>) 627 : _M_payload(__other._M_payload._M_engaged, 628 std::move(__other._M_payload)) 629 { } 630 631 // Assignment operators. 632 _Optional_base& operator=(const _Optional_base&) = default; 633 _Optional_base& operator=(_Optional_base&&) = default; 634 635 _Optional_payload<_Tp> _M_payload; 636 }; 637 638 template<typename _Tp> 639 struct _Optional_base<_Tp, true, true> 640 : _Optional_base_impl<_Tp, _Optional_base<_Tp>> 641 { 642 // Constructors for disengaged optionals. 643 constexpr _Optional_base() = default; 644 645 // Constructors for engaged optionals. 646 template<typename... _Args, 647 enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false> 648 constexpr explicit 649 _Optional_base(in_place_t, _Args&&... __args) 650 : _M_payload(in_place, std::forward<_Args>(__args)...) 651 { } 652 653 template<typename _Up, typename... _Args, 654 enable_if_t<is_constructible_v<_Tp, 655 initializer_list<_Up>&, 656 _Args...>, bool> = false> 657 constexpr explicit 658 _Optional_base(in_place_t, 659 initializer_list<_Up> __il, 660 _Args&&... __args) 661 : _M_payload(in_place, __il, std::forward<_Args>(__args)...) 662 { } 663 664 // Copy and move constructors. 665 constexpr _Optional_base(const _Optional_base& __other) = default; 666 constexpr _Optional_base(_Optional_base&& __other) = default; 667 668 // Assignment operators. 669 _Optional_base& operator=(const _Optional_base&) = default; 670 _Optional_base& operator=(_Optional_base&&) = default; 671 672 _Optional_payload<_Tp> _M_payload; 673 }; 674 675 template<typename _Tp> 676 class optional; 677 678 template<typename _Tp> 679 inline constexpr bool __is_optional_v = false; 680 template<typename _Tp> 681 inline constexpr bool __is_optional_v<optional<_Tp>> = true; 682 683 template<typename _Tp, typename _Up> 684 using __converts_from_optional = 685 __or_<is_constructible<_Tp, const optional<_Up>&>, 686 is_constructible<_Tp, optional<_Up>&>, 687 is_constructible<_Tp, const optional<_Up>&&>, 688 is_constructible<_Tp, optional<_Up>&&>, 689 is_convertible<const optional<_Up>&, _Tp>, 690 is_convertible<optional<_Up>&, _Tp>, 691 is_convertible<const optional<_Up>&&, _Tp>, 692 is_convertible<optional<_Up>&&, _Tp>>; 693 694 template<typename _Tp, typename _Up> 695 using __assigns_from_optional = 696 __or_<is_assignable<_Tp&, const optional<_Up>&>, 697 is_assignable<_Tp&, optional<_Up>&>, 698 is_assignable<_Tp&, const optional<_Up>&&>, 699 is_assignable<_Tp&, optional<_Up>&&>>; 700 701 /** 702 * @brief Class template for optional values. 703 */ 704 template<typename _Tp> 705 class optional 706 : private _Optional_base<_Tp>, 707 private _Enable_copy_move< 708 // Copy constructor. 709 is_copy_constructible_v<_Tp>, 710 // Copy assignment. 711 __and_v<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>, 712 // Move constructor. 713 is_move_constructible_v<_Tp>, 714 // Move assignment. 715 __and_v<is_move_constructible<_Tp>, is_move_assignable<_Tp>>, 716 // Unique tag type. 717 optional<_Tp>> 718 { 719 static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>); 720 static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>); 721 static_assert(!is_reference_v<_Tp>); 722 723 private: 724 using _Base = _Optional_base<_Tp>; 725 726 // SFINAE helpers 727 template<typename _Up> 728 using __not_self = __not_<is_same<optional, __remove_cvref_t<_Up>>>; 729 template<typename _Up> 730 using __not_tag = __not_<is_same<in_place_t, __remove_cvref_t<_Up>>>; 731 template<typename... _Cond> 732 using _Requires = enable_if_t<__and_v<_Cond...>, bool>; 733 734 public: 735 using value_type = _Tp; 736 737 constexpr optional() noexcept { } 738 739 constexpr optional(nullopt_t) noexcept { } 740 741 // Converting constructors for engaged optionals. 742 template<typename _Up = _Tp, 743 _Requires<__not_self<_Up>, __not_tag<_Up>, 744 is_constructible<_Tp, _Up>, 745 is_convertible<_Up, _Tp>> = true> 746 constexpr 747 optional(_Up&& __t) 748 noexcept(is_nothrow_constructible_v<_Tp, _Up>) 749 : _Base(std::in_place, std::forward<_Up>(__t)) { } 750 751 template<typename _Up = _Tp, 752 _Requires<__not_self<_Up>, __not_tag<_Up>, 753 is_constructible<_Tp, _Up>, 754 __not_<is_convertible<_Up, _Tp>>> = false> 755 explicit constexpr 756 optional(_Up&& __t) 757 noexcept(is_nothrow_constructible_v<_Tp, _Up>) 758 : _Base(std::in_place, std::forward<_Up>(__t)) { } 759 760 template<typename _Up, 761 _Requires<__not_<is_same<_Tp, _Up>>, 762 is_constructible<_Tp, const _Up&>, 763 is_convertible<const _Up&, _Tp>, 764 __not_<__converts_from_optional<_Tp, _Up>>> = true> 765 constexpr 766 optional(const optional<_Up>& __t) 767 noexcept(is_nothrow_constructible_v<_Tp, const _Up&>) 768 { 769 if (__t) 770 emplace(*__t); 771 } 772 773 template<typename _Up, 774 _Requires<__not_<is_same<_Tp, _Up>>, 775 is_constructible<_Tp, const _Up&>, 776 __not_<is_convertible<const _Up&, _Tp>>, 777 __not_<__converts_from_optional<_Tp, _Up>>> = false> 778 explicit constexpr 779 optional(const optional<_Up>& __t) 780 noexcept(is_nothrow_constructible_v<_Tp, const _Up&>) 781 { 782 if (__t) 783 emplace(*__t); 784 } 785 786 template<typename _Up, 787 _Requires<__not_<is_same<_Tp, _Up>>, 788 is_constructible<_Tp, _Up>, 789 is_convertible<_Up, _Tp>, 790 __not_<__converts_from_optional<_Tp, _Up>>> = true> 791 constexpr 792 optional(optional<_Up>&& __t) 793 noexcept(is_nothrow_constructible_v<_Tp, _Up>) 794 { 795 if (__t) 796 emplace(std::move(*__t)); 797 } 798 799 template<typename _Up, 800 _Requires<__not_<is_same<_Tp, _Up>>, 801 is_constructible<_Tp, _Up>, 802 __not_<is_convertible<_Up, _Tp>>, 803 __not_<__converts_from_optional<_Tp, _Up>>> = false> 804 explicit constexpr 805 optional(optional<_Up>&& __t) 806 noexcept(is_nothrow_constructible_v<_Tp, _Up>) 807 { 808 if (__t) 809 emplace(std::move(*__t)); 810 } 811 812 template<typename... _Args, 813 _Requires<is_constructible<_Tp, _Args...>> = false> 814 explicit constexpr 815 optional(in_place_t, _Args&&... __args) 816 noexcept(is_nothrow_constructible_v<_Tp, _Args...>) 817 : _Base(std::in_place, std::forward<_Args>(__args)...) { } 818 819 template<typename _Up, typename... _Args, 820 _Requires<is_constructible<_Tp, 821 initializer_list<_Up>&, 822 _Args...>> = false> 823 explicit constexpr 824 optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) 825 noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, 826 _Args...>) 827 : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { } 828 829 830 // Assignment operators. 831 _GLIBCXX20_CONSTEXPR optional& 832 operator=(nullopt_t) noexcept 833 { 834 this->_M_reset(); 835 return *this; 836 } 837 838 template<typename _Up = _Tp> 839 _GLIBCXX20_CONSTEXPR 840 enable_if_t<__and_v<__not_self<_Up>, 841 __not_<__and_<is_scalar<_Tp>, 842 is_same<_Tp, decay_t<_Up>>>>, 843 is_constructible<_Tp, _Up>, 844 is_assignable<_Tp&, _Up>>, 845 optional&> 846 operator=(_Up&& __u) 847 noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>, 848 is_nothrow_assignable<_Tp&, _Up>>) 849 { 850 if (this->_M_is_engaged()) 851 this->_M_get() = std::forward<_Up>(__u); 852 else 853 this->_M_construct(std::forward<_Up>(__u)); 854 855 return *this; 856 } 857 858 template<typename _Up> 859 _GLIBCXX20_CONSTEXPR 860 enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>, 861 is_constructible<_Tp, const _Up&>, 862 is_assignable<_Tp&, const _Up&>, 863 __not_<__converts_from_optional<_Tp, _Up>>, 864 __not_<__assigns_from_optional<_Tp, _Up>>>, 865 optional&> 866 operator=(const optional<_Up>& __u) 867 noexcept(__and_v<is_nothrow_constructible<_Tp, const _Up&>, 868 is_nothrow_assignable<_Tp&, const _Up&>>) 869 { 870 if (__u) 871 { 872 if (this->_M_is_engaged()) 873 this->_M_get() = *__u; 874 else 875 this->_M_construct(*__u); 876 } 877 else 878 { 879 this->_M_reset(); 880 } 881 return *this; 882 } 883 884 template<typename _Up> 885 _GLIBCXX20_CONSTEXPR 886 enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>, 887 is_constructible<_Tp, _Up>, 888 is_assignable<_Tp&, _Up>, 889 __not_<__converts_from_optional<_Tp, _Up>>, 890 __not_<__assigns_from_optional<_Tp, _Up>>>, 891 optional&> 892 operator=(optional<_Up>&& __u) 893 noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>, 894 is_nothrow_assignable<_Tp&, _Up>>) 895 { 896 if (__u) 897 { 898 if (this->_M_is_engaged()) 899 this->_M_get() = std::move(*__u); 900 else 901 this->_M_construct(std::move(*__u)); 902 } 903 else 904 { 905 this->_M_reset(); 906 } 907 908 return *this; 909 } 910 911 template<typename... _Args> 912 _GLIBCXX20_CONSTEXPR 913 enable_if_t<is_constructible_v<_Tp, _Args...>, _Tp&> 914 emplace(_Args&&... __args) 915 noexcept(is_nothrow_constructible_v<_Tp, _Args...>) 916 { 917 this->_M_reset(); 918 this->_M_construct(std::forward<_Args>(__args)...); 919 return this->_M_get(); 920 } 921 922 template<typename _Up, typename... _Args> 923 _GLIBCXX20_CONSTEXPR 924 enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, 925 _Tp&> 926 emplace(initializer_list<_Up> __il, _Args&&... __args) 927 noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, 928 _Args...>) 929 { 930 this->_M_reset(); 931 this->_M_construct(__il, std::forward<_Args>(__args)...); 932 return this->_M_get(); 933 } 934 935 // Destructor is implicit, implemented in _Optional_base. 936 937 // Swap. 938 _GLIBCXX20_CONSTEXPR void 939 swap(optional& __other) 940 noexcept(is_nothrow_move_constructible_v<_Tp> 941 && is_nothrow_swappable_v<_Tp>) 942 { 943 using std::swap; 944 945 if (this->_M_is_engaged() && __other._M_is_engaged()) 946 swap(this->_M_get(), __other._M_get()); 947 else if (this->_M_is_engaged()) 948 { 949 __other._M_construct(std::move(this->_M_get())); 950 this->_M_destruct(); 951 } 952 else if (__other._M_is_engaged()) 953 { 954 this->_M_construct(std::move(__other._M_get())); 955 __other._M_destruct(); 956 } 957 } 958 959 // Observers. 960 constexpr const _Tp* 961 operator->() const noexcept 962 { return std::__addressof(this->_M_get()); } 963 964 constexpr _Tp* 965 operator->() noexcept 966 { return std::__addressof(this->_M_get()); } 967 968 constexpr const _Tp& 969 operator*() const& noexcept 970 { return this->_M_get(); } 971 972 constexpr _Tp& 973 operator*()& noexcept 974 { return this->_M_get(); } 975 976 constexpr _Tp&& 977 operator*()&& noexcept 978 { return std::move(this->_M_get()); } 979 980 constexpr const _Tp&& 981 operator*() const&& noexcept 982 { return std::move(this->_M_get()); } 983 984 constexpr explicit operator bool() const noexcept 985 { return this->_M_is_engaged(); } 986 987 constexpr bool has_value() const noexcept 988 { return this->_M_is_engaged(); } 989 990 constexpr const _Tp& 991 value() const& 992 { 993 if (this->_M_is_engaged()) 994 return this->_M_get(); 995 __throw_bad_optional_access(); 996 } 997 998 constexpr _Tp& 999 value()& 1000 { 1001 if (this->_M_is_engaged()) 1002 return this->_M_get(); 1003 __throw_bad_optional_access(); 1004 } 1005 1006 constexpr _Tp&& 1007 value()&& 1008 { 1009 if (this->_M_is_engaged()) 1010 return std::move(this->_M_get()); 1011 __throw_bad_optional_access(); 1012 } 1013 1014 constexpr const _Tp&& 1015 value() const&& 1016 { 1017 if (this->_M_is_engaged()) 1018 return std::move(this->_M_get()); 1019 __throw_bad_optional_access(); 1020 } 1021 1022 template<typename _Up> 1023 constexpr _Tp 1024 value_or(_Up&& __u) const& 1025 { 1026 static_assert(is_copy_constructible_v<_Tp>); 1027 static_assert(is_convertible_v<_Up&&, _Tp>); 1028 1029 if (this->_M_is_engaged()) 1030 return this->_M_get(); 1031 else 1032 return static_cast<_Tp>(std::forward<_Up>(__u)); 1033 } 1034 1035 template<typename _Up> 1036 constexpr _Tp 1037 value_or(_Up&& __u) && 1038 { 1039 static_assert(is_move_constructible_v<_Tp>); 1040 static_assert(is_convertible_v<_Up&&, _Tp>); 1041 1042 if (this->_M_is_engaged()) 1043 return std::move(this->_M_get()); 1044 else 1045 return static_cast<_Tp>(std::forward<_Up>(__u)); 1046 } 1047 1048 #if __cpp_lib_optional >= 202110L 1049 // [optional.monadic] 1050 1051 template<typename _Fn> 1052 constexpr auto 1053 and_then(_Fn&& __f) & 1054 { 1055 using _Up = remove_cvref_t<invoke_result_t<_Fn, _Tp&>>; 1056 static_assert(__is_optional_v<remove_cvref_t<_Up>>); 1057 if (has_value()) 1058 return std::__invoke(std::forward<_Fn>(__f), **this); 1059 else 1060 return _Up(); 1061 } 1062 1063 template<typename _Fn> 1064 constexpr auto 1065 and_then(_Fn&& __f) const & 1066 { 1067 using _Up = remove_cvref_t<invoke_result_t<_Fn, const _Tp&>>; 1068 static_assert(__is_optional_v<_Up>); 1069 if (has_value()) 1070 return std::__invoke(std::forward<_Fn>(__f), **this); 1071 else 1072 return _Up(); 1073 } 1074 1075 template<typename _Fn> 1076 constexpr auto 1077 and_then(_Fn&& __f) && 1078 { 1079 using _Up = remove_cvref_t<invoke_result_t<_Fn, _Tp>>; 1080 static_assert(__is_optional_v<remove_cvref_t<_Up>>); 1081 if (has_value()) 1082 return std::__invoke(std::forward<_Fn>(__f), std::move(**this)); 1083 else 1084 return _Up(); 1085 } 1086 1087 template<typename _Fn> 1088 constexpr auto 1089 and_then(_Fn&& __f) const && 1090 { 1091 using _Up = remove_cvref_t<invoke_result_t<_Fn, const _Tp>>; 1092 static_assert(__is_optional_v<remove_cvref_t<_Up>>); 1093 if (has_value()) 1094 return std::__invoke(std::forward<_Fn>(__f), std::move(**this)); 1095 else 1096 return _Up(); 1097 } 1098 1099 template<typename _Fn> 1100 constexpr auto 1101 transform(_Fn&& __f) & 1102 { 1103 using _Up = remove_cv_t<invoke_result_t<_Fn, _Tp&>>; 1104 if (has_value()) 1105 return optional<_Up>(_Optional_func<_Fn>{__f}, **this); 1106 else 1107 return optional<_Up>(); 1108 } 1109 1110 template<typename _Fn> 1111 constexpr auto 1112 transform(_Fn&& __f) const & 1113 { 1114 using _Up = remove_cv_t<invoke_result_t<_Fn, const _Tp&>>; 1115 if (has_value()) 1116 return optional<_Up>(_Optional_func<_Fn>{__f}, **this); 1117 else 1118 return optional<_Up>(); 1119 } 1120 1121 template<typename _Fn> 1122 constexpr auto 1123 transform(_Fn&& __f) && 1124 { 1125 using _Up = remove_cv_t<invoke_result_t<_Fn, _Tp>>; 1126 if (has_value()) 1127 return optional<_Up>(_Optional_func<_Fn>{__f}, std::move(**this)); 1128 else 1129 return optional<_Up>(); 1130 } 1131 1132 template<typename _Fn> 1133 constexpr auto 1134 transform(_Fn&& __f) const && 1135 { 1136 using _Up = remove_cv_t<invoke_result_t<_Fn, const _Tp>>; 1137 if (has_value()) 1138 return optional<_Up>(_Optional_func<_Fn>{__f}, std::move(**this)); 1139 else 1140 return optional<_Up>(); 1141 } 1142 1143 template<typename _Fn> requires invocable<_Fn> && copy_constructible<_Tp> 1144 constexpr optional 1145 or_else(_Fn&& __f) const& 1146 { 1147 using _Up = invoke_result_t<_Fn>; 1148 static_assert( is_same_v<remove_cvref_t<_Up>, optional> ); 1149 1150 if (has_value()) 1151 return *this; 1152 else 1153 return std::forward<_Fn>(__f)(); 1154 } 1155 1156 template<typename _Fn> requires invocable<_Fn> && move_constructible<_Tp> 1157 constexpr optional 1158 or_else(_Fn&& __f) && 1159 { 1160 using _Up = invoke_result_t<_Fn>; 1161 static_assert( is_same_v<remove_cvref_t<_Up>, optional> ); 1162 1163 if (has_value()) 1164 return std::move(*this); 1165 else 1166 return std::forward<_Fn>(__f)(); 1167 } 1168 #endif 1169 1170 _GLIBCXX20_CONSTEXPR void reset() noexcept { this->_M_reset(); } 1171 1172 private: 1173 #if __cplusplus >= 202002L 1174 template<typename _Up> friend class optional; 1175 1176 template<typename _Fn, typename _Value> 1177 explicit constexpr 1178 optional(_Optional_func<_Fn> __f, _Value&& __v) 1179 { 1180 this->_M_payload._M_apply(__f, std::forward<_Value>(__v)); 1181 } 1182 #endif 1183 }; 1184 1185 template<typename _Tp> 1186 using __optional_relop_t = 1187 enable_if_t<is_convertible<_Tp, bool>::value, bool>; 1188 1189 template<typename _Tp, typename _Up> 1190 using __optional_eq_t = __optional_relop_t< 1191 decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()) 1192 >; 1193 1194 template<typename _Tp, typename _Up> 1195 using __optional_ne_t = __optional_relop_t< 1196 decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()) 1197 >; 1198 1199 template<typename _Tp, typename _Up> 1200 using __optional_lt_t = __optional_relop_t< 1201 decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()) 1202 >; 1203 1204 template<typename _Tp, typename _Up> 1205 using __optional_gt_t = __optional_relop_t< 1206 decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()) 1207 >; 1208 1209 template<typename _Tp, typename _Up> 1210 using __optional_le_t = __optional_relop_t< 1211 decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()) 1212 >; 1213 1214 template<typename _Tp, typename _Up> 1215 using __optional_ge_t = __optional_relop_t< 1216 decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()) 1217 >; 1218 1219 // Comparisons between optional values. 1220 template<typename _Tp, typename _Up> 1221 constexpr auto 1222 operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) 1223 -> __optional_eq_t<_Tp, _Up> 1224 { 1225 return static_cast<bool>(__lhs) == static_cast<bool>(__rhs) 1226 && (!__lhs || *__lhs == *__rhs); 1227 } 1228 1229 template<typename _Tp, typename _Up> 1230 constexpr auto 1231 operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) 1232 -> __optional_ne_t<_Tp, _Up> 1233 { 1234 return static_cast<bool>(__lhs) != static_cast<bool>(__rhs) 1235 || (static_cast<bool>(__lhs) && *__lhs != *__rhs); 1236 } 1237 1238 template<typename _Tp, typename _Up> 1239 constexpr auto 1240 operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) 1241 -> __optional_lt_t<_Tp, _Up> 1242 { 1243 return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs); 1244 } 1245 1246 template<typename _Tp, typename _Up> 1247 constexpr auto 1248 operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) 1249 -> __optional_gt_t<_Tp, _Up> 1250 { 1251 return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs); 1252 } 1253 1254 template<typename _Tp, typename _Up> 1255 constexpr auto 1256 operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) 1257 -> __optional_le_t<_Tp, _Up> 1258 { 1259 return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs); 1260 } 1261 1262 template<typename _Tp, typename _Up> 1263 constexpr auto 1264 operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) 1265 -> __optional_ge_t<_Tp, _Up> 1266 { 1267 return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs); 1268 } 1269 1270 #ifdef __cpp_lib_three_way_comparison 1271 template<typename _Tp, three_way_comparable_with<_Tp> _Up> 1272 constexpr compare_three_way_result_t<_Tp, _Up> 1273 operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y) 1274 { 1275 return __x && __y ? *__x <=> *__y : bool(__x) <=> bool(__y); 1276 } 1277 #endif 1278 1279 // Comparisons with nullopt. 1280 template<typename _Tp> 1281 constexpr bool 1282 operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept 1283 { return !__lhs; } 1284 1285 #ifdef __cpp_lib_three_way_comparison 1286 template<typename _Tp> 1287 constexpr strong_ordering 1288 operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept 1289 { return bool(__x) <=> false; } 1290 #else 1291 template<typename _Tp> 1292 constexpr bool 1293 operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept 1294 { return !__rhs; } 1295 1296 template<typename _Tp> 1297 constexpr bool 1298 operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept 1299 { return static_cast<bool>(__lhs); } 1300 1301 template<typename _Tp> 1302 constexpr bool 1303 operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept 1304 { return static_cast<bool>(__rhs); } 1305 1306 template<typename _Tp> 1307 constexpr bool 1308 operator<(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept 1309 { return false; } 1310 1311 template<typename _Tp> 1312 constexpr bool 1313 operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept 1314 { return static_cast<bool>(__rhs); } 1315 1316 template<typename _Tp> 1317 constexpr bool 1318 operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept 1319 { return static_cast<bool>(__lhs); } 1320 1321 template<typename _Tp> 1322 constexpr bool 1323 operator>(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept 1324 { return false; } 1325 1326 template<typename _Tp> 1327 constexpr bool 1328 operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept 1329 { return !__lhs; } 1330 1331 template<typename _Tp> 1332 constexpr bool 1333 operator<=(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept 1334 { return true; } 1335 1336 template<typename _Tp> 1337 constexpr bool 1338 operator>=(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept 1339 { return true; } 1340 1341 template<typename _Tp> 1342 constexpr bool 1343 operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept 1344 { return !__rhs; } 1345 #endif // three-way-comparison 1346 1347 // Comparisons with value type. 1348 template<typename _Tp, typename _Up> 1349 constexpr auto 1350 operator==(const optional<_Tp>& __lhs, const _Up& __rhs) 1351 -> __optional_eq_t<_Tp, _Up> 1352 { return __lhs && *__lhs == __rhs; } 1353 1354 template<typename _Tp, typename _Up> 1355 constexpr auto 1356 operator==(const _Up& __lhs, const optional<_Tp>& __rhs) 1357 -> __optional_eq_t<_Up, _Tp> 1358 { return __rhs && __lhs == *__rhs; } 1359 1360 template<typename _Tp, typename _Up> 1361 constexpr auto 1362 operator!=(const optional<_Tp>& __lhs, const _Up& __rhs) 1363 -> __optional_ne_t<_Tp, _Up> 1364 { return !__lhs || *__lhs != __rhs; } 1365 1366 template<typename _Tp, typename _Up> 1367 constexpr auto 1368 operator!=(const _Up& __lhs, const optional<_Tp>& __rhs) 1369 -> __optional_ne_t<_Up, _Tp> 1370 { return !__rhs || __lhs != *__rhs; } 1371 1372 template<typename _Tp, typename _Up> 1373 constexpr auto 1374 operator<(const optional<_Tp>& __lhs, const _Up& __rhs) 1375 -> __optional_lt_t<_Tp, _Up> 1376 { return !__lhs || *__lhs < __rhs; } 1377 1378 template<typename _Tp, typename _Up> 1379 constexpr auto 1380 operator<(const _Up& __lhs, const optional<_Tp>& __rhs) 1381 -> __optional_lt_t<_Up, _Tp> 1382 { return __rhs && __lhs < *__rhs; } 1383 1384 template<typename _Tp, typename _Up> 1385 constexpr auto 1386 operator>(const optional<_Tp>& __lhs, const _Up& __rhs) 1387 -> __optional_gt_t<_Tp, _Up> 1388 { return __lhs && *__lhs > __rhs; } 1389 1390 template<typename _Tp, typename _Up> 1391 constexpr auto 1392 operator>(const _Up& __lhs, const optional<_Tp>& __rhs) 1393 -> __optional_gt_t<_Up, _Tp> 1394 { return !__rhs || __lhs > *__rhs; } 1395 1396 template<typename _Tp, typename _Up> 1397 constexpr auto 1398 operator<=(const optional<_Tp>& __lhs, const _Up& __rhs) 1399 -> __optional_le_t<_Tp, _Up> 1400 { return !__lhs || *__lhs <= __rhs; } 1401 1402 template<typename _Tp, typename _Up> 1403 constexpr auto 1404 operator<=(const _Up& __lhs, const optional<_Tp>& __rhs) 1405 -> __optional_le_t<_Up, _Tp> 1406 { return __rhs && __lhs <= *__rhs; } 1407 1408 template<typename _Tp, typename _Up> 1409 constexpr auto 1410 operator>=(const optional<_Tp>& __lhs, const _Up& __rhs) 1411 -> __optional_ge_t<_Tp, _Up> 1412 { return __lhs && *__lhs >= __rhs; } 1413 1414 template<typename _Tp, typename _Up> 1415 constexpr auto 1416 operator>=(const _Up& __lhs, const optional<_Tp>& __rhs) 1417 -> __optional_ge_t<_Up, _Tp> 1418 { return !__rhs || __lhs >= *__rhs; } 1419 1420 #ifdef __cpp_lib_three_way_comparison 1421 template<typename _Tp, typename _Up> 1422 requires (!__is_optional_v<_Up>) 1423 && three_way_comparable_with<_Up, _Tp> 1424 constexpr compare_three_way_result_t<_Tp, _Up> 1425 operator<=>(const optional<_Tp>& __x, const _Up& __v) 1426 { return bool(__x) ? *__x <=> __v : strong_ordering::less; } 1427 #endif 1428 1429 // Swap and creation functions. 1430 1431 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1432 // 2748. swappable traits for optionals 1433 template<typename _Tp> 1434 _GLIBCXX20_CONSTEXPR 1435 inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>> 1436 swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs) 1437 noexcept(noexcept(__lhs.swap(__rhs))) 1438 { __lhs.swap(__rhs); } 1439 1440 template<typename _Tp> 1441 enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)> 1442 swap(optional<_Tp>&, optional<_Tp>&) = delete; 1443 1444 template<typename _Tp> 1445 constexpr 1446 enable_if_t<is_constructible_v<decay_t<_Tp>, _Tp>, 1447 optional<decay_t<_Tp>>> 1448 make_optional(_Tp&& __t) 1449 noexcept(is_nothrow_constructible_v<optional<decay_t<_Tp>>, _Tp>) 1450 { return optional<decay_t<_Tp>>{ std::forward<_Tp>(__t) }; } 1451 1452 template<typename _Tp, typename... _Args> 1453 constexpr 1454 enable_if_t<is_constructible_v<_Tp, _Args...>, 1455 optional<_Tp>> 1456 make_optional(_Args&&... __args) 1457 noexcept(is_nothrow_constructible_v<_Tp, _Args...>) 1458 { return optional<_Tp>{ in_place, std::forward<_Args>(__args)... }; } 1459 1460 template<typename _Tp, typename _Up, typename... _Args> 1461 constexpr 1462 enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, 1463 optional<_Tp>> 1464 make_optional(initializer_list<_Up> __il, _Args&&... __args) 1465 noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) 1466 { return optional<_Tp>{ in_place, __il, std::forward<_Args>(__args)... }; } 1467 1468 // Hash. 1469 1470 template<typename _Tp, typename _Up = remove_const_t<_Tp>, 1471 bool = __poison_hash<_Up>::__enable_hash_call> 1472 struct __optional_hash_call_base 1473 { 1474 size_t 1475 operator()(const optional<_Tp>& __t) const 1476 noexcept(noexcept(hash<_Up>{}(*__t))) 1477 { 1478 // We pick an arbitrary hash for disengaged optionals which hopefully 1479 // usual values of _Tp won't typically hash to. 1480 constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333); 1481 return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash; 1482 } 1483 }; 1484 1485 template<typename _Tp, typename _Up> 1486 struct __optional_hash_call_base<_Tp, _Up, false> {}; 1487 1488 template<typename _Tp> 1489 struct hash<optional<_Tp>> 1490 : private __poison_hash<remove_const_t<_Tp>>, 1491 public __optional_hash_call_base<_Tp> 1492 { 1493 using result_type [[__deprecated__]] = size_t; 1494 using argument_type [[__deprecated__]] = optional<_Tp>; 1495 }; 1496 1497 template<typename _Tp> 1498 struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>> 1499 { }; 1500 1501 /// @} 1502 1503 #if __cpp_deduction_guides >= 201606 1504 template <typename _Tp> optional(_Tp) -> optional<_Tp>; 1505 #endif 1506 1507 _GLIBCXX_END_NAMESPACE_VERSION 1508 } // namespace std 1509 1510 #endif // C++17 1511 1512 #endif // _GLIBCXX_OPTIONAL 1513
Indexes created Sun Oct 25 00:26:45 UTC 2026