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++1y 18 19 namespace std { namespace experimental { inline namespace fundamentals_v1 { 20 21 // 5.3, optional for object types 22 template <class T> class optional; 23 24 // 5.4, In-place construction 25 struct in_place_t{}; 26 constexpr in_place_t in_place{}; 27 28 // 5.5, No-value state indicator 29 struct nullopt_t{see below}; 30 constexpr nullopt_t nullopt(unspecified); 31 32 // 5.6, Class bad_optional_access 33 class bad_optional_access; 34 35 // 5.7, Relational operators 36 template <class T> 37 constexpr bool operator==(const optional<T>&, const optional<T>&); 38 template <class T> 39 constexpr bool operator!=(const optional<T>&, const optional<T>&); 40 template <class T> 41 constexpr bool operator<(const optional<T>&, const optional<T>&); 42 template <class T> 43 constexpr bool operator>(const optional<T>&, const optional<T>&); 44 template <class T> 45 constexpr bool operator<=(const optional<T>&, const optional<T>&); 46 template <class T> 47 constexpr bool operator>=(const optional<T>&, const optional<T>&); 48 49 // 5.8, Comparison with nullopt 50 template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept; 51 template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept; 52 template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept; 53 template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept; 54 template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept; 55 template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept; 56 template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept; 57 template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept; 58 template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept; 59 template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept; 60 template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept; 61 template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept; 62 63 // 5.9, Comparison with T 64 template <class T> constexpr bool operator==(const optional<T>&, const T&); 65 template <class T> constexpr bool operator==(const T&, const optional<T>&); 66 template <class T> constexpr bool operator!=(const optional<T>&, const T&); 67 template <class T> constexpr bool operator!=(const T&, const optional<T>&); 68 template <class T> constexpr bool operator<(const optional<T>&, const T&); 69 template <class T> constexpr bool operator<(const T&, const optional<T>&); 70 template <class T> constexpr bool operator<=(const optional<T>&, const T&); 71 template <class T> constexpr bool operator<=(const T&, const optional<T>&); 72 template <class T> constexpr bool operator>(const optional<T>&, const T&); 73 template <class T> constexpr bool operator>(const T&, const optional<T>&); 74 template <class T> constexpr bool operator>=(const optional<T>&, const T&); 75 template <class T> constexpr bool operator>=(const T&, const optional<T>&); 76 77 // 5.10, Specialized algorithms 78 template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below); 79 template <class T> constexpr optional<see below> make_optional(T&&); 80 81 template <class T> 82 class optional 83 { 84 public: 85 typedef T value_type; 86 87 // 5.3.1, Constructors 88 constexpr optional() noexcept; 89 constexpr optional(nullopt_t) noexcept; 90 optional(const optional&); 91 optional(optional&&) noexcept(see below); 92 constexpr optional(const T&); 93 constexpr optional(T&&); 94 template <class... Args> constexpr explicit optional(in_place_t, Args&&...); 95 template <class U, class... Args> 96 constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...); 97 98 // 5.3.2, Destructor 99 ~optional(); 100 101 // 5.3.3, Assignment 102 optional& operator=(nullopt_t) noexcept; 103 optional& operator=(const optional&); 104 optional& operator=(optional&&) noexcept(see below); 105 template <class U> optional& operator=(U&&); 106 template <class... Args> void emplace(Args&&...); 107 template <class U, class... Args> 108 void emplace(initializer_list<U>, Args&&...); 109 110 // 5.3.4, Swap 111 void swap(optional&) noexcept(see below); 112 113 // 5.3.5, Observers 114 constexpr T const* operator ->() const; 115 constexpr T* operator ->(); 116 constexpr T const& operator *() const &; 117 constexpr T& operator *() &; 118 constexpr T&& operator *() &&; 119 constexpr const T&& operator *() const &&; 120 constexpr explicit operator bool() const noexcept; 121 constexpr T const& value() const &; 122 constexpr T& value() &; 123 constexpr T&& value() &&; 124 constexpr const T&& value() const &&; 125 template <class U> constexpr T value_or(U&&) const &; 126 template <class U> constexpr T value_or(U&&) &&; 127 128 private: 129 T* val; // exposition only 130 }; 131 132 } // namespace fundamentals_v1 133 } // namespace experimental 134 135 // 5.11, Hash support 136 template <class T> struct hash; 137 template <class T> struct hash<experimental::optional<T>>; 138 139 } // namespace std 140 141 */ 142 143 #include <experimental/__config> 144 #include <functional> 145 #include <stdexcept> 146 147 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL 148 class _LIBCPP_EXCEPTION_ABI bad_optional_access 149 : public std::logic_error 150 { 151 public: 152 bad_optional_access() : std::logic_error("Bad optional Access") {} 153 154 // Get the key function ~bad_optional_access() into the dylib 155 virtual ~bad_optional_access() _NOEXCEPT; 156 }; 157 158 _LIBCPP_END_NAMESPACE_EXPERIMENTAL 159 160 161 #if _LIBCPP_STD_VER > 11 162 163 #include <initializer_list> 164 #include <type_traits> 165 #include <new> 166 #include <__functional_base> 167 #include <__undef_min_max> 168 #include <__debug> 169 170 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 171 #pragma GCC system_header 172 #endif 173 174 _LIBCPP_BEGIN_NAMESPACE_LFTS 175 176 struct in_place_t {}; 177 constexpr in_place_t in_place{}; 178 179 struct nullopt_t 180 { 181 explicit constexpr nullopt_t(int) noexcept {} 182 }; 183 184 constexpr nullopt_t nullopt{0}; 185 186 template <class _Tp, bool = is_trivially_destructible<_Tp>::value> 187 class __optional_storage 188 { 189 protected: 190 typedef _Tp value_type; 191 union 192 { 193 char __null_state_; 194 value_type __val_; 195 }; 196 bool __engaged_ = false; 197 198 _LIBCPP_INLINE_VISIBILITY 199 ~__optional_storage() 200 { 201 if (__engaged_) 202 __val_.~value_type(); 203 } 204 205 _LIBCPP_INLINE_VISIBILITY 206 constexpr __optional_storage() noexcept 207 : __null_state_('\0') {} 208 209 _LIBCPP_INLINE_VISIBILITY 210 __optional_storage(const __optional_storage& __x) 211 : __engaged_(__x.__engaged_) 212 { 213 if (__engaged_) 214 ::new(_VSTD::addressof(__val_)) value_type(__x.__val_); 215 } 216 217 _LIBCPP_INLINE_VISIBILITY 218 __optional_storage(__optional_storage&& __x) 219 noexcept(is_nothrow_move_constructible<value_type>::value) 220 : __engaged_(__x.__engaged_) 221 { 222 if (__engaged_) 223 ::new(_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_)); 224 } 225 226 _LIBCPP_INLINE_VISIBILITY 227 constexpr __optional_storage(const value_type& __v) 228 : __val_(__v), 229 __engaged_(true) {} 230 231 _LIBCPP_INLINE_VISIBILITY 232 constexpr __optional_storage(value_type&& __v) 233 : __val_(_VSTD::move(__v)), 234 __engaged_(true) {} 235 236 template <class... _Args> 237 _LIBCPP_INLINE_VISIBILITY 238 constexpr 239 explicit __optional_storage(in_place_t, _Args&&... __args) 240 : __val_(_VSTD::forward<_Args>(__args)...), 241 __engaged_(true) {} 242 }; 243 244 template <class _Tp> 245 class __optional_storage<_Tp, true> 246 { 247 protected: 248 typedef _Tp value_type; 249 union 250 { 251 char __null_state_; 252 value_type __val_; 253 }; 254 bool __engaged_ = false; 255 256 _LIBCPP_INLINE_VISIBILITY 257 constexpr __optional_storage() noexcept 258 : __null_state_('\0') {} 259 260 _LIBCPP_INLINE_VISIBILITY 261 __optional_storage(const __optional_storage& __x) 262 : __engaged_(__x.__engaged_) 263 { 264 if (__engaged_) 265 ::new(_VSTD::addressof(__val_)) value_type(__x.__val_); 266 } 267 268 _LIBCPP_INLINE_VISIBILITY 269 __optional_storage(__optional_storage&& __x) 270 noexcept(is_nothrow_move_constructible<value_type>::value) 271 : __engaged_(__x.__engaged_) 272 { 273 if (__engaged_) 274 ::new(_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_)); 275 } 276 277 _LIBCPP_INLINE_VISIBILITY 278 constexpr __optional_storage(const value_type& __v) 279 : __val_(__v), 280 __engaged_(true) {} 281 282 _LIBCPP_INLINE_VISIBILITY 283 constexpr __optional_storage(value_type&& __v) 284 : __val_(_VSTD::move(__v)), 285 __engaged_(true) {} 286 287 template <class... _Args> 288 _LIBCPP_INLINE_VISIBILITY 289 constexpr 290 explicit __optional_storage(in_place_t, _Args&&... __args) 291 : __val_(_VSTD::forward<_Args>(__args)...), 292 __engaged_(true) {} 293 }; 294 295 template <class _Tp> 296 class optional 297 : private __optional_storage<_Tp> 298 { 299 typedef __optional_storage<_Tp> __base; 300 public: 301 typedef _Tp value_type; 302 303 static_assert(!is_reference<value_type>::value, 304 "Instantiation of optional with a reference type is ill-formed."); 305 static_assert(!is_same<typename remove_cv<value_type>::type, in_place_t>::value, 306 "Instantiation of optional with a in_place_t type is ill-formed."); 307 static_assert(!is_same<typename remove_cv<value_type>::type, nullopt_t>::value, 308 "Instantiation of optional with a nullopt_t type is ill-formed."); 309 static_assert(is_object<value_type>::value, 310 "Instantiation of optional with a non-object type is undefined behavior."); 311 static_assert(is_nothrow_destructible<value_type>::value, 312 "Instantiation of optional with an object type that is not noexcept destructible is undefined behavior."); 313 314 _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {} 315 _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default; 316 _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default; 317 _LIBCPP_INLINE_VISIBILITY ~optional() = default; 318 _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {} 319 _LIBCPP_INLINE_VISIBILITY constexpr optional(const value_type& __v) 320 : __base(__v) {} 321 _LIBCPP_INLINE_VISIBILITY constexpr optional(value_type&& __v) 322 : __base(_VSTD::move(__v)) {} 323 324 template <class... _Args, 325 class = typename enable_if 326 < 327 is_constructible<value_type, _Args...>::value 328 >::type 329 > 330 _LIBCPP_INLINE_VISIBILITY 331 constexpr 332 explicit optional(in_place_t, _Args&&... __args) 333 : __base(in_place, _VSTD::forward<_Args>(__args)...) {} 334 335 template <class _Up, class... _Args, 336 class = typename enable_if 337 < 338 is_constructible<value_type, initializer_list<_Up>&, _Args...>::value 339 >::type 340 > 341 _LIBCPP_INLINE_VISIBILITY 342 constexpr 343 explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) 344 : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {} 345 346 _LIBCPP_INLINE_VISIBILITY 347 optional& operator=(nullopt_t) noexcept 348 { 349 if (this->__engaged_) 350 { 351 this->__val_.~value_type(); 352 this->__engaged_ = false; 353 } 354 return *this; 355 } 356 357 _LIBCPP_INLINE_VISIBILITY 358 optional& 359 operator=(const optional& __opt) 360 { 361 if (this->__engaged_ == __opt.__engaged_) 362 { 363 if (this->__engaged_) 364 this->__val_ = __opt.__val_; 365 } 366 else 367 { 368 if (this->__engaged_) 369 this->__val_.~value_type(); 370 else 371 ::new(_VSTD::addressof(this->__val_)) value_type(__opt.__val_); 372 this->__engaged_ = __opt.__engaged_; 373 } 374 return *this; 375 } 376 377 _LIBCPP_INLINE_VISIBILITY 378 optional& 379 operator=(optional&& __opt) 380 noexcept(is_nothrow_move_assignable<value_type>::value && 381 is_nothrow_move_constructible<value_type>::value) 382 { 383 if (this->__engaged_ == __opt.__engaged_) 384 { 385 if (this->__engaged_) 386 this->__val_ = _VSTD::move(__opt.__val_); 387 } 388 else 389 { 390 if (this->__engaged_) 391 this->__val_.~value_type(); 392 else 393 ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_)); 394 this->__engaged_ = __opt.__engaged_; 395 } 396 return *this; 397 } 398 399 template <class _Up, 400 class = typename enable_if 401 < 402 is_same<typename remove_reference<_Up>::type, value_type>::value && 403 is_constructible<value_type, _Up>::value && 404 is_assignable<value_type&, _Up>::value 405 >::type 406 > 407 _LIBCPP_INLINE_VISIBILITY 408 optional& 409 operator=(_Up&& __v) 410 { 411 if (this->__engaged_) 412 this->__val_ = _VSTD::forward<_Up>(__v); 413 else 414 { 415 ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Up>(__v)); 416 this->__engaged_ = true; 417 } 418 return *this; 419 } 420 421 template <class... _Args, 422 class = typename enable_if 423 < 424 is_constructible<value_type, _Args...>::value 425 >::type 426 > 427 _LIBCPP_INLINE_VISIBILITY 428 void 429 emplace(_Args&&... __args) 430 { 431 *this = nullopt; 432 ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); 433 this->__engaged_ = true; 434 } 435 436 template <class _Up, class... _Args, 437 class = typename enable_if 438 < 439 is_constructible<value_type, initializer_list<_Up>&, _Args...>::value 440 >::type 441 > 442 _LIBCPP_INLINE_VISIBILITY 443 void 444 emplace(initializer_list<_Up> __il, _Args&&... __args) 445 { 446 *this = nullopt; 447 ::new(_VSTD::addressof(this->__val_)) value_type(__il, _VSTD::forward<_Args>(__args)...); 448 this->__engaged_ = true; 449 } 450 451 _LIBCPP_INLINE_VISIBILITY 452 void 453 swap(optional& __opt) 454 noexcept(is_nothrow_move_constructible<value_type>::value && 455 __is_nothrow_swappable<value_type>::value) 456 { 457 using _VSTD::swap; 458 if (this->__engaged_ == __opt.__engaged_) 459 { 460 if (this->__engaged_) 461 swap(this->__val_, __opt.__val_); 462 } 463 else 464 { 465 if (this->__engaged_) 466 { 467 ::new(_VSTD::addressof(__opt.__val_)) value_type(_VSTD::move(this->__val_)); 468 this->__val_.~value_type(); 469 } 470 else 471 { 472 ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_)); 473 __opt.__val_.~value_type(); 474 } 475 swap(this->__engaged_, __opt.__engaged_); 476 } 477 } 478 479 _LIBCPP_INLINE_VISIBILITY 480 constexpr 481 value_type const* 482 operator->() const 483 { 484 _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value"); 485 return __operator_arrow(__has_operator_addressof<value_type>{}); 486 } 487 488 _LIBCPP_INLINE_VISIBILITY 489 value_type* 490 operator->() 491 { 492 _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value"); 493 return _VSTD::addressof(this->__val_); 494 } 495 496 _LIBCPP_INLINE_VISIBILITY 497 constexpr 498 const value_type& 499 operator*() const 500 { 501 _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value"); 502 return this->__val_; 503 } 504 505 _LIBCPP_INLINE_VISIBILITY 506 value_type& 507 operator*() 508 { 509 _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value"); 510 return this->__val_; 511 } 512 513 _LIBCPP_INLINE_VISIBILITY 514 constexpr explicit operator bool() const noexcept {return this->__engaged_;} 515 516 _LIBCPP_INLINE_VISIBILITY 517 constexpr value_type const& value() const 518 { 519 if (!this->__engaged_) 520 throw bad_optional_access(); 521 return this->__val_; 522 } 523 524 _LIBCPP_INLINE_VISIBILITY 525 value_type& value() 526 { 527 if (!this->__engaged_) 528 throw bad_optional_access(); 529 return this->__val_; 530 } 531 532 template <class _Up> 533 _LIBCPP_INLINE_VISIBILITY 534 constexpr value_type value_or(_Up&& __v) const& 535 { 536 static_assert(is_copy_constructible<value_type>::value, 537 "optional<T>::value_or: T must be copy constructible"); 538 static_assert(is_convertible<_Up, value_type>::value, 539 "optional<T>::value_or: U must be convertible to T"); 540 return this->__engaged_ ? this->__val_ : 541 static_cast<value_type>(_VSTD::forward<_Up>(__v)); 542 } 543 544 template <class _Up> 545 _LIBCPP_INLINE_VISIBILITY 546 value_type value_or(_Up&& __v) && 547 { 548 static_assert(is_move_constructible<value_type>::value, 549 "optional<T>::value_or: T must be move constructible"); 550 static_assert(is_convertible<_Up, value_type>::value, 551 "optional<T>::value_or: U must be convertible to T"); 552 return this->__engaged_ ? _VSTD::move(this->__val_) : 553 static_cast<value_type>(_VSTD::forward<_Up>(__v)); 554 } 555 556 private: 557 _LIBCPP_INLINE_VISIBILITY 558 value_type const* 559 __operator_arrow(true_type) const 560 { 561 return _VSTD::addressof(this->__val_); 562 } 563 564 _LIBCPP_INLINE_VISIBILITY 565 constexpr 566 value_type const* 567 __operator_arrow(false_type) const 568 { 569 return &this->__val_; 570 } 571 }; 572 573 // Comparisons between optionals 574 template <class _Tp> 575 inline _LIBCPP_INLINE_VISIBILITY 576 constexpr 577 bool 578 operator==(const optional<_Tp>& __x, const optional<_Tp>& __y) 579 { 580 if (static_cast<bool>(__x) != static_cast<bool>(__y)) 581 return false; 582 if (!static_cast<bool>(__x)) 583 return true; 584 return *__x == *__y; 585 } 586 587 template <class _Tp> 588 inline _LIBCPP_INLINE_VISIBILITY 589 constexpr 590 bool 591 operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y) 592 { 593 return !(__x == __y); 594 } 595 596 template <class _Tp> 597 inline _LIBCPP_INLINE_VISIBILITY 598 constexpr 599 bool 600 operator<(const optional<_Tp>& __x, const optional<_Tp>& __y) 601 { 602 if (!static_cast<bool>(__y)) 603 return false; 604 if (!static_cast<bool>(__x)) 605 return true; 606 return *__x < *__y; 607 } 608 609 template <class _Tp> 610 inline _LIBCPP_INLINE_VISIBILITY 611 constexpr 612 bool 613 operator>(const optional<_Tp>& __x, const optional<_Tp>& __y) 614 { 615 return __y < __x; 616 } 617 618 template <class _Tp> 619 inline _LIBCPP_INLINE_VISIBILITY 620 constexpr 621 bool 622 operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y) 623 { 624 return !(__y < __x); 625 } 626 627 template <class _Tp> 628 inline _LIBCPP_INLINE_VISIBILITY 629 constexpr 630 bool 631 operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y) 632 { 633 return !(__x < __y); 634 } 635 636 637 // Comparisons with nullopt 638 template <class _Tp> 639 inline _LIBCPP_INLINE_VISIBILITY 640 constexpr 641 bool 642 operator==(const optional<_Tp>& __x, nullopt_t) noexcept 643 { 644 return !static_cast<bool>(__x); 645 } 646 647 template <class _Tp> 648 inline _LIBCPP_INLINE_VISIBILITY 649 constexpr 650 bool 651 operator==(nullopt_t, const optional<_Tp>& __x) noexcept 652 { 653 return !static_cast<bool>(__x); 654 } 655 656 template <class _Tp> 657 inline _LIBCPP_INLINE_VISIBILITY 658 constexpr 659 bool 660 operator!=(const optional<_Tp>& __x, nullopt_t) noexcept 661 { 662 return static_cast<bool>(__x); 663 } 664 665 template <class _Tp> 666 inline _LIBCPP_INLINE_VISIBILITY 667 constexpr 668 bool 669 operator!=(nullopt_t, const optional<_Tp>& __x) noexcept 670 { 671 return static_cast<bool>(__x); 672 } 673 674 template <class _Tp> 675 inline _LIBCPP_INLINE_VISIBILITY 676 constexpr 677 bool 678 operator<(const optional<_Tp>&, nullopt_t) noexcept 679 { 680 return false; 681 } 682 683 template <class _Tp> 684 inline _LIBCPP_INLINE_VISIBILITY 685 constexpr 686 bool 687 operator<(nullopt_t, const optional<_Tp>& __x) noexcept 688 { 689 return static_cast<bool>(__x); 690 } 691 692 template <class _Tp> 693 inline _LIBCPP_INLINE_VISIBILITY 694 constexpr 695 bool 696 operator<=(const optional<_Tp>& __x, nullopt_t) noexcept 697 { 698 return !static_cast<bool>(__x); 699 } 700 701 template <class _Tp> 702 inline _LIBCPP_INLINE_VISIBILITY 703 constexpr 704 bool 705 operator<=(nullopt_t, const optional<_Tp>& __x) noexcept 706 { 707 return true; 708 } 709 710 template <class _Tp> 711 inline _LIBCPP_INLINE_VISIBILITY 712 constexpr 713 bool 714 operator>(const optional<_Tp>& __x, nullopt_t) noexcept 715 { 716 return static_cast<bool>(__x); 717 } 718 719 template <class _Tp> 720 inline _LIBCPP_INLINE_VISIBILITY 721 constexpr 722 bool 723 operator>(nullopt_t, const optional<_Tp>& __x) noexcept 724 { 725 return false; 726 } 727 728 template <class _Tp> 729 inline _LIBCPP_INLINE_VISIBILITY 730 constexpr 731 bool 732 operator>=(const optional<_Tp>&, nullopt_t) noexcept 733 { 734 return true; 735 } 736 737 template <class _Tp> 738 inline _LIBCPP_INLINE_VISIBILITY 739 constexpr 740 bool 741 operator>=(nullopt_t, const optional<_Tp>& __x) noexcept 742 { 743 return !static_cast<bool>(__x); 744 } 745 746 // Comparisons with T 747 template <class _Tp> 748 inline _LIBCPP_INLINE_VISIBILITY 749 constexpr 750 bool 751 operator==(const optional<_Tp>& __x, const _Tp& __v) 752 { 753 return static_cast<bool>(__x) ? *__x == __v : false; 754 } 755 756 template <class _Tp> 757 inline _LIBCPP_INLINE_VISIBILITY 758 constexpr 759 bool 760 operator==(const _Tp& __v, const optional<_Tp>& __x) 761 { 762 return static_cast<bool>(__x) ? *__x == __v : false; 763 } 764 765 template <class _Tp> 766 inline _LIBCPP_INLINE_VISIBILITY 767 constexpr 768 bool 769 operator!=(const optional<_Tp>& __x, const _Tp& __v) 770 { 771 return static_cast<bool>(__x) ? !(*__x == __v) : true; 772 } 773 774 template <class _Tp> 775 inline _LIBCPP_INLINE_VISIBILITY 776 constexpr 777 bool 778 operator!=(const _Tp& __v, const optional<_Tp>& __x) 779 { 780 return static_cast<bool>(__x) ? !(*__x == __v) : true; 781 } 782 783 template <class _Tp> 784 inline _LIBCPP_INLINE_VISIBILITY 785 constexpr 786 bool 787 operator<(const optional<_Tp>& __x, const _Tp& __v) 788 { 789 return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true; 790 } 791 792 template <class _Tp> 793 inline _LIBCPP_INLINE_VISIBILITY 794 constexpr 795 bool 796 operator<(const _Tp& __v, const optional<_Tp>& __x) 797 { 798 return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false; 799 } 800 801 template <class _Tp> 802 inline _LIBCPP_INLINE_VISIBILITY 803 constexpr 804 bool 805 operator<=(const optional<_Tp>& __x, const _Tp& __v) 806 { 807 return !(__x > __v); 808 } 809 810 template <class _Tp> 811 inline _LIBCPP_INLINE_VISIBILITY 812 constexpr 813 bool 814 operator<=(const _Tp& __v, const optional<_Tp>& __x) 815 { 816 return !(__v > __x); 817 } 818 819 template <class _Tp> 820 inline _LIBCPP_INLINE_VISIBILITY 821 constexpr 822 bool 823 operator>(const optional<_Tp>& __x, const _Tp& __v) 824 { 825 return static_cast<bool>(__x) ? __v < __x : false; 826 } 827 828 template <class _Tp> 829 inline _LIBCPP_INLINE_VISIBILITY 830 constexpr 831 bool 832 operator>(const _Tp& __v, const optional<_Tp>& __x) 833 { 834 return static_cast<bool>(__x) ? __x < __v : true; 835 } 836 837 template <class _Tp> 838 inline _LIBCPP_INLINE_VISIBILITY 839 constexpr 840 bool 841 operator>=(const optional<_Tp>& __x, const _Tp& __v) 842 { 843 return !(__x < __v); 844 } 845 846 template <class _Tp> 847 inline _LIBCPP_INLINE_VISIBILITY 848 constexpr 849 bool 850 operator>=(const _Tp& __v, const optional<_Tp>& __x) 851 { 852 return !(__v < __x); 853 } 854 855 856 template <class _Tp> 857 inline _LIBCPP_INLINE_VISIBILITY 858 void 859 swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) 860 { 861 __x.swap(__y); 862 } 863 864 template <class _Tp> 865 inline _LIBCPP_INLINE_VISIBILITY 866 constexpr 867 optional<typename decay<_Tp>::type> 868 make_optional(_Tp&& __v) 869 { 870 return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v)); 871 } 872 873 _LIBCPP_END_NAMESPACE_LFTS 874 875 _LIBCPP_BEGIN_NAMESPACE_STD 876 877 template <class _Tp> 878 struct _LIBCPP_TYPE_VIS_ONLY hash<std::experimental::optional<_Tp> > 879 { 880 typedef std::experimental::optional<_Tp> argument_type; 881 typedef size_t result_type; 882 883 _LIBCPP_INLINE_VISIBILITY 884 result_type operator()(const argument_type& __opt) const _NOEXCEPT 885 { 886 return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0; 887 } 888 }; 889 890 _LIBCPP_END_NAMESPACE_STD 891 892 #endif // _LIBCPP_STD_VER > 11 893 894 #endif // _LIBCPP_OPTIONAL 895
