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 #include <initializer_list> 20 21 namespace std { namespace experimental { 22 23 // optional for object types 24 template <class T> 25 class optional 26 { 27 public: 28 typedef T value_type; 29 30 // constructors 31 constexpr optional() noexcept; 32 constexpr optional(nullopt_t) noexcept; 33 optional(const optional&); 34 optional(optional&&) noexcept(is_nothrow_move_constructible<T>::value); 35 constexpr optional(const T&); 36 constexpr optional(T&&); 37 template <class... Args> constexpr explicit optional(in_place_t, Args&&...); 38 template <class U, class... Args> 39 constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...); 40 41 // destructor 42 ~optional(); 43 44 // assignment 45 optional& operator=(nullopt_t) noexcept; 46 optional& operator=(const optional&); 47 optional& operator=(optional&&) 48 noexcept(is_nothrow_move_assignable<T>::value && 49 is_nothrow_move_constructible<T>::value); 50 template <class U> optional& operator=(U&&); 51 template <class... Args> void emplace(Args&&...); 52 template <class U, class... Args> void emplace(initializer_list<U>, Args&&...); 53 54 // swap 55 void swap(optional&) 56 noexcept(is_nothrow_move_constructible<T>::value && 57 noexcept(swap(declval<T&>(), declval<T&>()))); 58 59 // observers 60 constexpr T const* operator->() const; 61 T* operator->(); 62 constexpr T const& operator*() const; 63 T& operator*(); 64 constexpr explicit operator bool() const noexcept; 65 constexpr T const& value() const; 66 T& value(); 67 template <class U> constexpr T value_or(U&&) const&; 68 template <class U> T value_or(U&&) &&; 69 }; 70 71 // In-place construction 72 struct in_place_t{}; 73 constexpr in_place_t in_place{}; 74 75 // Disengaged state indicator 76 struct nullopt_t{see below}; 77 constexpr nullopt_t nullopt(unspecified); 78 79 // class bad_optional_access 80 class bad_optional_access 81 : public logic_error 82 { 83 public: 84 explicit bad_optional_access(const string& what_arg); 85 explicit bad_optional_access(const char* what_arg); 86 }; 87 88 // Relational operators 89 template <class T> constexpr bool operator==(const optional<T>&, const optional<T>&); 90 template <class T> constexpr bool operator< (const optional<T>&, const optional<T>&); 91 92 // Comparison with nullopt 93 template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept; 94 template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept; 95 template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept; 96 template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept; 97 98 // Comparison with T 99 template <class T> constexpr bool operator==(const optional<T>&, const T&); 100 template <class T> constexpr bool operator==(const T&, const optional<T>&); 101 template <class T> constexpr bool operator<(const optional<T>&, const T&); 102 template <class T> constexpr bool operator<(const T&, const optional<T>&); 103 104 // Specialized algorithms 105 template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below); 106 template <class T> constexpr optional<typename decay<T>::type> make_optional(T&&); 107 108 // hash support 109 template <class T> struct hash; 110 template <class T> struct hash<optional<T>>; 111 112 }} // std::experimental 113 114 */ 115 116 #include <__config> 117 #include <functional> 118 #include <stdexcept> 119 120 namespace std { namespace experimental { 121 122 class _LIBCPP_EXCEPTION_ABI bad_optional_access 123 : public logic_error 124 { 125 public: 126 #if _LIBCPP_STD_VER > 11 127 _LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const string& __arg) 128 : logic_error(__arg) {} 129 _LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const char* __arg) 130 : logic_error(__arg) {} 131 _LIBCPP_INLINE_VISIBILITY bad_optional_access(const bad_optional_access&) noexcept = default; 132 _LIBCPP_INLINE_VISIBILITY bad_optional_access& operator=(const bad_optional_access&) noexcept = default; 133 #else 134 private: 135 bad_optional_access(const bad_optional_access&); 136 bad_optional_access& operator=(const bad_optional_access&); 137 public: 138 #endif // _LIBCPP_STD_VER > 11 139 // Get the key function ~bad_optional_access() into the dylib even if not compiling for C++1y 140 virtual ~bad_optional_access() _NOEXCEPT; 141 }; 142 143 }} // std::experimental 144 145 #if _LIBCPP_STD_VER > 11 146 147 #include <initializer_list> 148 #include <type_traits> 149 #include <new> 150 #include <__functional_base> 151 152 #include <__undef_min_max> 153 154 #ifdef _LIBCPP_DEBUG 155 # include <__debug> 156 #else 157 # define _LIBCPP_ASSERT(x, m) ((void)0) 158 #endif 159 160 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 161 #pragma GCC system_header 162 #endif 163 164 namespace std { namespace experimental { inline namespace __library_fundamentals_v1 { 165 166 struct in_place_t {}; 167 constexpr in_place_t in_place{}; 168 169 struct nullopt_t 170 { 171 explicit constexpr nullopt_t(int) noexcept {} 172 }; 173 174 constexpr nullopt_t nullopt{0}; 175 176 template <class _Tp, bool = is_trivially_destructible<_Tp>::value> 177 class __optional_storage 178 { 179 protected: 180 typedef _Tp value_type; 181 union 182 { 183 char __null_state_; 184 value_type __val_; 185 }; 186 bool __engaged_ = false; 187 188 _LIBCPP_INLINE_VISIBILITY 189 ~__optional_storage() 190 { 191 if (__engaged_) 192 __val_.~value_type(); 193 } 194 195 _LIBCPP_INLINE_VISIBILITY 196 constexpr __optional_storage() noexcept 197 : __null_state_('\0') {} 198 199 _LIBCPP_INLINE_VISIBILITY 200 __optional_storage(const __optional_storage& __x) 201 : __engaged_(__x.__engaged_) 202 { 203 if (__engaged_) 204 ::new(_VSTD::addressof(__val_)) value_type(__x.__val_); 205 } 206 207 _LIBCPP_INLINE_VISIBILITY 208 __optional_storage(__optional_storage&& __x) 209 noexcept(is_nothrow_move_constructible<value_type>::value) 210 : __engaged_(__x.__engaged_) 211 { 212 if (__engaged_) 213 ::new(_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_)); 214 } 215 216 _LIBCPP_INLINE_VISIBILITY 217 constexpr __optional_storage(const value_type& __v) 218 : __val_(__v), 219 __engaged_(true) {} 220 221 _LIBCPP_INLINE_VISIBILITY 222 constexpr __optional_storage(value_type&& __v) 223 : __val_(_VSTD::move(__v)), 224 __engaged_(true) {} 225 226 template <class... _Args> 227 _LIBCPP_INLINE_VISIBILITY 228 constexpr 229 explicit __optional_storage(in_place_t, _Args&&... __args) 230 : __val_(_VSTD::forward<_Args>(__args)...), 231 __engaged_(true) {} 232 }; 233 234 template <class _Tp> 235 class __optional_storage<_Tp, true> 236 { 237 protected: 238 typedef _Tp value_type; 239 union 240 { 241 char __null_state_; 242 value_type __val_; 243 }; 244 bool __engaged_ = false; 245 246 _LIBCPP_INLINE_VISIBILITY 247 constexpr __optional_storage() noexcept 248 : __null_state_('\0') {} 249 250 _LIBCPP_INLINE_VISIBILITY 251 __optional_storage(const __optional_storage& __x) 252 : __engaged_(__x.__engaged_) 253 { 254 if (__engaged_) 255 ::new(_VSTD::addressof(__val_)) value_type(__x.__val_); 256 } 257 258 _LIBCPP_INLINE_VISIBILITY 259 __optional_storage(__optional_storage&& __x) 260 noexcept(is_nothrow_move_constructible<value_type>::value) 261 : __engaged_(__x.__engaged_) 262 { 263 if (__engaged_) 264 ::new(_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_)); 265 } 266 267 _LIBCPP_INLINE_VISIBILITY 268 constexpr __optional_storage(const value_type& __v) 269 : __val_(__v), 270 __engaged_(true) {} 271 272 _LIBCPP_INLINE_VISIBILITY 273 constexpr __optional_storage(value_type&& __v) 274 : __val_(_VSTD::move(__v)), 275 __engaged_(true) {} 276 277 template <class... _Args> 278 _LIBCPP_INLINE_VISIBILITY 279 constexpr 280 explicit __optional_storage(in_place_t, _Args&&... __args) 281 : __val_(_VSTD::forward<_Args>(__args)...), 282 __engaged_(true) {} 283 }; 284 285 template <class _Tp> 286 class optional 287 : private __optional_storage<_Tp> 288 { 289 typedef __optional_storage<_Tp> __base; 290 public: 291 typedef _Tp value_type; 292 293 static_assert(!is_reference<value_type>::value, 294 "Instantiation of optional with a reference type is ill-formed."); 295 static_assert(!is_same<typename remove_cv<value_type>::type, in_place_t>::value, 296 "Instantiation of optional with a in_place_t type is ill-formed."); 297 static_assert(!is_same<typename remove_cv<value_type>::type, nullopt_t>::value, 298 "Instantiation of optional with a nullopt_t type is ill-formed."); 299 static_assert(is_object<value_type>::value, 300 "Instantiation of optional with a non-object type is undefined behavior."); 301 static_assert(is_nothrow_destructible<value_type>::value, 302 "Instantiation of optional with an object type that is not noexcept destructible is undefined behavior."); 303 304 _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {} 305 _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default; 306 _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default; 307 _LIBCPP_INLINE_VISIBILITY ~optional() = default; 308 _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {} 309 _LIBCPP_INLINE_VISIBILITY constexpr optional(const value_type& __v) 310 : __base(__v) {} 311 _LIBCPP_INLINE_VISIBILITY constexpr optional(value_type&& __v) 312 : __base(_VSTD::move(__v)) {} 313 314 template <class... _Args, 315 class = typename enable_if 316 < 317 is_constructible<value_type, _Args...>::value 318 >::type 319 > 320 _LIBCPP_INLINE_VISIBILITY 321 constexpr 322 explicit optional(in_place_t, _Args&&... __args) 323 : __base(in_place, _VSTD::forward<_Args>(__args)...) {} 324 325 template <class _Up, class... _Args, 326 class = typename enable_if 327 < 328 is_constructible<value_type, initializer_list<_Up>&, _Args...>::value 329 >::type 330 > 331 _LIBCPP_INLINE_VISIBILITY 332 constexpr 333 explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) 334 : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {} 335 336 _LIBCPP_INLINE_VISIBILITY 337 optional& operator=(nullopt_t) noexcept 338 { 339 if (this->__engaged_) 340 { 341 this->__val_.~value_type(); 342 this->__engaged_ = false; 343 } 344 return *this; 345 } 346 347 _LIBCPP_INLINE_VISIBILITY 348 optional& 349 operator=(const optional& __opt) 350 { 351 if (this->__engaged_ == __opt.__engaged_) 352 { 353 if (this->__engaged_) 354 this->__val_ = __opt.__val_; 355 } 356 else 357 { 358 if (this->__engaged_) 359 this->__val_.~value_type(); 360 else 361 ::new(_VSTD::addressof(this->__val_)) value_type(__opt.__val_); 362 this->__engaged_ = __opt.__engaged_; 363 } 364 return *this; 365 } 366 367 _LIBCPP_INLINE_VISIBILITY 368 optional& 369 operator=(optional&& __opt) 370 noexcept(is_nothrow_move_assignable<value_type>::value && 371 is_nothrow_move_constructible<value_type>::value) 372 { 373 if (this->__engaged_ == __opt.__engaged_) 374 { 375 if (this->__engaged_) 376 this->__val_ = _VSTD::move(__opt.__val_); 377 } 378 else 379 { 380 if (this->__engaged_) 381 this->__val_.~value_type(); 382 else 383 ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_)); 384 this->__engaged_ = __opt.__engaged_; 385 } 386 return *this; 387 } 388 389 template <class _Up, 390 class = typename enable_if 391 < 392 is_same<typename remove_reference<_Up>::type, value_type>::value && 393 is_constructible<value_type, _Up>::value && 394 is_assignable<value_type&, _Up>::value 395 >::type 396 > 397 _LIBCPP_INLINE_VISIBILITY 398 optional& 399 operator=(_Up&& __v) 400 { 401 if (this->__engaged_) 402 this->__val_ = _VSTD::forward<_Up>(__v); 403 else 404 { 405 ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Up>(__v)); 406 this->__engaged_ = true; 407 } 408 return *this; 409 } 410 411 template <class... _Args, 412 class = typename enable_if 413 < 414 is_constructible<value_type, _Args...>::value 415 >::type 416 > 417 _LIBCPP_INLINE_VISIBILITY 418 void 419 emplace(_Args&&... __args) 420 { 421 *this = nullopt; 422 ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); 423 this->__engaged_ = true; 424 } 425 426 template <class _Up, class... _Args, 427 class = typename enable_if 428 < 429 is_constructible<value_type, initializer_list<_Up>&, _Args...>::value 430 >::type 431 > 432 _LIBCPP_INLINE_VISIBILITY 433 void 434 emplace(initializer_list<_Up> __il, _Args&&... __args) 435 { 436 *this = nullopt; 437 ::new(_VSTD::addressof(this->__val_)) value_type(__il, _VSTD::forward<_Args>(__args)...); 438 this->__engaged_ = true; 439 } 440 441 _LIBCPP_INLINE_VISIBILITY 442 void 443 swap(optional& __opt) 444 noexcept(is_nothrow_move_constructible<value_type>::value && 445 __is_nothrow_swappable<value_type>::value) 446 { 447 using _VSTD::swap; 448 if (this->__engaged_ == __opt.__engaged_) 449 { 450 if (this->__engaged_) 451 swap(this->__val_, __opt.__val_); 452 } 453 else 454 { 455 if (this->__engaged_) 456 { 457 ::new(_VSTD::addressof(__opt.__val_)) value_type(_VSTD::move(this->__val_)); 458 this->__val_.~value_type(); 459 } 460 else 461 { 462 ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_)); 463 __opt.__val_.~value_type(); 464 } 465 swap(this->__engaged_, __opt.__engaged_); 466 } 467 } 468 469 _LIBCPP_INLINE_VISIBILITY 470 constexpr 471 value_type const* 472 operator->() const 473 { 474 _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value"); 475 return __operator_arrow(__has_operator_addressof<value_type>{}); 476 } 477 478 _LIBCPP_INLINE_VISIBILITY 479 value_type* 480 operator->() 481 { 482 _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value"); 483 return _VSTD::addressof(this->__val_); 484 } 485 486 _LIBCPP_INLINE_VISIBILITY 487 constexpr 488 const value_type& 489 operator*() const 490 { 491 _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value"); 492 return this->__val_; 493 } 494 495 _LIBCPP_INLINE_VISIBILITY 496 value_type& 497 operator*() 498 { 499 _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value"); 500 return this->__val_; 501 } 502 503 _LIBCPP_INLINE_VISIBILITY 504 constexpr explicit operator bool() const noexcept {return this->__engaged_;} 505 506 _LIBCPP_INLINE_VISIBILITY 507 constexpr value_type const& value() const 508 { 509 if (!this->__engaged_) 510 throw bad_optional_access("optional<T>::value: not engaged"); 511 return this->__val_; 512 } 513 514 _LIBCPP_INLINE_VISIBILITY 515 value_type& value() 516 { 517 if (!this->__engaged_) 518 throw bad_optional_access("optional<T>::value: not engaged"); 519 return this->__val_; 520 } 521 522 template <class _Up> 523 _LIBCPP_INLINE_VISIBILITY 524 constexpr value_type value_or(_Up&& __v) const& 525 { 526 static_assert(is_copy_constructible<value_type>::value, 527 "optional<T>::value_or: T must be copy constructible"); 528 static_assert(is_convertible<_Up, value_type>::value, 529 "optional<T>::value_or: U must be convertible to T"); 530 return this->__engaged_ ? this->__val_ : 531 static_cast<value_type>(_VSTD::forward<_Up>(__v)); 532 } 533 534 template <class _Up> 535 _LIBCPP_INLINE_VISIBILITY 536 value_type value_or(_Up&& __v) && 537 { 538 static_assert(is_move_constructible<value_type>::value, 539 "optional<T>::value_or: T must be move constructible"); 540 static_assert(is_convertible<_Up, value_type>::value, 541 "optional<T>::value_or: U must be convertible to T"); 542 return this->__engaged_ ? _VSTD::move(this->__val_) : 543 static_cast<value_type>(_VSTD::forward<_Up>(__v)); 544 } 545 546 private: 547 _LIBCPP_INLINE_VISIBILITY 548 value_type const* 549 __operator_arrow(true_type) const 550 { 551 return _VSTD::addressof(this->__val_); 552 } 553 554 _LIBCPP_INLINE_VISIBILITY 555 constexpr 556 value_type const* 557 __operator_arrow(false_type) const 558 { 559 return &this->__val_; 560 } 561 }; 562 563 template <class _Tp> 564 inline _LIBCPP_INLINE_VISIBILITY 565 constexpr 566 bool 567 operator==(const optional<_Tp>& __x, const optional<_Tp>& __y) 568 { 569 if (static_cast<bool>(__x) != static_cast<bool>(__y)) 570 return false; 571 if (!static_cast<bool>(__x)) 572 return true; 573 return *__x == *__y; 574 } 575 576 template <class _Tp> 577 inline _LIBCPP_INLINE_VISIBILITY 578 constexpr 579 bool 580 operator<(const optional<_Tp>& __x, const optional<_Tp>& __y) 581 { 582 if (!static_cast<bool>(__y)) 583 return false; 584 if (!static_cast<bool>(__x)) 585 return true; 586 return less<_Tp>{}(*__x, *__y); 587 } 588 589 template <class _Tp> 590 inline _LIBCPP_INLINE_VISIBILITY 591 constexpr 592 bool 593 operator==(const optional<_Tp>& __x, nullopt_t) noexcept 594 { 595 return !static_cast<bool>(__x); 596 } 597 598 template <class _Tp> 599 inline _LIBCPP_INLINE_VISIBILITY 600 constexpr 601 bool 602 operator==(nullopt_t, const optional<_Tp>& __x) noexcept 603 { 604 return !static_cast<bool>(__x); 605 } 606 607 template <class _Tp> 608 inline _LIBCPP_INLINE_VISIBILITY 609 constexpr 610 bool 611 operator<(const optional<_Tp>&, nullopt_t) noexcept 612 { 613 return false; 614 } 615 616 template <class _Tp> 617 inline _LIBCPP_INLINE_VISIBILITY 618 constexpr 619 bool 620 operator<(nullopt_t, const optional<_Tp>& __x) noexcept 621 { 622 return static_cast<bool>(__x); 623 } 624 625 template <class _Tp> 626 inline _LIBCPP_INLINE_VISIBILITY 627 constexpr 628 bool 629 operator==(const optional<_Tp>& __x, const _Tp& __v) 630 { 631 return static_cast<bool>(__x) ? *__x == __v : false; 632 } 633 634 template <class _Tp> 635 inline _LIBCPP_INLINE_VISIBILITY 636 constexpr 637 bool 638 operator==(const _Tp& __v, const optional<_Tp>& __x) 639 { 640 return static_cast<bool>(__x) ? *__x == __v : false; 641 } 642 643 template <class _Tp> 644 inline _LIBCPP_INLINE_VISIBILITY 645 constexpr 646 bool 647 operator<(const optional<_Tp>& __x, const _Tp& __v) 648 { 649 return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true; 650 } 651 652 template <class _Tp> 653 inline _LIBCPP_INLINE_VISIBILITY 654 constexpr 655 bool 656 operator<(const _Tp& __v, const optional<_Tp>& __x) 657 { 658 return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false; 659 } 660 661 template <class _Tp> 662 inline _LIBCPP_INLINE_VISIBILITY 663 void 664 swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) 665 { 666 __x.swap(__y); 667 } 668 669 template <class _Tp> 670 inline _LIBCPP_INLINE_VISIBILITY 671 constexpr 672 optional<typename decay<_Tp>::type> 673 make_optional(_Tp&& __v) 674 { 675 return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v)); 676 } 677 678 }}} // namespace std::experimental::__library_fundamentals_v1 679 680 _LIBCPP_BEGIN_NAMESPACE_STD 681 682 template <class _Tp> 683 struct _LIBCPP_TYPE_VIS_ONLY hash<std::experimental::optional<_Tp> > 684 { 685 typedef std::experimental::optional<_Tp> argument_type; 686 typedef size_t result_type; 687 688 _LIBCPP_INLINE_VISIBILITY 689 result_type operator()(const argument_type& __opt) const _NOEXCEPT 690 { 691 return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0; 692 } 693 }; 694 695 _LIBCPP_END_NAMESPACE_STD 696 697 #endif // _LIBCPP_STD_VER > 11 698 699 #endif // _LIBCPP_ARRAY 700
