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