optional revision 276792
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 19namespace 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 148class _LIBCPP_EXCEPTION_ABI bad_optional_access 149 : public std::logic_error 150{ 151public: 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 176struct in_place_t {}; 177constexpr in_place_t in_place{}; 178 179struct nullopt_t 180{ 181 explicit constexpr nullopt_t(int) noexcept {} 182}; 183 184constexpr nullopt_t nullopt{0}; 185 186template <class _Tp, bool = is_trivially_destructible<_Tp>::value> 187class __optional_storage 188{ 189protected: 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 244template <class _Tp> 245class __optional_storage<_Tp, true> 246{ 247protected: 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 295template <class _Tp> 296class optional 297 : private __optional_storage<_Tp> 298{ 299 typedef __optional_storage<_Tp> __base; 300public: 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 556private: 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 574template <class _Tp> 575inline _LIBCPP_INLINE_VISIBILITY 576constexpr 577bool 578operator==(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 587template <class _Tp> 588inline _LIBCPP_INLINE_VISIBILITY 589constexpr 590bool 591operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y) 592{ 593 return !(__x == __y); 594} 595 596template <class _Tp> 597inline _LIBCPP_INLINE_VISIBILITY 598constexpr 599bool 600operator<(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 609template <class _Tp> 610inline _LIBCPP_INLINE_VISIBILITY 611constexpr 612bool 613operator>(const optional<_Tp>& __x, const optional<_Tp>& __y) 614{ 615 return __y < __x; 616} 617 618template <class _Tp> 619inline _LIBCPP_INLINE_VISIBILITY 620constexpr 621bool 622operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y) 623{ 624 return !(__y < __x); 625} 626 627template <class _Tp> 628inline _LIBCPP_INLINE_VISIBILITY 629constexpr 630bool 631operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y) 632{ 633 return !(__x < __y); 634} 635 636 637// Comparisons with nullopt 638template <class _Tp> 639inline _LIBCPP_INLINE_VISIBILITY 640constexpr 641bool 642operator==(const optional<_Tp>& __x, nullopt_t) noexcept 643{ 644 return !static_cast<bool>(__x); 645} 646 647template <class _Tp> 648inline _LIBCPP_INLINE_VISIBILITY 649constexpr 650bool 651operator==(nullopt_t, const optional<_Tp>& __x) noexcept 652{ 653 return !static_cast<bool>(__x); 654} 655 656template <class _Tp> 657inline _LIBCPP_INLINE_VISIBILITY 658constexpr 659bool 660operator!=(const optional<_Tp>& __x, nullopt_t) noexcept 661{ 662 return static_cast<bool>(__x); 663} 664 665template <class _Tp> 666inline _LIBCPP_INLINE_VISIBILITY 667constexpr 668bool 669operator!=(nullopt_t, const optional<_Tp>& __x) noexcept 670{ 671 return static_cast<bool>(__x); 672} 673 674template <class _Tp> 675inline _LIBCPP_INLINE_VISIBILITY 676constexpr 677bool 678operator<(const optional<_Tp>&, nullopt_t) noexcept 679{ 680 return false; 681} 682 683template <class _Tp> 684inline _LIBCPP_INLINE_VISIBILITY 685constexpr 686bool 687operator<(nullopt_t, const optional<_Tp>& __x) noexcept 688{ 689 return static_cast<bool>(__x); 690} 691 692template <class _Tp> 693inline _LIBCPP_INLINE_VISIBILITY 694constexpr 695bool 696operator<=(const optional<_Tp>& __x, nullopt_t) noexcept 697{ 698 return !static_cast<bool>(__x); 699} 700 701template <class _Tp> 702inline _LIBCPP_INLINE_VISIBILITY 703constexpr 704bool 705operator<=(nullopt_t, const optional<_Tp>& __x) noexcept 706{ 707 return true; 708} 709 710template <class _Tp> 711inline _LIBCPP_INLINE_VISIBILITY 712constexpr 713bool 714operator>(const optional<_Tp>& __x, nullopt_t) noexcept 715{ 716 return static_cast<bool>(__x); 717} 718 719template <class _Tp> 720inline _LIBCPP_INLINE_VISIBILITY 721constexpr 722bool 723operator>(nullopt_t, const optional<_Tp>& __x) noexcept 724{ 725 return false; 726} 727 728template <class _Tp> 729inline _LIBCPP_INLINE_VISIBILITY 730constexpr 731bool 732operator>=(const optional<_Tp>&, nullopt_t) noexcept 733{ 734 return true; 735} 736 737template <class _Tp> 738inline _LIBCPP_INLINE_VISIBILITY 739constexpr 740bool 741operator>=(nullopt_t, const optional<_Tp>& __x) noexcept 742{ 743 return !static_cast<bool>(__x); 744} 745 746// Comparisons with T 747template <class _Tp> 748inline _LIBCPP_INLINE_VISIBILITY 749constexpr 750bool 751operator==(const optional<_Tp>& __x, const _Tp& __v) 752{ 753 return static_cast<bool>(__x) ? *__x == __v : false; 754} 755 756template <class _Tp> 757inline _LIBCPP_INLINE_VISIBILITY 758constexpr 759bool 760operator==(const _Tp& __v, const optional<_Tp>& __x) 761{ 762 return static_cast<bool>(__x) ? *__x == __v : false; 763} 764 765template <class _Tp> 766inline _LIBCPP_INLINE_VISIBILITY 767constexpr 768bool 769operator!=(const optional<_Tp>& __x, const _Tp& __v) 770{ 771 return static_cast<bool>(__x) ? !(*__x == __v) : true; 772} 773 774template <class _Tp> 775inline _LIBCPP_INLINE_VISIBILITY 776constexpr 777bool 778operator!=(const _Tp& __v, const optional<_Tp>& __x) 779{ 780 return static_cast<bool>(__x) ? !(*__x == __v) : true; 781} 782 783template <class _Tp> 784inline _LIBCPP_INLINE_VISIBILITY 785constexpr 786bool 787operator<(const optional<_Tp>& __x, const _Tp& __v) 788{ 789 return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true; 790} 791 792template <class _Tp> 793inline _LIBCPP_INLINE_VISIBILITY 794constexpr 795bool 796operator<(const _Tp& __v, const optional<_Tp>& __x) 797{ 798 return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false; 799} 800 801template <class _Tp> 802inline _LIBCPP_INLINE_VISIBILITY 803constexpr 804bool 805operator<=(const optional<_Tp>& __x, const _Tp& __v) 806{ 807 return !(__x > __v); 808} 809 810template <class _Tp> 811inline _LIBCPP_INLINE_VISIBILITY 812constexpr 813bool 814operator<=(const _Tp& __v, const optional<_Tp>& __x) 815{ 816 return !(__v > __x); 817} 818 819template <class _Tp> 820inline _LIBCPP_INLINE_VISIBILITY 821constexpr 822bool 823operator>(const optional<_Tp>& __x, const _Tp& __v) 824{ 825 return static_cast<bool>(__x) ? __v < __x : false; 826} 827 828template <class _Tp> 829inline _LIBCPP_INLINE_VISIBILITY 830constexpr 831bool 832operator>(const _Tp& __v, const optional<_Tp>& __x) 833{ 834 return static_cast<bool>(__x) ? __x < __v : true; 835} 836 837template <class _Tp> 838inline _LIBCPP_INLINE_VISIBILITY 839constexpr 840bool 841operator>=(const optional<_Tp>& __x, const _Tp& __v) 842{ 843 return !(__x < __v); 844} 845 846template <class _Tp> 847inline _LIBCPP_INLINE_VISIBILITY 848constexpr 849bool 850operator>=(const _Tp& __v, const optional<_Tp>& __x) 851{ 852 return !(__v < __x); 853} 854 855 856template <class _Tp> 857inline _LIBCPP_INLINE_VISIBILITY 858void 859swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) 860{ 861 __x.swap(__y); 862} 863 864template <class _Tp> 865inline _LIBCPP_INLINE_VISIBILITY 866constexpr 867optional<typename decay<_Tp>::type> 868make_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 877template <class _Tp> 878struct _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