1 // -*- C++ -*- 2 //===-------------------------- optional ----------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP_OPTIONAL 12 #define _LIBCPP_OPTIONAL 13 14 /* 15 optional synopsis 16 17 // C++1z 18 19 namespace std { 20 // 23.6.3, optional for object types 21 template <class T> class optional; 22 23 // 23.6.4, no-value state indicator 24 struct nullopt_t{see below }; 25 constexpr nullopt_t nullopt(unspecified ); 26 27 // 23.6.5, class bad_optional_access 28 class bad_optional_access; 29 30 // 23.6.6, relational operators 31 template <class T, class U> 32 constexpr bool operator==(const optional<T>&, const optional<U>&); 33 template <class T, class U> 34 constexpr bool operator!=(const optional<T>&, const optional<U>&); 35 template <class T, class U> 36 constexpr bool operator<(const optional<T>&, const optional<U>&); 37 template <class T, class U> 38 constexpr bool operator>(const optional<T>&, const optional<U>&); 39 template <class T, class U> 40 constexpr bool operator<=(const optional<T>&, const optional<U>&); 41 template <class T, class U> 42 constexpr bool operator>=(const optional<T>&, const optional<U>&); 43 44 // 23.6.7 comparison with nullopt 45 template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept; 46 template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept; 47 template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept; 48 template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept; 49 template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept; 50 template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept; 51 template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept; 52 template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept; 53 template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept; 54 template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept; 55 template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept; 56 template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept; 57 58 // 23.6.8, comparison with T 59 template <class T, class U> constexpr bool operator==(const optional<T>&, const U&); 60 template <class T, class U> constexpr bool operator==(const U&, const optional<T>&); 61 template <class T, class U> constexpr bool operator!=(const optional<T>&, const U&); 62 template <class T, class U> constexpr bool operator!=(const U&, const optional<T>&); 63 template <class T, class U> constexpr bool operator<(const optional<T>&, const U&); 64 template <class T, class U> constexpr bool operator<(const U&, const optional<T>&); 65 template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&); 66 template <class T, class U> constexpr bool operator<=(const U&, const optional<T>&); 67 template <class T, class U> constexpr bool operator>(const optional<T>&, const U&); 68 template <class T, class U> constexpr bool operator>(const U&, const optional<T>&); 69 template <class T, class U> constexpr bool operator>=(const optional<T>&, const U&); 70 template <class T, class U> constexpr bool operator>=(const U&, const optional<T>&); 71 72 // 23.6.9, specialized algorithms 73 template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below ); 74 template <class T> constexpr optional<see below > make_optional(T&&); 75 template <class T, class... Args> 76 constexpr optional<T> make_optional(Args&&... args); 77 template <class T, class U, class... Args> 78 constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args); 79 80 // 23.6.10, hash support 81 template <class T> struct hash; 82 template <class T> struct hash<optional<T>>; 83 84 template <class T> class optional { 85 public: 86 using value_type = T; 87 88 // 23.6.3.1, constructors 89 constexpr optional() noexcept; 90 constexpr optional(nullopt_t) noexcept; 91 optional(const optional &); 92 optional(optional &&) noexcept(see below); 93 template <class... Args> constexpr explicit optional(in_place_t, Args &&...); 94 template <class U, class... Args> 95 constexpr explicit optional(in_place_t, initializer_list<U>, Args &&...); 96 template <class U = T> 97 constexpr EXPLICIT optional(U &&); 98 template <class U> 99 constexpr EXPLICIT optional(const optional<U> &); 100 template <class U> 101 constexpr EXPLICIT optional(optional<U> &&); 102 103 // 23.6.3.2, destructor 104 ~optional(); 105 106 // 23.6.3.3, assignment 107 optional &operator=(nullopt_t) noexcept; 108 optional &operator=(const optional &); 109 optional &operator=(optional &&) noexcept(see below ); 110 template <class U = T> optional &operator=(U &&); 111 template <class U> optional &operator=(const optional<U> &); 112 template <class U> optional &operator=(optional<U> &&); 113 template <class... Args> T& emplace(Args &&...); 114 template <class U, class... Args> 115 T& emplace(initializer_list<U>, Args &&...); 116 117 // 23.6.3.4, swap 118 void swap(optional &) noexcept(see below ); 119 120 // 23.6.3.5, observers 121 constexpr T const *operator->() const; 122 constexpr T *operator->(); 123 constexpr T const &operator*() const &; 124 constexpr T &operator*() &; 125 constexpr T &&operator*() &&; 126 constexpr const T &&operator*() const &&; 127 constexpr explicit operator bool() const noexcept; 128 constexpr bool has_value() const noexcept; 129 constexpr T const &value() const &; 130 constexpr T &value() &; 131 constexpr T &&value() &&; 132 constexpr const T &&value() const &&; 133 template <class U> constexpr T value_or(U &&) const &; 134 template <class U> constexpr T value_or(U &&) &&; 135 136 // 23.6.3.6, modifiers 137 void reset() noexcept; 138 139 private: 140 T *val; // exposition only 141 }; 142 } // namespace std 143 144 */ 145 146 #include <__config> 147 #include <__debug> 148 #include <__functional_base> 149 #include <functional> 150 #include <initializer_list> 151 #include <new> 152 #include <stdexcept> 153 #include <type_traits> 154 #include <utility> 155 156 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 157 #pragma GCC system_header 158 #endif 159 160 _LIBCPP_PUSH_MACROS 161 #include <__undef_macros> 162 163 164 namespace std // purposefully not using versioning namespace 165 { 166 167 class _LIBCPP_EXCEPTION_ABI bad_optional_access 168 : public exception 169 { 170 public: 171 // Get the key function ~bad_optional_access() into the dylib 172 virtual ~bad_optional_access() _NOEXCEPT; 173 virtual const char* what() const _NOEXCEPT; 174 }; 175 176 } // std 177 178 #if _LIBCPP_STD_VER > 14 179 180 _LIBCPP_BEGIN_NAMESPACE_STD 181 182 _LIBCPP_NORETURN 183 inline _LIBCPP_INLINE_VISIBILITY 184 void __throw_bad_optional_access() { 185 #ifndef _LIBCPP_NO_EXCEPTIONS 186 throw bad_optional_access(); 187 #else 188 _VSTD::abort(); 189 #endif 190 } 191 192 struct nullopt_t 193 { 194 struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() = default; }; 195 _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {} 196 }; 197 198 /* inline */ constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}}; 199 200 template <class _Tp, bool = is_trivially_destructible<_Tp>::value> 201 struct __optional_destruct_base; 202 203 template <class _Tp> 204 struct __optional_destruct_base<_Tp, false> 205 { 206 typedef _Tp value_type; 207 static_assert(is_object_v<value_type>, 208 "instantiation of optional with a non-object type is undefined behavior"); 209 union 210 { 211 char __null_state_; 212 value_type __val_; 213 }; 214 bool __engaged_; 215 216 _LIBCPP_INLINE_VISIBILITY 217 ~__optional_destruct_base() 218 { 219 if (__engaged_) 220 __val_.~value_type(); 221 } 222 223 _LIBCPP_INLINE_VISIBILITY 224 constexpr __optional_destruct_base() noexcept 225 : __null_state_(), 226 __engaged_(false) {} 227 228 template <class... _Args> 229 _LIBCPP_INLINE_VISIBILITY 230 constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) 231 : __val_(_VSTD::forward<_Args>(__args)...), 232 __engaged_(true) {} 233 234 _LIBCPP_INLINE_VISIBILITY 235 void reset() noexcept 236 { 237 if (__engaged_) 238 { 239 __val_.~value_type(); 240 __engaged_ = false; 241 } 242 } 243 }; 244 245 template <class _Tp> 246 struct __optional_destruct_base<_Tp, true> 247 { 248 typedef _Tp value_type; 249 static_assert(is_object_v<value_type>, 250 "instantiation of optional with a non-object type is undefined behavior"); 251 union 252 { 253 char __null_state_; 254 value_type __val_; 255 }; 256 bool __engaged_; 257 258 _LIBCPP_INLINE_VISIBILITY 259 constexpr __optional_destruct_base() noexcept 260 : __null_state_(), 261 __engaged_(false) {} 262 263 template <class... _Args> 264 _LIBCPP_INLINE_VISIBILITY 265 constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) 266 : __val_(_VSTD::forward<_Args>(__args)...), 267 __engaged_(true) {} 268 269 _LIBCPP_INLINE_VISIBILITY 270 void reset() noexcept 271 { 272 if (__engaged_) 273 { 274 __engaged_ = false; 275 } 276 } 277 }; 278 279 template <class _Tp, bool = is_reference<_Tp>::value> 280 struct __optional_storage_base : __optional_destruct_base<_Tp> 281 { 282 using __base = __optional_destruct_base<_Tp>; 283 using value_type = _Tp; 284 using __base::__base; 285 286 _LIBCPP_INLINE_VISIBILITY 287 constexpr bool has_value() const noexcept 288 { 289 return this->__engaged_; 290 } 291 292 _LIBCPP_INLINE_VISIBILITY 293 constexpr value_type& __get() & noexcept 294 { 295 return this->__val_; 296 } 297 _LIBCPP_INLINE_VISIBILITY 298 constexpr const value_type& __get() const& noexcept 299 { 300 return this->__val_; 301 } 302 _LIBCPP_INLINE_VISIBILITY 303 constexpr value_type&& __get() && noexcept 304 { 305 return _VSTD::move(this->__val_); 306 } 307 _LIBCPP_INLINE_VISIBILITY 308 constexpr const value_type&& __get() const&& noexcept 309 { 310 return _VSTD::move(this->__val_); 311 } 312 313 template <class... _Args> 314 _LIBCPP_INLINE_VISIBILITY 315 void __construct(_Args&&... __args) 316 { 317 _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); 318 ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); 319 this->__engaged_ = true; 320 } 321 322 template <class _That> 323 _LIBCPP_INLINE_VISIBILITY 324 void __construct_from(_That&& __opt) 325 { 326 if (__opt.has_value()) 327 __construct(_VSTD::forward<_That>(__opt).__get()); 328 } 329 330 template <class _That> 331 _LIBCPP_INLINE_VISIBILITY 332 void __assign_from(_That&& __opt) 333 { 334 if (this->__engaged_ == __opt.has_value()) 335 { 336 if (this->__engaged_) 337 this->__val_ = _VSTD::forward<_That>(__opt).__get(); 338 } 339 else 340 { 341 if (this->__engaged_) 342 this->reset(); 343 else 344 __construct(_VSTD::forward<_That>(__opt).__get()); 345 } 346 } 347 }; 348 349 // optional<T&> is currently required ill-formed, however it may to be in the 350 // future. For this reason it has already been implemented to ensure we can 351 // make the change in an ABI compatible manner. 352 template <class _Tp> 353 struct __optional_storage_base<_Tp, true> 354 { 355 using value_type = _Tp; 356 using __raw_type = remove_reference_t<_Tp>; 357 __raw_type* __value_; 358 359 template <class _Up> 360 static constexpr bool __can_bind_reference() { 361 using _RawUp = typename remove_reference<_Up>::type; 362 using _UpPtr = _RawUp*; 363 using _RawTp = typename remove_reference<_Tp>::type; 364 using _TpPtr = _RawTp*; 365 using _CheckLValueArg = integral_constant<bool, 366 (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value) 367 || is_same<_RawUp, reference_wrapper<_RawTp>>::value 368 || is_same<_RawUp, reference_wrapper<typename remove_const<_RawTp>::type>>::value 369 >; 370 return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value) 371 || (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value && 372 is_convertible<_UpPtr, _TpPtr>::value); 373 } 374 375 _LIBCPP_INLINE_VISIBILITY 376 constexpr __optional_storage_base() noexcept 377 : __value_(nullptr) {} 378 379 template <class _UArg> 380 _LIBCPP_INLINE_VISIBILITY 381 constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg) 382 : __value_(_VSTD::addressof(__uarg)) 383 { 384 static_assert(__can_bind_reference<_UArg>(), 385 "Attempted to construct a reference element in tuple from a " 386 "possible temporary"); 387 } 388 389 _LIBCPP_INLINE_VISIBILITY 390 void reset() noexcept { __value_ = nullptr; } 391 392 _LIBCPP_INLINE_VISIBILITY 393 constexpr bool has_value() const noexcept 394 { return __value_ != nullptr; } 395 396 _LIBCPP_INLINE_VISIBILITY 397 constexpr value_type& __get() const& noexcept 398 { return *__value_; } 399 400 _LIBCPP_INLINE_VISIBILITY 401 constexpr value_type&& __get() const&& noexcept 402 { return _VSTD::forward<value_type>(*__value_); } 403 404 template <class _UArg> 405 _LIBCPP_INLINE_VISIBILITY 406 void __construct(_UArg&& __val) 407 { 408 _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); 409 static_assert(__can_bind_reference<_UArg>(), 410 "Attempted to construct a reference element in tuple from a " 411 "possible temporary"); 412 __value_ = _VSTD::addressof(__val); 413 } 414 415 template <class _That> 416 _LIBCPP_INLINE_VISIBILITY 417 void __construct_from(_That&& __opt) 418 { 419 if (__opt.has_value()) 420 __construct(_VSTD::forward<_That>(__opt).__get()); 421 } 422 423 template <class _That> 424 _LIBCPP_INLINE_VISIBILITY 425 void __assign_from(_That&& __opt) 426 { 427 if (has_value() == __opt.has_value()) 428 { 429 if (has_value()) 430 *__value_ = _VSTD::forward<_That>(__opt).__get(); 431 } 432 else 433 { 434 if (has_value()) 435 reset(); 436 else 437 __construct(_VSTD::forward<_That>(__opt).__get()); 438 } 439 } 440 }; 441 442 template <class _Tp, bool = is_trivially_copyable<_Tp>::value> 443 struct __optional_storage; 444 445 template <class _Tp> 446 struct __optional_storage<_Tp, true> : __optional_storage_base<_Tp> 447 { 448 using __optional_storage_base<_Tp>::__optional_storage_base; 449 }; 450 451 template <class _Tp> 452 struct __optional_storage<_Tp, false> : __optional_storage_base<_Tp> 453 { 454 using value_type = _Tp; 455 using __optional_storage_base<_Tp>::__optional_storage_base; 456 457 _LIBCPP_INLINE_VISIBILITY 458 __optional_storage() = default; 459 460 _LIBCPP_INLINE_VISIBILITY 461 __optional_storage(const __optional_storage& __opt) 462 { 463 this->__construct_from(__opt); 464 } 465 466 _LIBCPP_INLINE_VISIBILITY 467 __optional_storage(__optional_storage&& __opt) 468 noexcept(is_nothrow_move_constructible_v<value_type>) 469 { 470 this->__construct_from(_VSTD::move(__opt)); 471 } 472 473 _LIBCPP_INLINE_VISIBILITY 474 __optional_storage& operator=(const __optional_storage& __opt) 475 { 476 this->__assign_from(__opt); 477 return *this; 478 } 479 480 _LIBCPP_INLINE_VISIBILITY 481 __optional_storage& operator=(__optional_storage&& __opt) 482 noexcept(is_nothrow_move_assignable_v<value_type> && 483 is_nothrow_move_constructible_v<value_type>) 484 { 485 this->__assign_from(_VSTD::move(__opt)); 486 return *this; 487 } 488 }; 489 490 template <class _Tp> 491 using __optional_sfinae_ctor_base_t = __sfinae_ctor_base< 492 is_copy_constructible<_Tp>::value, 493 is_move_constructible<_Tp>::value 494 >; 495 496 template <class _Tp> 497 using __optional_sfinae_assign_base_t = __sfinae_assign_base< 498 (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value), 499 (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value) 500 >; 501 502 template <class _Tp> 503 class optional 504 : private __optional_storage<_Tp> 505 , private __optional_sfinae_ctor_base_t<_Tp> 506 , private __optional_sfinae_assign_base_t<_Tp> 507 { 508 using __base = __optional_storage<_Tp>; 509 public: 510 using value_type = _Tp; 511 512 private: 513 // Disable the reference extension using this static assert. 514 static_assert(!is_same_v<value_type, in_place_t>, 515 "instantiation of optional with in_place_t is ill-formed"); 516 static_assert(!is_same_v<__uncvref_t<value_type>, nullopt_t>, 517 "instantiation of optional with nullopt_t is ill-formed"); 518 static_assert(!is_reference_v<value_type>, 519 "instantiation of optional with a reference type is ill-formed"); 520 static_assert(is_destructible_v<value_type>, 521 "instantiation of optional with a non-destructible type is ill-formed"); 522 523 // LWG2756: conditionally explicit conversion from _Up 524 struct _CheckOptionalArgsConstructor { 525 template <class _Up> 526 static constexpr bool __enable_implicit() { 527 return is_constructible_v<_Tp, _Up&&> && 528 is_convertible_v<_Up&&, _Tp>; 529 } 530 531 template <class _Up> 532 static constexpr bool __enable_explicit() { 533 return is_constructible_v<_Tp, _Up&&> && 534 !is_convertible_v<_Up&&, _Tp>; 535 } 536 }; 537 template <class _Up> 538 using _CheckOptionalArgsCtor = conditional_t< 539 !is_same_v<decay_t<_Up>, in_place_t> && 540 !is_same_v<decay_t<_Up>, optional>, 541 _CheckOptionalArgsConstructor, 542 __check_tuple_constructor_fail 543 >; 544 template <class _QualUp> 545 struct _CheckOptionalLikeConstructor { 546 template <class _Up, class _Opt = optional<_Up>> 547 using __check_constructible_from_opt = __lazy_or< 548 is_constructible<_Tp, _Opt&>, 549 is_constructible<_Tp, _Opt const&>, 550 is_constructible<_Tp, _Opt&&>, 551 is_constructible<_Tp, _Opt const&&>, 552 is_convertible<_Opt&, _Tp>, 553 is_convertible<_Opt const&, _Tp>, 554 is_convertible<_Opt&&, _Tp>, 555 is_convertible<_Opt const&&, _Tp> 556 >; 557 template <class _Up, class _Opt = optional<_Up>> 558 using __check_assignable_from_opt = __lazy_or< 559 is_assignable<_Tp&, _Opt&>, 560 is_assignable<_Tp&, _Opt const&>, 561 is_assignable<_Tp&, _Opt&&>, 562 is_assignable<_Tp&, _Opt const&&> 563 >; 564 template <class _Up, class _QUp = _QualUp> 565 static constexpr bool __enable_implicit() { 566 return is_convertible<_QUp, _Tp>::value && 567 !__check_constructible_from_opt<_Up>::value; 568 } 569 template <class _Up, class _QUp = _QualUp> 570 static constexpr bool __enable_explicit() { 571 return !is_convertible<_QUp, _Tp>::value && 572 !__check_constructible_from_opt<_Up>::value; 573 } 574 template <class _Up, class _QUp = _QualUp> 575 static constexpr bool __enable_assign() { 576 // Construction and assignability of _Qup to _Tp has already been 577 // checked. 578 return !__check_constructible_from_opt<_Up>::value && 579 !__check_assignable_from_opt<_Up>::value; 580 } 581 }; 582 583 template <class _Up, class _QualUp> 584 using _CheckOptionalLikeCtor = conditional_t< 585 __lazy_and< 586 __lazy_not<is_same<_Up, _Tp>>, 587 is_constructible<_Tp, _QualUp> 588 >::value, 589 _CheckOptionalLikeConstructor<_QualUp>, 590 __check_tuple_constructor_fail 591 >; 592 template <class _Up, class _QualUp> 593 using _CheckOptionalLikeAssign = conditional_t< 594 __lazy_and< 595 __lazy_not<is_same<_Up, _Tp>>, 596 is_constructible<_Tp, _QualUp>, 597 is_assignable<_Tp&, _QualUp> 598 >::value, 599 _CheckOptionalLikeConstructor<_QualUp>, 600 __check_tuple_constructor_fail 601 >; 602 public: 603 604 _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {} 605 _LIBCPP_INLINE_VISIBILITY constexpr optional(const optional&) = default; 606 _LIBCPP_INLINE_VISIBILITY constexpr optional(optional&&) = default; 607 _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {} 608 609 template <class... _Args, class = enable_if_t< 610 is_constructible_v<value_type, _Args...>> 611 > 612 _LIBCPP_INLINE_VISIBILITY 613 constexpr explicit optional(in_place_t, _Args&&... __args) 614 : __base(in_place, _VSTD::forward<_Args>(__args)...) {} 615 616 template <class _Up, class... _Args, class = enable_if_t< 617 is_constructible_v<value_type, initializer_list<_Up>&, _Args...>> 618 > 619 _LIBCPP_INLINE_VISIBILITY 620 constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) 621 : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {} 622 623 template <class _Up = value_type, enable_if_t< 624 _CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>() 625 , int> = 0> 626 _LIBCPP_INLINE_VISIBILITY 627 constexpr optional(_Up&& __v) 628 : __base(in_place, _VSTD::forward<_Up>(__v)) {} 629 630 template <class _Up, enable_if_t< 631 _CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>() 632 , int> = 0> 633 _LIBCPP_INLINE_VISIBILITY 634 constexpr explicit optional(_Up&& __v) 635 : __base(in_place, _VSTD::forward<_Up>(__v)) {} 636 637 // LWG2756: conditionally explicit conversion from const optional<_Up>& 638 template <class _Up, enable_if_t< 639 _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>() 640 , int> = 0> 641 _LIBCPP_INLINE_VISIBILITY 642 optional(const optional<_Up>& __v) 643 { 644 this->__construct_from(__v); 645 } 646 template <class _Up, enable_if_t< 647 _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>() 648 , int> = 0> 649 _LIBCPP_INLINE_VISIBILITY 650 explicit optional(const optional<_Up>& __v) 651 { 652 this->__construct_from(__v); 653 } 654 655 // LWG2756: conditionally explicit conversion from optional<_Up>&& 656 template <class _Up, enable_if_t< 657 _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_implicit<_Up>() 658 , int> = 0> 659 _LIBCPP_INLINE_VISIBILITY 660 optional(optional<_Up>&& __v) 661 { 662 this->__construct_from(_VSTD::move(__v)); 663 } 664 template <class _Up, enable_if_t< 665 _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>() 666 , int> = 0> 667 _LIBCPP_INLINE_VISIBILITY 668 explicit optional(optional<_Up>&& __v) 669 { 670 this->__construct_from(_VSTD::move(__v)); 671 } 672 673 _LIBCPP_INLINE_VISIBILITY 674 optional& operator=(nullopt_t) noexcept 675 { 676 reset(); 677 return *this; 678 } 679 680 _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default; 681 _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default; 682 683 // LWG2756 684 template <class _Up = value_type, 685 class = enable_if_t 686 <__lazy_and< 687 integral_constant<bool, 688 !is_same_v<decay_t<_Up>, optional> && 689 !(is_same_v<_Up, value_type> && is_scalar_v<value_type>) 690 >, 691 is_constructible<value_type, _Up>, 692 is_assignable<value_type&, _Up> 693 >::value> 694 > 695 _LIBCPP_INLINE_VISIBILITY 696 optional& 697 operator=(_Up&& __v) 698 { 699 if (this->has_value()) 700 this->__get() = _VSTD::forward<_Up>(__v); 701 else 702 this->__construct(_VSTD::forward<_Up>(__v)); 703 return *this; 704 } 705 706 // LWG2756 707 template <class _Up, enable_if_t< 708 _CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>() 709 , int> = 0> 710 _LIBCPP_INLINE_VISIBILITY 711 optional& 712 operator=(const optional<_Up>& __v) 713 { 714 this->__assign_from(__v); 715 return *this; 716 } 717 718 // LWG2756 719 template <class _Up, enable_if_t< 720 _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_assign<_Up>() 721 , int> = 0> 722 _LIBCPP_INLINE_VISIBILITY 723 optional& 724 operator=(optional<_Up>&& __v) 725 { 726 this->__assign_from(_VSTD::move(__v)); 727 return *this; 728 } 729 730 template <class... _Args, 731 class = enable_if_t 732 < 733 is_constructible_v<value_type, _Args...> 734 > 735 > 736 _LIBCPP_INLINE_VISIBILITY 737 _Tp & 738 emplace(_Args&&... __args) 739 { 740 reset(); 741 this->__construct(_VSTD::forward<_Args>(__args)...); 742 return this->__get(); 743 } 744 745 template <class _Up, class... _Args, 746 class = enable_if_t 747 < 748 is_constructible_v<value_type, initializer_list<_Up>&, _Args...> 749 > 750 > 751 _LIBCPP_INLINE_VISIBILITY 752 _Tp & 753 emplace(initializer_list<_Up> __il, _Args&&... __args) 754 { 755 reset(); 756 this->__construct(__il, _VSTD::forward<_Args>(__args)...); 757 return this->__get(); 758 } 759 760 _LIBCPP_INLINE_VISIBILITY 761 void swap(optional& __opt) 762 noexcept(is_nothrow_move_constructible_v<value_type> && 763 is_nothrow_swappable_v<value_type>) 764 { 765 if (this->has_value() == __opt.has_value()) 766 { 767 using _VSTD::swap; 768 if (this->has_value()) 769 swap(this->__get(), __opt.__get()); 770 } 771 else 772 { 773 if (this->has_value()) 774 { 775 __opt.__construct(_VSTD::move(this->__get())); 776 reset(); 777 } 778 else 779 { 780 this->__construct(_VSTD::move(__opt.__get())); 781 __opt.reset(); 782 } 783 } 784 } 785 786 _LIBCPP_INLINE_VISIBILITY 787 constexpr 788 add_pointer_t<value_type const> 789 operator->() const 790 { 791 _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value"); 792 #ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF 793 return _VSTD::addressof(this->__get()); 794 #else 795 return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get()); 796 #endif 797 } 798 799 _LIBCPP_INLINE_VISIBILITY 800 constexpr 801 add_pointer_t<value_type> 802 operator->() 803 { 804 _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value"); 805 #ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF 806 return _VSTD::addressof(this->__get()); 807 #else 808 return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get()); 809 #endif 810 } 811 812 _LIBCPP_INLINE_VISIBILITY 813 constexpr 814 const value_type& 815 operator*() const& 816 { 817 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); 818 return this->__get(); 819 } 820 821 _LIBCPP_INLINE_VISIBILITY 822 constexpr 823 value_type& 824 operator*() & 825 { 826 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); 827 return this->__get(); 828 } 829 830 _LIBCPP_INLINE_VISIBILITY 831 constexpr 832 value_type&& 833 operator*() && 834 { 835 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); 836 return _VSTD::move(this->__get()); 837 } 838 839 _LIBCPP_INLINE_VISIBILITY 840 constexpr 841 const value_type&& 842 operator*() const&& 843 { 844 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); 845 return _VSTD::move(this->__get()); 846 } 847 848 _LIBCPP_INLINE_VISIBILITY 849 constexpr explicit operator bool() const noexcept { return has_value(); } 850 851 using __base::has_value; 852 using __base::__get; 853 854 _LIBCPP_INLINE_VISIBILITY 855 constexpr value_type const& value() const& 856 { 857 if (!this->has_value()) 858 __throw_bad_optional_access(); 859 return this->__get(); 860 } 861 862 _LIBCPP_INLINE_VISIBILITY 863 constexpr value_type& value() & 864 { 865 if (!this->has_value()) 866 __throw_bad_optional_access(); 867 return this->__get(); 868 } 869 870 _LIBCPP_INLINE_VISIBILITY 871 constexpr value_type&& value() && 872 { 873 if (!this->has_value()) 874 __throw_bad_optional_access(); 875 return _VSTD::move(this->__get()); 876 } 877 878 _LIBCPP_INLINE_VISIBILITY 879 constexpr value_type const&& value() const&& 880 { 881 if (!this->has_value()) 882 __throw_bad_optional_access(); 883 return _VSTD::move(this->__get()); 884 } 885 886 template <class _Up> 887 _LIBCPP_INLINE_VISIBILITY 888 constexpr value_type value_or(_Up&& __v) const& 889 { 890 static_assert(is_copy_constructible_v<value_type>, 891 "optional<T>::value_or: T must be copy constructible"); 892 static_assert(is_convertible_v<_Up, value_type>, 893 "optional<T>::value_or: U must be convertible to T"); 894 return this->has_value() ? this->__get() : 895 static_cast<value_type>(_VSTD::forward<_Up>(__v)); 896 } 897 898 template <class _Up> 899 _LIBCPP_INLINE_VISIBILITY 900 constexpr value_type value_or(_Up&& __v) && 901 { 902 static_assert(is_move_constructible_v<value_type>, 903 "optional<T>::value_or: T must be move constructible"); 904 static_assert(is_convertible_v<_Up, value_type>, 905 "optional<T>::value_or: U must be convertible to T"); 906 return this->has_value() ? _VSTD::move(this->__get()) : 907 static_cast<value_type>(_VSTD::forward<_Up>(__v)); 908 } 909 910 using __base::reset; 911 912 private: 913 template <class _Up> 914 _LIBCPP_INLINE_VISIBILITY 915 static _Up* 916 __operator_arrow(true_type, _Up& __x) 917 { 918 return _VSTD::addressof(__x); 919 } 920 921 template <class _Up> 922 _LIBCPP_INLINE_VISIBILITY 923 static constexpr _Up* 924 __operator_arrow(false_type, _Up& __x) 925 { 926 return &__x; 927 } 928 }; 929 930 // Comparisons between optionals 931 template <class _Tp, class _Up> 932 _LIBCPP_INLINE_VISIBILITY constexpr 933 enable_if_t< 934 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() == 935 _VSTD::declval<const _Up&>()), bool>, 936 bool 937 > 938 operator==(const optional<_Tp>& __x, const optional<_Up>& __y) 939 { 940 if (static_cast<bool>(__x) != static_cast<bool>(__y)) 941 return false; 942 if (!static_cast<bool>(__x)) 943 return true; 944 return *__x == *__y; 945 } 946 947 template <class _Tp, class _Up> 948 _LIBCPP_INLINE_VISIBILITY constexpr 949 enable_if_t< 950 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() != 951 _VSTD::declval<const _Up&>()), bool>, 952 bool 953 > 954 operator!=(const optional<_Tp>& __x, const optional<_Up>& __y) 955 { 956 if (static_cast<bool>(__x) != static_cast<bool>(__y)) 957 return true; 958 if (!static_cast<bool>(__x)) 959 return false; 960 return *__x != *__y; 961 } 962 963 template <class _Tp, class _Up> 964 _LIBCPP_INLINE_VISIBILITY constexpr 965 enable_if_t< 966 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() < 967 _VSTD::declval<const _Up&>()), bool>, 968 bool 969 > 970 operator<(const optional<_Tp>& __x, const optional<_Up>& __y) 971 { 972 if (!static_cast<bool>(__y)) 973 return false; 974 if (!static_cast<bool>(__x)) 975 return true; 976 return *__x < *__y; 977 } 978 979 template <class _Tp, class _Up> 980 _LIBCPP_INLINE_VISIBILITY constexpr 981 enable_if_t< 982 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() > 983 _VSTD::declval<const _Up&>()), bool>, 984 bool 985 > 986 operator>(const optional<_Tp>& __x, const optional<_Up>& __y) 987 { 988 if (!static_cast<bool>(__x)) 989 return false; 990 if (!static_cast<bool>(__y)) 991 return true; 992 return *__x > *__y; 993 } 994 995 template <class _Tp, class _Up> 996 _LIBCPP_INLINE_VISIBILITY constexpr 997 enable_if_t< 998 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <= 999 _VSTD::declval<const _Up&>()), bool>, 1000 bool 1001 > 1002 operator<=(const optional<_Tp>& __x, const optional<_Up>& __y) 1003 { 1004 if (!static_cast<bool>(__x)) 1005 return true; 1006 if (!static_cast<bool>(__y)) 1007 return false; 1008 return *__x <= *__y; 1009 } 1010 1011 template <class _Tp, class _Up> 1012 _LIBCPP_INLINE_VISIBILITY constexpr 1013 enable_if_t< 1014 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >= 1015 _VSTD::declval<const _Up&>()), bool>, 1016 bool 1017 > 1018 operator>=(const optional<_Tp>& __x, const optional<_Up>& __y) 1019 { 1020 if (!static_cast<bool>(__y)) 1021 return true; 1022 if (!static_cast<bool>(__x)) 1023 return false; 1024 return *__x >= *__y; 1025 } 1026 1027 // Comparisons with nullopt 1028 template <class _Tp> 1029 _LIBCPP_INLINE_VISIBILITY constexpr 1030 bool 1031 operator==(const optional<_Tp>& __x, nullopt_t) noexcept 1032 { 1033 return !static_cast<bool>(__x); 1034 } 1035 1036 template <class _Tp> 1037 _LIBCPP_INLINE_VISIBILITY constexpr 1038 bool 1039 operator==(nullopt_t, const optional<_Tp>& __x) noexcept 1040 { 1041 return !static_cast<bool>(__x); 1042 } 1043 1044 template <class _Tp> 1045 _LIBCPP_INLINE_VISIBILITY constexpr 1046 bool 1047 operator!=(const optional<_Tp>& __x, nullopt_t) noexcept 1048 { 1049 return static_cast<bool>(__x); 1050 } 1051 1052 template <class _Tp> 1053 _LIBCPP_INLINE_VISIBILITY constexpr 1054 bool 1055 operator!=(nullopt_t, const optional<_Tp>& __x) noexcept 1056 { 1057 return static_cast<bool>(__x); 1058 } 1059 1060 template <class _Tp> 1061 _LIBCPP_INLINE_VISIBILITY constexpr 1062 bool 1063 operator<(const optional<_Tp>&, nullopt_t) noexcept 1064 { 1065 return false; 1066 } 1067 1068 template <class _Tp> 1069 _LIBCPP_INLINE_VISIBILITY constexpr 1070 bool 1071 operator<(nullopt_t, const optional<_Tp>& __x) noexcept 1072 { 1073 return static_cast<bool>(__x); 1074 } 1075 1076 template <class _Tp> 1077 _LIBCPP_INLINE_VISIBILITY constexpr 1078 bool 1079 operator<=(const optional<_Tp>& __x, nullopt_t) noexcept 1080 { 1081 return !static_cast<bool>(__x); 1082 } 1083 1084 template <class _Tp> 1085 _LIBCPP_INLINE_VISIBILITY constexpr 1086 bool 1087 operator<=(nullopt_t, const optional<_Tp>&) noexcept 1088 { 1089 return true; 1090 } 1091 1092 template <class _Tp> 1093 _LIBCPP_INLINE_VISIBILITY constexpr 1094 bool 1095 operator>(const optional<_Tp>& __x, nullopt_t) noexcept 1096 { 1097 return static_cast<bool>(__x); 1098 } 1099 1100 template <class _Tp> 1101 _LIBCPP_INLINE_VISIBILITY constexpr 1102 bool 1103 operator>(nullopt_t, const optional<_Tp>&) noexcept 1104 { 1105 return false; 1106 } 1107 1108 template <class _Tp> 1109 _LIBCPP_INLINE_VISIBILITY constexpr 1110 bool 1111 operator>=(const optional<_Tp>&, nullopt_t) noexcept 1112 { 1113 return true; 1114 } 1115 1116 template <class _Tp> 1117 _LIBCPP_INLINE_VISIBILITY constexpr 1118 bool 1119 operator>=(nullopt_t, const optional<_Tp>& __x) noexcept 1120 { 1121 return !static_cast<bool>(__x); 1122 } 1123 1124 // Comparisons with T 1125 template <class _Tp, class _Up> 1126 _LIBCPP_INLINE_VISIBILITY constexpr 1127 enable_if_t< 1128 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() == 1129 _VSTD::declval<const _Up&>()), bool>, 1130 bool 1131 > 1132 operator==(const optional<_Tp>& __x, const _Up& __v) 1133 { 1134 return static_cast<bool>(__x) ? *__x == __v : false; 1135 } 1136 1137 template <class _Tp, class _Up> 1138 _LIBCPP_INLINE_VISIBILITY constexpr 1139 enable_if_t< 1140 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() == 1141 _VSTD::declval<const _Up&>()), bool>, 1142 bool 1143 > 1144 operator==(const _Tp& __v, const optional<_Up>& __x) 1145 { 1146 return static_cast<bool>(__x) ? __v == *__x : false; 1147 } 1148 1149 template <class _Tp, class _Up> 1150 _LIBCPP_INLINE_VISIBILITY constexpr 1151 enable_if_t< 1152 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() != 1153 _VSTD::declval<const _Up&>()), bool>, 1154 bool 1155 > 1156 operator!=(const optional<_Tp>& __x, const _Up& __v) 1157 { 1158 return static_cast<bool>(__x) ? *__x != __v : true; 1159 } 1160 1161 template <class _Tp, class _Up> 1162 _LIBCPP_INLINE_VISIBILITY constexpr 1163 enable_if_t< 1164 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() != 1165 _VSTD::declval<const _Up&>()), bool>, 1166 bool 1167 > 1168 operator!=(const _Tp& __v, const optional<_Up>& __x) 1169 { 1170 return static_cast<bool>(__x) ? __v != *__x : true; 1171 } 1172 1173 template <class _Tp, class _Up> 1174 _LIBCPP_INLINE_VISIBILITY constexpr 1175 enable_if_t< 1176 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() < 1177 _VSTD::declval<const _Up&>()), bool>, 1178 bool 1179 > 1180 operator<(const optional<_Tp>& __x, const _Up& __v) 1181 { 1182 return static_cast<bool>(__x) ? *__x < __v : true; 1183 } 1184 1185 template <class _Tp, class _Up> 1186 _LIBCPP_INLINE_VISIBILITY constexpr 1187 enable_if_t< 1188 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() < 1189 _VSTD::declval<const _Up&>()), bool>, 1190 bool 1191 > 1192 operator<(const _Tp& __v, const optional<_Up>& __x) 1193 { 1194 return static_cast<bool>(__x) ? __v < *__x : false; 1195 } 1196 1197 template <class _Tp, class _Up> 1198 _LIBCPP_INLINE_VISIBILITY constexpr 1199 enable_if_t< 1200 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <= 1201 _VSTD::declval<const _Up&>()), bool>, 1202 bool 1203 > 1204 operator<=(const optional<_Tp>& __x, const _Up& __v) 1205 { 1206 return static_cast<bool>(__x) ? *__x <= __v : true; 1207 } 1208 1209 template <class _Tp, class _Up> 1210 _LIBCPP_INLINE_VISIBILITY constexpr 1211 enable_if_t< 1212 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <= 1213 _VSTD::declval<const _Up&>()), bool>, 1214 bool 1215 > 1216 operator<=(const _Tp& __v, const optional<_Up>& __x) 1217 { 1218 return static_cast<bool>(__x) ? __v <= *__x : false; 1219 } 1220 1221 template <class _Tp, class _Up> 1222 _LIBCPP_INLINE_VISIBILITY constexpr 1223 enable_if_t< 1224 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() > 1225 _VSTD::declval<const _Up&>()), bool>, 1226 bool 1227 > 1228 operator>(const optional<_Tp>& __x, const _Up& __v) 1229 { 1230 return static_cast<bool>(__x) ? *__x > __v : false; 1231 } 1232 1233 template <class _Tp, class _Up> 1234 _LIBCPP_INLINE_VISIBILITY constexpr 1235 enable_if_t< 1236 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() > 1237 _VSTD::declval<const _Up&>()), bool>, 1238 bool 1239 > 1240 operator>(const _Tp& __v, const optional<_Up>& __x) 1241 { 1242 return static_cast<bool>(__x) ? __v > *__x : true; 1243 } 1244 1245 template <class _Tp, class _Up> 1246 _LIBCPP_INLINE_VISIBILITY constexpr 1247 enable_if_t< 1248 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >= 1249 _VSTD::declval<const _Up&>()), bool>, 1250 bool 1251 > 1252 operator>=(const optional<_Tp>& __x, const _Up& __v) 1253 { 1254 return static_cast<bool>(__x) ? *__x >= __v : false; 1255 } 1256 1257 template <class _Tp, class _Up> 1258 _LIBCPP_INLINE_VISIBILITY constexpr 1259 enable_if_t< 1260 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >= 1261 _VSTD::declval<const _Up&>()), bool>, 1262 bool 1263 > 1264 operator>=(const _Tp& __v, const optional<_Up>& __x) 1265 { 1266 return static_cast<bool>(__x) ? __v >= *__x : true; 1267 } 1268 1269 1270 template <class _Tp> 1271 inline _LIBCPP_INLINE_VISIBILITY 1272 enable_if_t< 1273 is_move_constructible_v<_Tp> && is_swappable_v<_Tp>, 1274 void 1275 > 1276 swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) 1277 { 1278 __x.swap(__y); 1279 } 1280 1281 template <class _Tp> 1282 _LIBCPP_INLINE_VISIBILITY constexpr 1283 optional<decay_t<_Tp>> make_optional(_Tp&& __v) 1284 { 1285 return optional<decay_t<_Tp>>(_VSTD::forward<_Tp>(__v)); 1286 } 1287 1288 template <class _Tp, class... _Args> 1289 _LIBCPP_INLINE_VISIBILITY constexpr 1290 optional<_Tp> make_optional(_Args&&... __args) 1291 { 1292 return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...); 1293 } 1294 1295 template <class _Tp, class _Up, class... _Args> 1296 _LIBCPP_INLINE_VISIBILITY constexpr 1297 optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) 1298 { 1299 return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...); 1300 } 1301 1302 template <class _Tp> 1303 struct _LIBCPP_TEMPLATE_VIS hash< 1304 __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>> 1305 > 1306 { 1307 typedef optional<_Tp> argument_type; 1308 typedef size_t result_type; 1309 1310 _LIBCPP_INLINE_VISIBILITY 1311 result_type operator()(const argument_type& __opt) const 1312 { 1313 return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0; 1314 } 1315 }; 1316 1317 _LIBCPP_END_NAMESPACE_STD 1318 1319 #endif // _LIBCPP_STD_VER > 14 1320 1321 _LIBCPP_POP_MACROS 1322 1323 #endif // _LIBCPP_OPTIONAL 1324
