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